edsger 0.45.1 → 0.47.0

package/dist/phases/app-store-generation/index.js

@@ -13,9 +13,8 @@ function truncateKeywords(keywords) {
     }
     return keywords.slice(0, 100).replace(/,[^,]*$/, '');
 }
-export const generateAppStoreAssets = async (options, config
 // eslint-disable-next-line complexity
-) => {
+export const generateAppStoreAssets = async (options, config) => {
     const { productId, targetStore, screenshotsOnly, listingsOnly, verbose } = options;
     if (verbose) {
         logInfo(`Starting app store generation for product: ${productId}`);

package/dist/phases/branch-planning/index.js

@@ -116,9 +116,8 @@ async function persistBranches(sortedBranches, featureId, verbose) {
         }
     }
 }
-export const planFeatureBranches = async (options, config
 // eslint-disable-next-line complexity
-) => {
+export const planFeatureBranches = async (options, config) => {
     const { featureId, verbose, replaceExisting } = options;
     if (verbose) {
         logInfo(`Starting branch planning for feature ID: ${featureId}`);

package/dist/phases/bug-fixing/analyzer.js

@@ -32,9 +32,8 @@ async function* prompt(bugFixPrompt) {
         setTimeout(res, 10000);
     });
 }
-export const fixTestFailures = async (options, config
 // eslint-disable-next-line complexity
-) => {
+export const fixTestFailures = async (options, config) => {
     const { featureId, testErrors, attemptNumber = 1, verbose } = options;
     if (verbose) {
         logInfo(`Starting bug fixing for feature ID: ${featureId} (Attempt ${attemptNumber})`);

package/dist/phases/code-implementation/index.js

@@ -170,9 +170,8 @@ message, lastAssistantResponse, featureId, verbose
     }
     return null;
 }
-export const implementFeatureCode = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const implementFeatureCode = async (options, config, checklistContext) => {
     const { featureId, verbose, baseBranch = 'main' } = options;
     if (verbose) {
         logInfo(`Starting code implementation for feature ID: ${featureId}`);

package/dist/phases/code-refine/index.js

@@ -41,9 +41,8 @@ export const MAX_REFINE_ITERATIONS = 10;
  * Similar to technical-design, this includes an iterative improvement cycle:
  * refine → verification → improve → re-refine (if needed)
  */
-export const refineCodeFromPRFeedback = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const refineCodeFromPRFeedback = async (options, config, checklistContext) => {
     const { featureId, githubToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting code refine for feature ID: ${featureId}`);

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

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

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

@@ -0,0 +1,101 @@
+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/code-review/index.js

@@ -67,9 +67,8 @@ baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose) {
 /**
  * Main code review function
  */
-export const reviewPullRequest = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const reviewPullRequest = async (options, config, checklistContext) => {
     const { featureId, githubToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting code review for feature ID: ${featureId}`);

package/dist/phases/code-testing/analyzer.js

@@ -31,9 +31,8 @@ async function* prompt(testingPrompt) {
         setTimeout(res, 10000);
     });
 }
-export const writeCodeTests = async (options, config
 // eslint-disable-next-line complexity
-) => {
+export const writeCodeTests = async (options, config) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting code testing phase for feature ID: ${featureId}`);

package/dist/phases/feature-analysis/index.js

@@ -6,9 +6,8 @@ import { executeAnalysisQuery, parseAnalysisResult } from './agent.js';
 import { prepareAnalysisContext } from './context.js';
 import { buildAnalysisResult, deleteArtifacts, deleteSpecificArtifacts, getAllDraftArtifactIds, resetReadyArtifactsToDraft, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, } from './outcome.js';
 import { createFeatureAnalysisSystemPrompt } from './prompts.js';
-export const analyseFeature = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const analyseFeature = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting feature analysis for feature ID: ${featureId}`);

package/dist/phases/functional-testing/analyzer.js

@@ -326,9 +326,8 @@ async function saveTestResults(featureId, testStatus, structuredTestResult, last
     }
     return testReportResult;
 }
-export const runFunctionalTesting = async (options, config, checklistContext
 // eslint-disable-next-line complexity
-) => {
+export const runFunctionalTesting = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting functional testing for feature ID: ${featureId}`);

package/dist/phases/growth-analysis/index.js

@@ -49,9 +49,8 @@ contentSuggestions) {
     }
     return plans;
 }
-export const analyseGrowth = async (options, config
 // eslint-disable-next-line complexity
-) => {
+export const analyseGrowth = async (options, config) => {
     const { productId, verbose, guidance, analysisId } = options;
     if (verbose) {
         logInfo(`Starting growth analysis for product ID: ${productId}`);

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

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

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

@@ -0,0 +1,192 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+/**
+ * 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

@@ -0,0 +1,154 @@
+/**
+ * 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

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