edsger 0.45.0 → 0.46.0

package/dist/phases/code-review/__tests__/diff-utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/phases/code-review/__tests__/diff-utils.test.js

@@ -1,101 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { buildLineToPositionMap, findClosestPosition } from '../diff-utils.js';
-void describe('buildLineToPositionMap', () => {
-    void it('maps simple additions correctly', () => {
-        const patch = `@@ -1,3 +1,4 @@
- line 1
-+new line
- line 2
- line 3`;
-        const map = buildLineToPositionMap(patch);
-        // line 1 is at position 1 (new file line 1)
-        assert.strictEqual(map.get(1), 1);
-        // new line is at position 2 (new file line 2)
-        assert.strictEqual(map.get(2), 2);
-        // line 2 is at position 3 (new file line 3)
-        assert.strictEqual(map.get(3), 3);
-        // line 3 is at position 4 (new file line 4)
-        assert.strictEqual(map.get(4), 4);
-    });
-    void it('handles deletions - deleted lines have no new file line number', () => {
-        const patch = `@@ -1,3 +1,2 @@
- line 1
--deleted line
- line 3`;
-        const map = buildLineToPositionMap(patch);
-        assert.strictEqual(map.get(1), 1);
-        // deleted line takes position 2 but no new line
-        // line 3 in old file becomes line 2 in new file, position 3
-        assert.strictEqual(map.get(2), 3);
-    });
-    void it('handles multiple hunks', () => {
-        const patch = `@@ -1,2 +1,2 @@
- line 1
-+added
-@@ -10,2 +10,2 @@
- line 10
-+added at 11`;
-        const map = buildLineToPositionMap(patch);
-        // First hunk: line 1 -> pos 1, added -> pos 2
-        assert.strictEqual(map.get(1), 1);
-        assert.strictEqual(map.get(2), 2);
-        // Second hunk: line 10 -> pos 3, added at 11 -> pos 4
-        assert.strictEqual(map.get(10), 3);
-        assert.strictEqual(map.get(11), 4);
-    });
-    void it('returns empty map for patch with only hunk header', () => {
-        const patch = '@@ -0,0 +1 @@';
-        const map = buildLineToPositionMap(patch);
-        // Hunk header only, no content lines
-        assert.strictEqual(map.size, 0);
-    });
-    void it('handles hunk starting at line other than 1', () => {
-        const patch = `@@ -50,3 +50,3 @@
- context
--old
-+new`;
-        const map = buildLineToPositionMap(patch);
-        assert.strictEqual(map.get(50), 1);
-        // -old takes position 2 (no new line)
-        // +new takes position 3, new file line 51
-        assert.strictEqual(map.get(51), 3);
-    });
-});
-void describe('findClosestPosition', () => {
-    void it('returns exact match when available', () => {
-        const map = new Map([
-            [10, 5],
-            [11, 6],
-            [12, 7],
-        ]);
-        const result = findClosestPosition(11, map);
-        assert.deepStrictEqual(result, { position: 6, actualLine: 11 });
-    });
-    void it('returns nearby line below first', () => {
-        const map = new Map([
-            [10, 5],
-            [15, 8],
-        ]);
-        // Line 12 not in map, closest below is 15 (offset 3)
-        // closest above is 10 (offset 2) - but we check below first at each offset
-        // offset 1: check 13 (no), check 11 (no)
-        // offset 2: check 14 (no), check 10 (yes!)
-        const result = findClosestPosition(12, map);
-        assert.deepStrictEqual(result, { position: 5, actualLine: 10 });
-    });
-    void it('returns null when no line within range', () => {
-        const map = new Map([
-            [1, 1],
-            [100, 50],
-        ]);
-        // Line 50 is too far from both 1 and 100
-        const result = findClosestPosition(50, map);
-        assert.strictEqual(result, null);
-    });
-    void it('returns null for empty map', () => {
-        const map = new Map();
-        const result = findClosestPosition(5, map);
-        assert.strictEqual(result, null);
-    });
-});

package/dist/phases/intelligence-analysis/__tests__/context.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for intelligence analysis context formatting.
- */
-export {};

package/dist/phases/intelligence-analysis/__tests__/context.test.js

@@ -1,192 +0,0 @@
-/**
- * Unit tests for intelligence analysis context formatting.
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { formatContextForPrompt, } from '../context.js';
-const makeContext = (overrides = {}) => ({
-    product: {
-        id: 'prod-001',
-        name: 'Edsger',
-        description: 'AI-powered software development automation.',
-        features: [
-            {
-                name: 'Code Generation',
-                description: 'AI writes code',
-                status: 'shipped',
-            },
-            {
-                name: 'Growth Analysis',
-                description: 'Marketing automation',
-                status: 'shipped',
-            },
-        ],
-    },
-    confirmedCompetitors: [],
-    suggestedCompetitors: [],
-    previousSnapshots: new Map(),
-    ...overrides,
-});
-const makeCompetitor = (name, id = `comp-${name.toLowerCase()}`) => ({
-    id,
-    product_id: 'prod-001',
-    name,
-    url: `https://${name.toLowerCase()}.com`,
-    app_store_url: null,
-    play_store_url: null,
-    description: `${name} description`,
-    category: 'developer-tools',
-    status: 'confirmed',
-    discovery_source: 'ai_discovery',
-    discovery_reason: 'Frequently compared',
-    notes: null,
-    created_by: 'user-1',
-    created_at: '2026-03-25',
-    updated_at: '2026-03-25',
-});
-// ============================================================
-// Product info in context
-// ============================================================
-void describe('formatContextForPrompt — product info', () => {
-    void it('should include product name', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('Edsger'));
-    });
-    void it('should include product description', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('AI-powered software development automation'));
-    });
-    void it('should include product ID', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('prod-001'));
-    });
-    void it('should list features with bold names', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('**Code Generation**'));
-        assert.ok(result.includes('**Growth Analysis**'));
-    });
-    void it('should show feature count', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('Product Features (2)'));
-    });
-    void it('should handle empty features', () => {
-        const ctx = makeContext({
-            product: { id: 'p1', name: 'X', description: '', features: [] },
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('No features listed'));
-    });
-    void it('should handle missing description', () => {
-        const ctx = makeContext({
-            product: {
-                id: 'p1',
-                name: 'X',
-                description: undefined,
-                features: [],
-            },
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('No description provided'));
-    });
-});
-// ============================================================
-// No competitors — discovery prompt
-// ============================================================
-void describe('formatContextForPrompt — no competitors', () => {
-    void it('should indicate no competitors registered', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('No competitors registered yet'));
-    });
-    void it('should instruct to discover competitors', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(result.includes('discover'));
-    });
-});
-// ============================================================
-// With confirmed competitors
-// ============================================================
-void describe('formatContextForPrompt — with confirmed competitors', () => {
-    const competitor = makeCompetitor('Linear');
-    void it('should show competitor name as heading', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('### Linear'));
-    });
-    void it('should show competitor ID', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('comp-linear'));
-    });
-    void it('should show competitor URL', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('https://linear.com'));
-    });
-    void it('should show confirmed count', () => {
-        const ctx = makeContext({
-            confirmedCompetitors: [makeCompetitor('A'), makeCompetitor('B')],
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('Confirmed Competitors (2)'));
-    });
-    void it('should show N/A for missing app store URLs', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('App Store**: N/A'));
-    });
-    void it('should include snapshot data when available', () => {
-        const snapshots = new Map();
-        snapshots.set('comp-linear', [
-            {
-                id: 'snap-1',
-                competitor_id: 'comp-linear',
-                product_id: 'prod-001',
-                features: [
-                    { name: 'Issues', description: 'Issue tracking', is_new: false },
-                ],
-                pricing: { model: 'freemium' },
-                tech_stack: [],
-                app_rating: 4.5,
-                app_review_count: 1200,
-                app_version: '2.0',
-                app_last_updated: null,
-                recent_reviews: [],
-                social_mentions: {},
-                changes_detected: [],
-                source: 'ai_analysis',
-                raw_data: null,
-                created_at: '2026-03-25',
-            },
-        ]);
-        const ctx = makeContext({
-            confirmedCompetitors: [competitor],
-            previousSnapshots: snapshots,
-        });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('Rating: 4.5'));
-        assert.ok(result.includes('Reviews: 1200'));
-        assert.ok(result.includes('Pricing model: freemium'));
-    });
-    void it('should show "No previous data" without snapshots', () => {
-        const ctx = makeContext({ confirmedCompetitors: [competitor] });
-        const result = formatContextForPrompt(ctx);
-        assert.ok(result.includes('No previous data'));
-    });
-});
-// ============================================================
-// Human guidance
-// ============================================================
-void describe('formatContextForPrompt — guidance', () => {
-    void it('should include guidance when provided', () => {
-        const result = formatContextForPrompt(makeContext(), 'Focus on pricing changes');
-        assert.ok(result.includes('Focus on pricing changes'));
-    });
-    void it('should have priority callout for guidance', () => {
-        const result = formatContextForPrompt(makeContext(), 'Focus on pricing');
-        assert.ok(result.includes('Follow this guidance closely'));
-    });
-    void it('should not include guidance section when absent', () => {
-        const result = formatContextForPrompt(makeContext());
-        assert.ok(!result.includes('Human Analysis Guidance'));
-    });
-});

package/dist/phases/intelligence-analysis/__tests__/matching.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Unit tests for competitor snapshot matching logic.
- *
- * Tests the PRODUCTION resolveCompetitorId and buildCompetitorIndex
- * functions exported from index.ts.
- *
- * The matching uses a 4-tier strategy:
- * 1. Direct competitor_id match
- * 2. Exact name match (case-insensitive)
- * 3. Normalized name match (strip suffixes like "App", "Inc")
- * 4. Substring match
- */
-export {};

package/dist/phases/intelligence-analysis/__tests__/matching.test.js

@@ -1,154 +0,0 @@
-/**
- * Unit tests for competitor snapshot matching logic.
- *
- * Tests the PRODUCTION resolveCompetitorId and buildCompetitorIndex
- * functions exported from index.ts.
- *
- * The matching uses a 4-tier strategy:
- * 1. Direct competitor_id match
- * 2. Exact name match (case-insensitive)
- * 3. Normalized name match (strip suffixes like "App", "Inc")
- * 4. Substring match
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { buildCompetitorIndex, resolveCompetitorId } from '../index.js';
-const competitors = [
-    { id: 'id-linear', name: 'Linear' },
-    { id: 'id-cursor', name: 'Cursor' },
-    { id: 'id-github-copilot', name: 'GitHub Copilot' },
-    { id: 'id-vercel', name: 'Vercel Inc' },
-];
-const { idSet, nameToId } = buildCompetitorIndex(competitors);
-// ============================================================
-// buildCompetitorIndex
-// ============================================================
-void describe('buildCompetitorIndex', () => {
-    void it('should populate idSet with all competitor IDs', () => {
-        assert.strictEqual(idSet.size, 4);
-        assert.ok(idSet.has('id-linear'));
-        assert.ok(idSet.has('id-cursor'));
-        assert.ok(idSet.has('id-github-copilot'));
-        assert.ok(idSet.has('id-vercel'));
-    });
-    void it('should index exact names (lowercased)', () => {
-        assert.strictEqual(nameToId.get('linear'), 'id-linear');
-        assert.strictEqual(nameToId.get('cursor'), 'id-cursor');
-        assert.strictEqual(nameToId.get('github copilot'), 'id-github-copilot');
-    });
-    void it('should index normalized names (suffix stripped)', () => {
-        // "Vercel Inc" → "vercel" should also be indexed
-        assert.strictEqual(nameToId.get('vercel'), 'id-vercel');
-    });
-    void it('should not double-index when name has no suffix', () => {
-        // "Linear" has no suffix to strip, so only "linear" should be in map
-        // Count entries for id-linear
-        let count = 0;
-        for (const [, id] of nameToId) {
-            if (id === 'id-linear') {
-                count++;
-            }
-        }
-        assert.strictEqual(count, 1);
-    });
-    void it('should handle empty list', () => {
-        const { idSet: emptyIds, nameToId: emptyNames } = buildCompetitorIndex([]);
-        assert.strictEqual(emptyIds.size, 0);
-        assert.strictEqual(emptyNames.size, 0);
-    });
-});
-// ============================================================
-// Tier 1: Direct ID match
-// ============================================================
-void describe('resolveCompetitorId — direct ID match', () => {
-    void it('should match by exact competitor_id', () => {
-        const result = resolveCompetitorId({ competitor_id: 'id-linear', competitor_name: 'Whatever' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-linear');
-    });
-    void it('should ignore invalid competitor_id and fall through to name', () => {
-        const result = resolveCompetitorId({ competitor_id: 'id-nonexistent', competitor_name: 'Linear' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-linear');
-    });
-    void it('should handle undefined competitor_id', () => {
-        const result = resolveCompetitorId({ competitor_name: 'Linear' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-linear');
-    });
-    void it('should prefer ID over name when both match different competitors', () => {
-        // If AI returns id for Cursor but name "Linear", ID wins
-        const result = resolveCompetitorId({ competitor_id: 'id-cursor', competitor_name: 'Linear' }, idSet, nameToId);
-        assert.strictEqual(result, 'id-cursor');
-    });
-});
-// ============================================================
-// Tier 2: Exact name match (case-insensitive)
-// ============================================================
-void describe('resolveCompetitorId — exact name match', () => {
-    void it('should match exact name', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Linear' }, idSet, nameToId), 'id-linear');
-    });
-    void it('should match case-insensitively', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'linear' }, idSet, nameToId), 'id-linear');
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'LINEAR' }, idSet, nameToId), 'id-linear');
-    });
-    void it('should match multi-word names', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'GitHub Copilot' }, idSet, nameToId), 'id-github-copilot');
-    });
-    void it('should match multi-word names case-insensitively', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'github copilot' }, idSet, nameToId), 'id-github-copilot');
-    });
-});
-// ============================================================
-// Tier 3: Normalized name match (strip suffixes)
-// ============================================================
-void describe('resolveCompetitorId — normalized name match', () => {
-    void it('should match "Vercel" against "Vercel Inc"', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Vercel' }, idSet, nameToId), 'id-vercel');
-    });
-    void it('should match "Linear App" against "Linear"', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Linear App' }, idSet, nameToId), 'id-linear');
-    });
-    void it('should match with ".io" suffix stripped', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-render', name: 'Render.io' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Render' }, ids, names), 'id-render');
-    });
-    void it('should match with ".com" suffix stripped', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-netlify', name: 'Netlify.com' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Netlify' }, ids, names), 'id-netlify');
-    });
-    void it('should match with "Ltd" suffix stripped', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-acme', name: 'Acme Ltd' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Acme' }, ids, names), 'id-acme');
-    });
-});
-// ============================================================
-// Tier 4: Substring match
-// ============================================================
-void describe('resolveCompetitorId — substring match', () => {
-    void it('should match when snapshot name contains competitor name', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Cursor AI Editor' }, idSet, nameToId), 'id-cursor');
-    });
-    void it('should match when competitor name contains snapshot name', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([
-            { id: 'id-ghc', name: 'GitHub Copilot Enterprise' },
-        ]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'github copilot' }, ids, names), 'id-ghc');
-    });
-});
-// ============================================================
-// No match
-// ============================================================
-void describe('resolveCompetitorId — no match', () => {
-    void it('should return undefined for unknown competitor', () => {
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Completely Unknown Tool' }, idSet, nameToId), undefined);
-    });
-    void it('should return undefined with empty index', () => {
-        const { idSet: ids, nameToId: names } = buildCompetitorIndex([]);
-        assert.strictEqual(resolveCompetitorId({ competitor_name: 'Linear' }, ids, names), undefined);
-    });
-});

package/dist/phases/intelligence-analysis/__tests__/orchestration.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Integration tests for analyseIntelligence orchestration.
- * Uses dependency injection to mock API calls and AI agent.
- */
-export {};