edsger 0.51.0 → 0.53.0

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

@@ -1,378 +0,0 @@
-/**
- * Integration tests for analyseIntelligence orchestration.
- * Uses dependency injection to mock API calls and AI agent.
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { analyseIntelligence } from '../index.js';
-// ── Helpers ────────────────────────────────────────────────────
-const fakeConfig = {
-    patterns: ['**/*.ts'],
-    exclude: [],
-    severity: 'error',
-    maxFiles: 100,
-    claude: { timeout: 30000 },
-    workflow: {
-        maxConcurrency: 3,
-        pollInterval: 30000,
-        maxRetries: 3,
-        retryCooldown: 300000,
-        workerTimeout: 1800000,
-        maxVerificationIterations: 10,
-    },
-};
-const fakeProduct = {
-    id: 'prod-001',
-    name: 'TestApp',
-    description: 'A test product',
-    features: [],
-};
-function makeCompetitor(name, id, status = 'confirmed') {
-    return {
-        id,
-        product_id: 'prod-001',
-        name,
-        url: `https://${name.toLowerCase()}.com`,
-        app_store_url: null,
-        play_store_url: null,
-        description: `${name} desc`,
-        category: 'tools',
-        status,
-        discovery_source: status === 'suggested' ? 'ai_discovery' : 'manual',
-        discovery_reason: status === 'suggested' ? 'AI found it' : null,
-        notes: null,
-        created_by: 'user-1',
-        created_at: '2026-03-25',
-        updated_at: '2026-03-25',
-    };
-}
-function makeSnapshot(competitorId, id = 'snap-1') {
-    return {
-        id,
-        competitor_id: competitorId,
-        product_id: 'prod-001',
-        features: [],
-        pricing: {},
-        tech_stack: [],
-        app_rating: null,
-        app_review_count: null,
-        app_version: null,
-        app_last_updated: null,
-        recent_reviews: [],
-        social_mentions: {},
-        changes_detected: [],
-        source: 'ai_analysis',
-        raw_data: null,
-        created_at: '2026-03-25',
-    };
-}
-function makeReport(id = 'rpt-1') {
-    return {
-        id,
-        product_id: 'prod-001',
-        report_type: 'competitive',
-        title: 'Test Report',
-        summary: 'Summary',
-        full_report: '# Report',
-        key_findings: [],
-        recommendations: [],
-        competitor_highlights: [],
-        market_signals: [],
-        trends: [],
-        persona_updates: null,
-        pmf_score: null,
-        pmf_signals: null,
-        guidance: null,
-        status: 'completed',
-        snapshot_ids: [],
-        created_by: 'user-1',
-        created_at: '2026-03-25',
-        updated_at: '2026-03-25',
-    };
-}
-function makeContext(confirmed = []) {
-    return {
-        product: fakeProduct,
-        confirmedCompetitors: confirmed,
-        suggestedCompetitors: [],
-        previousSnapshots: new Map(),
-    };
-}
-/** Create mock deps that return the given AI result */
-function makeDeps(aiResult, contextOverride) {
-    const batchCreateCalls = [];
-    const saveSnapCalls = [];
-    const saveRptCalls = [];
-    const updateRptCalls = [];
-    let batchCreateCounter = 0;
-    return {
-        batchCreateCalls,
-        saveSnapCalls,
-        saveRptCalls,
-        updateRptCalls,
-        prepareContext: () => Promise.resolve({
-            context: contextOverride || makeContext(),
-            analysisPrompt: 'fake prompt',
-        }),
-        executeQuery: () => Promise.resolve(aiResult),
-        batchCreate: (_productId, competitors) => {
-            batchCreateCalls.push([_productId, competitors]);
-            return Promise.resolve(competitors.map((c) => makeCompetitor(c.name, `discovered-${batchCreateCounter++}`, 'suggested')));
-        },
-        saveSnap: (snap) => {
-            saveSnapCalls.push([snap]);
-            return Promise.resolve(makeSnapshot(snap.competitor_id, `snap-${saveSnapCalls.length}`));
-        },
-        saveRpt: (report) => {
-            saveRptCalls.push([report]);
-            return Promise.resolve(makeReport(`rpt-${saveRptCalls.length}`));
-        },
-        updateRpt: (_id, updates) => {
-            updateRptCalls.push([_id, updates]);
-            return Promise.resolve(makeReport(_id));
-        },
-    };
-}
-// ============================================================
-// Success: full flow with discovery
-// ============================================================
-void describe('analyseIntelligence — discovery flow', () => {
-    const aiResult = {
-        title: 'Competitive Report',
-        summary: 'Found 2 competitors',
-        full_report: '# Report',
-        key_findings: [
-            {
-                finding: 'Competitor A is growing',
-                severity: 'important',
-                category: 'competitive',
-            },
-        ],
-        recommendations: [
-            {
-                action: 'Add feature X',
-                priority: 'high',
-                effort: 'medium',
-                impact: 'high',
-                rationale: 'Gap',
-            },
-        ],
-        competitor_highlights: [],
-        market_signals: [],
-        trends: [],
-        discovered_competitors: [
-            {
-                name: 'CompA',
-                url: 'https://compa.com',
-                discovery_reason: 'Top alternative',
-            },
-            {
-                name: 'CompB',
-                url: 'https://compb.com',
-                discovery_reason: 'Same category',
-            },
-        ],
-        competitor_snapshots: [
-            {
-                competitor_name: 'CompA',
-                features: [{ name: 'Feat1', description: 'Desc', is_new: true }],
-                app_rating: 4.5,
-            },
-            { competitor_name: 'CompB', features: [], app_rating: 3.8 },
-        ],
-    };
-    void it('should return success status', async () => {
-        const deps = makeDeps(aiResult);
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(result.status, 'success');
-    });
-    void it('should save discovered competitors via batchCreate', async () => {
-        const deps = makeDeps(aiResult);
-        await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(deps.batchCreateCalls.length, 1);
-        const [, competitors] = deps.batchCreateCalls[0];
-        assert.strictEqual(competitors.length, 2);
-        assert.strictEqual(competitors[0].name, 'CompA');
-        assert.strictEqual(competitors[1].name, 'CompB');
-    });
-    void it('should save snapshots matched to discovered competitors', async () => {
-        const deps = makeDeps(aiResult);
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(deps.saveSnapCalls.length, 2);
-        assert.strictEqual(result.snapshots.length, 2);
-    });
-    void it('should save the report', async () => {
-        const deps = makeDeps(aiResult);
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(deps.saveRptCalls.length, 1);
-        assert.ok(result.report);
-    });
-    void it('should return discovered competitors in result', async () => {
-        const deps = makeDeps(aiResult);
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(result.discoveredCompetitors.length, 2);
-    });
-});
-// ============================================================
-// Success: existing competitors (no discovery needed)
-// ============================================================
-void describe('analyseIntelligence — existing competitors', () => {
-    const existing = [makeCompetitor('Linear', 'id-linear')];
-    const aiResult = {
-        title: 'Report',
-        summary: 'Update',
-        full_report: '# R',
-        key_findings: [],
-        recommendations: [],
-        competitor_highlights: [],
-        market_signals: [],
-        trends: [],
-        discovered_competitors: [],
-        competitor_snapshots: [
-            {
-                competitor_id: 'id-linear',
-                competitor_name: 'Linear',
-                features: [],
-                app_rating: 4.6,
-            },
-        ],
-    };
-    void it('should not call batchCreate when no new competitors', async () => {
-        const deps = makeDeps(aiResult, makeContext(existing));
-        await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(deps.batchCreateCalls.length, 0);
-    });
-    void it('should save snapshot matched by ID', async () => {
-        const deps = makeDeps(aiResult, makeContext(existing));
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(result.snapshots.length, 1);
-        const [snapArg] = deps.saveSnapCalls[0];
-        assert.strictEqual(snapArg.competitor_id, 'id-linear');
-    });
-});
-// ============================================================
-// Error: AI returns null
-// ============================================================
-void describe('analyseIntelligence — AI returns null', () => {
-    void it('should return error status', async () => {
-        const deps = makeDeps(null);
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(result.status, 'error');
-        assert.strictEqual(result.report, null);
-        assert.strictEqual(result.discoveredCompetitors.length, 0);
-        assert.strictEqual(result.snapshots.length, 0);
-    });
-});
-// ============================================================
-// Edge: AI returns empty arrays
-// ============================================================
-void describe('analyseIntelligence — empty AI result', () => {
-    const emptyResult = {
-        title: 'Empty',
-        summary: 'Nothing found',
-        full_report: '',
-        key_findings: [],
-        recommendations: [],
-        competitor_highlights: [],
-        market_signals: [],
-        trends: [],
-    };
-    void it('should succeed with no competitors or snapshots', async () => {
-        const deps = makeDeps(emptyResult);
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(result.status, 'success');
-        assert.strictEqual(result.discoveredCompetitors.length, 0);
-        assert.strictEqual(result.snapshots.length, 0);
-        assert.strictEqual(deps.batchCreateCalls.length, 0);
-        assert.strictEqual(deps.saveSnapCalls.length, 0);
-    });
-    void it('should still save a report', async () => {
-        const deps = makeDeps(emptyResult);
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(deps.saveRptCalls.length, 1);
-        assert.ok(result.report);
-    });
-});
-// ============================================================
-// Edge: unmatched snapshots are skipped
-// ============================================================
-void describe('analyseIntelligence — unmatched snapshots', () => {
-    const aiResult = {
-        title: 'R',
-        summary: 'S',
-        full_report: '',
-        key_findings: [],
-        recommendations: [],
-        competitor_highlights: [],
-        market_signals: [],
-        trends: [],
-        discovered_competitors: [],
-        competitor_snapshots: [
-            { competitor_name: 'Totally Unknown Product', features: [] },
-        ],
-    };
-    void it('should skip snapshots for unknown competitors', async () => {
-        const deps = makeDeps(aiResult, makeContext([makeCompetitor('Linear', 'id-linear')]));
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(result.snapshots.length, 0);
-        assert.strictEqual(deps.saveSnapCalls.length, 0);
-    });
-});
-// ============================================================
-// Report update mode
-// ============================================================
-void describe('analyseIntelligence — update existing report', () => {
-    const aiResult = {
-        title: 'Updated',
-        summary: 'Refreshed',
-        full_report: '# Updated',
-        key_findings: [],
-        recommendations: [],
-        competitor_highlights: [],
-        market_signals: [],
-        trends: [],
-    };
-    void it('should call updateRpt instead of saveRpt when reportId given', async () => {
-        const deps = makeDeps(aiResult);
-        await analyseIntelligence({ productId: 'prod-001', reportId: 'existing-rpt' }, fakeConfig, deps);
-        assert.strictEqual(deps.updateRptCalls.length, 1);
-        assert.strictEqual(deps.saveRptCalls.length, 0);
-        const [rptId] = deps.updateRptCalls[0];
-        assert.strictEqual(rptId, 'existing-rpt');
-    });
-});
-// ============================================================
-// Guidance passthrough
-// ============================================================
-void describe('analyseIntelligence — guidance', () => {
-    void it('should pass guidance into report payload', async () => {
-        const aiResult = {
-            title: 'R',
-            summary: 'S',
-            full_report: '',
-            key_findings: [],
-            recommendations: [],
-            competitor_highlights: [],
-            market_signals: [],
-            trends: [],
-        };
-        const deps = makeDeps(aiResult);
-        await analyseIntelligence({ productId: 'prod-001', guidance: 'Focus on pricing' }, fakeConfig, deps);
-        const [reportArg] = deps.saveRptCalls[0];
-        assert.strictEqual(reportArg.guidance, 'Focus on pricing');
-    });
-});
-// ============================================================
-// Exception handling
-// ============================================================
-void describe('analyseIntelligence — exception in deps', () => {
-    void it('should return error when context fetch throws', async () => {
-        const deps = makeDeps(null);
-        deps.prepareContext = () => {
-            return Promise.reject(new Error('Network error'));
-        };
-        const result = await analyseIntelligence({ productId: 'prod-001' }, fakeConfig, deps);
-        assert.strictEqual(result.status, 'error');
-        assert.ok(result.error?.includes('Network error'));
-    });
-});

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

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

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

@@ -1,33 +0,0 @@
-/**
- * Unit tests for intelligence analysis prompt generation.
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { createIntelligencePromptWithContext } from '../prompts.js';
-// ============================================================
-// Context prompt
-// ============================================================
-void describe('createIntelligencePromptWithContext', () => {
-    const contextInfo = '# Context\nProduct: TestApp\n## Competitors\nNone';
-    void it('should include report type', () => {
-        const result = createIntelligencePromptWithContext('p1', contextInfo, 'competitive', true);
-        assert.ok(result.includes('competitive'));
-    });
-    void it('should include discovery instructions when needed', () => {
-        const result = createIntelligencePromptWithContext('p1', contextInfo, 'competitive', true);
-        assert.ok(result.includes('Competitor Discovery Required'));
-    });
-    void it('should use softer discovery language when competitors exist', () => {
-        const result = createIntelligencePromptWithContext('p1', contextInfo, 'competitive', false);
-        assert.ok(!result.includes('Competitor Discovery Required'));
-        assert.ok(result.includes('also look for new entrants'));
-    });
-    void it('should embed the context info', () => {
-        const result = createIntelligencePromptWithContext('p1', contextInfo, 'market', false);
-        assert.ok(result.includes('Product: TestApp'));
-    });
-    void it('should instruct to use web search', () => {
-        const result = createIntelligencePromptWithContext('p1', contextInfo, 'competitive', true);
-        assert.ok(result.includes('web search'));
-    });
-});

package/dist/phases/pr-execution/__tests__/file-assigner.test.d.ts

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