edsger 0.76.0 → 0.78.0

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

@@ -1,142 +0,0 @@
-import { getCompetitors, getSnapshots, } from '../../api/intelligence.js';
-import { getProduct } from '../../api/products.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createIntelligencePromptWithContext } from './prompts.js';
-/**
- * Fetch all context needed for intelligence analysis via MCP endpoints
- */
-export async function fetchIntelligenceContext(productId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching intelligence context for product: ${productId}`);
-        }
-        const [product, allCompetitors] = await Promise.all([
-            getProduct(productId, verbose),
-            getCompetitors(productId, undefined, verbose),
-        ]);
-        const confirmedCompetitors = allCompetitors.filter((c) => c.status === 'confirmed');
-        const suggestedCompetitors = allCompetitors.filter((c) => c.status === 'suggested');
-        // Fetch latest snapshots for confirmed competitors
-        const previousSnapshots = new Map();
-        if (confirmedCompetitors.length > 0) {
-            const snapshotResults = await Promise.all(confirmedCompetitors.map((c) => getSnapshots({ competitorId: c.id, limit: 2 }, verbose)));
-            for (let i = 0; i < confirmedCompetitors.length; i++) {
-                previousSnapshots.set(confirmedCompetitors[i].id, snapshotResults[i]);
-            }
-        }
-        if (verbose) {
-            logInfo(`Intelligence context fetched:`);
-            logInfo(`  Product: ${product.name}`);
-            logInfo(`  Confirmed competitors: ${confirmedCompetitors.length}`);
-            logInfo(`  Suggested competitors: ${suggestedCompetitors.length}`);
-        }
-        return {
-            product,
-            confirmedCompetitors,
-            suggestedCompetitors,
-            previousSnapshots,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch intelligence context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}
-/**
- * Format context into a prompt string for the AI
- */
-export function formatContextForPrompt(context, guidance) {
-    const { product, confirmedCompetitors, previousSnapshots } = context;
-    const issuesList = product.issues && product.issues.length > 0
-        ? product.issues
-            .map((f) => `- **${f.name}**: ${f.description || 'No description'} (Status: ${f.status || 'unknown'})`)
-            .join('\n')
-        : 'No issues listed.';
-    let competitorsSection = '';
-    if (confirmedCompetitors.length > 0) {
-        const competitorEntries = confirmedCompetitors.map((c) => {
-            const snapshots = previousSnapshots.get(c.id) || [];
-            const latestSnapshot = snapshots[0];
-            let snapshotInfo = 'No previous data.';
-            if (latestSnapshot) {
-                const parts = [];
-                if (latestSnapshot.app_rating) {
-                    parts.push(`Rating: ${latestSnapshot.app_rating}`);
-                }
-                if (latestSnapshot.app_review_count) {
-                    parts.push(`Reviews: ${latestSnapshot.app_review_count}`);
-                }
-                if (latestSnapshot.app_version) {
-                    parts.push(`Version: ${latestSnapshot.app_version}`);
-                }
-                if (latestSnapshot.issues?.length) {
-                    parts.push(`Known issues: ${latestSnapshot.issues.length}`);
-                }
-                if (latestSnapshot.pricing?.model) {
-                    parts.push(`Pricing model: ${latestSnapshot.pricing.model}`);
-                }
-                snapshotInfo =
-                    parts.length > 0
-                        ? parts.join(' | ')
-                        : 'Snapshot exists but no structured data.';
-            }
-            return `### ${c.name}
-- **Competitor ID**: \`${c.id}\`
-- **URL**: ${c.url || 'Unknown'}
-- **App Store**: ${c.app_store_url || 'N/A'}
-- **Play Store**: ${c.play_store_url || 'N/A'}
-- **Category**: ${c.category || 'Unknown'}
-- **Description**: ${c.description || 'No description'}
-- **Last snapshot**: ${snapshotInfo}
-${c.notes ? `- **Notes**: ${c.notes}` : ''}`;
-        });
-        competitorsSection = `## Confirmed Competitors (${confirmedCompetitors.length})
-${competitorEntries.join('\n\n')}`;
-    }
-    else {
-        competitorsSection = `## Competitors
-No competitors registered yet. You MUST discover competitors as part of this analysis.`;
-    }
-    const guidanceSection = guidance
-        ? `
-
-## Human Analysis Guidance
-The product owner has provided the following direction. **Follow this guidance closely** — it takes priority over default analysis scope.
-
-${guidance}
-
----`
-        : '';
-    return `# Intelligence Analysis Context
-
-## Product Information
-- **Name**: ${product.name}
-- **Product ID**: ${product.id}
-- **Description**: ${product.description || 'No description provided'}
-
-## Product Issues (${product.issues?.length || 0})
-${issuesList}
-${guidanceSection}
-
-${competitorsSection}
-
----
-
-**Instructions**: Analyze the product above, research competitors online, and produce a comprehensive intelligence report. ${confirmedCompetitors.length === 0 ? 'Since no competitors are registered, start by discovering 5-10 relevant competitors.' : 'Focus on deep analysis of the confirmed competitors, and also look for new competitors to suggest.'}${guidance ? ' Follow the human guidance provided above.' : ''}`;
-}
-/**
- * Prepare the full analysis prompt with all context
- */
-export async function prepareIntelligenceContext(productId, verbose, reportType = 'competitive', guidance) {
-    if (verbose) {
-        logInfo('Fetching intelligence context via MCP endpoints...');
-        if (guidance) {
-            logInfo(`Human guidance provided: "${guidance.substring(0, 80)}${guidance.length > 80 ? '...' : ''}"`);
-        }
-    }
-    const context = await fetchIntelligenceContext(productId, verbose);
-    const contextInfo = formatContextForPrompt(context, guidance);
-    const analysisPrompt = createIntelligencePromptWithContext(productId, contextInfo, reportType, context.confirmedCompetitors.length === 0);
-    return { context, analysisPrompt };
-}

package/dist/phases/intelligence-analysis/index.d.ts

@@ -1,58 +0,0 @@
-import { batchCreateCompetitors, type Competitor, type CompetitorSnapshot, type IntelligenceReport, saveReport, saveSnapshot, updateReport } from '../../api/intelligence.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { prepareIntelligenceContext } from './context.js';
-interface CompetitorRef {
-    id: string;
-    name: string;
-}
-interface SnapshotRef {
-    competitor_id?: string;
-    competitor_name: string;
-}
-/**
- * Build lookup indexes from a list of competitors.
- * Returns idSet (for direct ID validation) and nameToId (for name-based matching).
- */
-export declare function buildCompetitorIndex(competitors: CompetitorRef[]): {
-    idSet: Set<string>;
-    nameToId: Map<string, string>;
-};
-/**
- * Resolve a competitor ID from an AI-returned snapshot using a 4-tier strategy:
- * 1. Direct competitor_id match (AI returned the UUID)
- * 2. Exact name match (case-insensitive)
- * 3. Normalized name match (strip common suffixes like "App", "Inc", ".io")
- * 4. Substring match (either direction)
- */
-export declare function resolveCompetitorId(snap: SnapshotRef, idSet: Set<string>, nameToId: Map<string, string>): string | undefined;
-export interface IntelligenceAnalysisOptions {
-    productId: string;
-    reportType?: string;
-    verbose?: boolean;
-    guidance?: string;
-    reportId?: string;
-}
-export interface IntelligenceAnalysisResult {
-    status: 'success' | 'error';
-    report: IntelligenceReport | null;
-    discoveredCompetitors: Competitor[];
-    snapshots: CompetitorSnapshot[];
-    error?: string;
-}
-/** Injectable dependencies for testing. Production code uses the defaults. */
-export interface IntelligenceDeps {
-    prepareContext: typeof prepareIntelligenceContext;
-    executeQuery: (currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean, cwd?: string) => Promise<Record<string, unknown> | null>;
-    batchCreate: typeof batchCreateCompetitors;
-    saveSnap: typeof saveSnapshot;
-    saveRpt: typeof saveReport;
-    updateRpt: typeof updateReport;
-}
-/**
- * Run a full intelligence analysis:
- * 1. Fetch context (product + existing competitors + previous snapshots)
- * 2. AI agent researches competitors and market via web search
- * 3. Save discovered competitors, snapshots, and report
- */
-export declare function analyseIntelligence(options: IntelligenceAnalysisOptions, config: EdsgerConfig, deps?: IntelligenceDeps): Promise<IntelligenceAnalysisResult>;
-export {};

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

@@ -1,244 +0,0 @@
-import { getGitHubConfigByProduct } from '../../api/github.js';
-import { batchCreateCompetitors, saveReport, saveSnapshot, updateReport, } from '../../api/intelligence.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
-import { executeIntelligenceQuery } from './agent.js';
-import { prepareIntelligenceContext } from './context.js';
-import { createIntelligenceSystemPrompt } from './prompts.js';
-/**
- * Build lookup indexes from a list of competitors.
- * Returns idSet (for direct ID validation) and nameToId (for name-based matching).
- */
-export function buildCompetitorIndex(competitors) {
-    const idSet = new Set(competitors.map((c) => c.id));
-    const nameToId = new Map();
-    for (const c of competitors) {
-        nameToId.set(c.name.toLowerCase(), c.id);
-        // Also index without common suffixes for fuzzy matching
-        const normalized = c.name
-            .toLowerCase()
-            .replace(/\s*(app|inc|io|\.com|ltd|co)\.?$/i, '')
-            .trim();
-        if (normalized !== c.name.toLowerCase()) {
-            nameToId.set(normalized, c.id);
-        }
-    }
-    return { idSet, nameToId };
-}
-/**
- * Resolve a competitor ID from an AI-returned snapshot using a 4-tier strategy:
- * 1. Direct competitor_id match (AI returned the UUID)
- * 2. Exact name match (case-insensitive)
- * 3. Normalized name match (strip common suffixes like "App", "Inc", ".io")
- * 4. Substring match (either direction)
- */
-export function resolveCompetitorId(snap, idSet, nameToId) {
-    // 1. Direct ID match
-    if (snap.competitor_id && idSet.has(snap.competitor_id)) {
-        return snap.competitor_id;
-    }
-    // 2. Exact name match (case-insensitive)
-    const exactMatch = nameToId.get(snap.competitor_name.toLowerCase());
-    if (exactMatch) {
-        return exactMatch;
-    }
-    // 3. Normalized name match (strip AI-returned name suffixes)
-    const normalized = snap.competitor_name
-        .toLowerCase()
-        .replace(/\s*(app|inc|io|\.com|ltd|co)\.?$/i, '')
-        .trim();
-    const normalizedMatch = nameToId.get(normalized);
-    if (normalizedMatch) {
-        return normalizedMatch;
-    }
-    // 4. Substring match
-    const snapLower = snap.competitor_name.toLowerCase();
-    for (const [name, id] of nameToId) {
-        if (snapLower.includes(name) || name.includes(snapLower)) {
-            return id;
-        }
-    }
-    return undefined;
-}
-const defaultDeps = {
-    prepareContext: prepareIntelligenceContext,
-    executeQuery: executeIntelligenceQuery,
-    batchCreate: batchCreateCompetitors,
-    saveSnap: saveSnapshot,
-    saveRpt: saveReport,
-    updateRpt: updateReport,
-};
-/**
- * Run a full intelligence analysis:
- * 1. Fetch context (product + existing competitors + previous snapshots)
- * 2. AI agent researches competitors and market via web search
- * 3. Save discovered competitors, snapshots, and report
- */
-// eslint-disable-next-line complexity
-export async function analyseIntelligence(options, config, deps = defaultDeps) {
-    const { productId, reportType = 'competitive', verbose, guidance, reportId, } = options;
-    let repoCwd;
-    let analysisSucceeded = false;
-    try {
-        // 1. Clone product repo if GitHub is configured
-        try {
-            const githubConfig = await getGitHubConfigByProduct(productId, verbose);
-            if (githubConfig.configured &&
-                githubConfig.token &&
-                githubConfig.owner &&
-                githubConfig.repo) {
-                const workspaceRoot = ensureWorkspaceDir();
-                const { repoPath } = cloneIssueRepo(workspaceRoot, `intel-${productId}`, githubConfig.owner, githubConfig.repo, githubConfig.token);
-                repoCwd = repoPath;
-                logInfo(`Repository cloned to: ${repoCwd}`);
-            }
-            else {
-                logInfo(`No GitHub repo configured, running without codebase access. ${githubConfig.message || ''}`);
-            }
-        }
-        catch (error) {
-            logInfo(`Could not clone repo (continuing without codebase): ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const hasCodebase = !!repoCwd;
-        // 2. Prepare context
-        logInfo('Preparing intelligence analysis context...');
-        const { context, analysisPrompt } = await deps.prepareContext(productId, verbose, reportType, guidance);
-        // Only discover competitors on 'competitive' or 'comprehensive' type,
-        // and only when no competitors exist at all (confirmed OR suggested)
-        const hasAnyCompetitors = context.confirmedCompetitors.length > 0 ||
-            context.suggestedCompetitors.length > 0;
-        const isDiscoveryType = reportType === 'competitive' || reportType === 'comprehensive';
-        const needsDiscovery = !hasAnyCompetitors && isDiscoveryType;
-        const systemPrompt = await createIntelligenceSystemPrompt(needsDiscovery, hasCodebase);
-        // 3. Run AI analysis
-        logInfo(needsDiscovery
-            ? 'No competitors found — AI will discover competitors first...'
-            : `Analyzing ${context.confirmedCompetitors.length} confirmed competitors...`);
-        const analysisResult = await deps.executeQuery(analysisPrompt, systemPrompt, config, verbose, repoCwd);
-        if (!analysisResult) {
-            logError('Intelligence analysis returned no results');
-            return {
-                status: 'error',
-                report: null,
-                discoveredCompetitors: [],
-                snapshots: [],
-                error: 'Analysis returned no results',
-            };
-        }
-        // 3. Save discovered competitors (only for competitive/comprehensive types)
-        let discoveredCompetitors = [];
-        const rawDiscovered = isDiscoveryType
-            ? analysisResult.discovered_competitors
-            : undefined;
-        if (rawDiscovered && rawDiscovered.length > 0) {
-            logInfo(`Saving ${rawDiscovered.length} discovered competitors...`);
-            discoveredCompetitors = await deps.batchCreate(productId, rawDiscovered.map((c) => ({
-                name: c.name,
-                url: c.url,
-                app_store_url: c.app_store_url,
-                play_store_url: c.play_store_url,
-                description: c.description,
-                category: c.category,
-                status: 'suggested',
-                discovery_source: 'ai_discovery',
-                discovery_reason: c.discovery_reason,
-            })), verbose);
-            logSuccess(`Saved ${discoveredCompetitors.length} discovered competitors`);
-        }
-        // 4. Save competitor snapshots
-        const savedSnapshots = [];
-        const rawSnapshots = analysisResult.competitor_snapshots;
-        if (rawSnapshots && rawSnapshots.length > 0) {
-            const allCompetitors = [
-                ...context.confirmedCompetitors,
-                ...discoveredCompetitors,
-            ];
-            const { idSet, nameToId } = buildCompetitorIndex(allCompetitors);
-            logInfo(`Saving ${rawSnapshots.length} competitor snapshots...`);
-            for (const snap of rawSnapshots) {
-                const competitorId = resolveCompetitorId(snap, idSet, nameToId);
-                if (!competitorId) {
-                    logWarning(`Snapshot for unmatched competitor "${snap.competitor_name}" — skipping`);
-                    continue;
-                }
-                const saved = await deps.saveSnap({
-                    competitor_id: competitorId,
-                    product_id: productId,
-                    issues: snap.issues,
-                    pricing: snap.pricing,
-                    tech_stack: snap.tech_stack,
-                    app_rating: snap.app_rating,
-                    app_review_count: snap.app_review_count,
-                    app_version: snap.app_version,
-                    recent_reviews: snap.recent_reviews,
-                    social_mentions: snap.social_mentions,
-                    changes_detected: snap.changes_detected,
-                    source: 'ai_analysis',
-                }, verbose);
-                if (saved) {
-                    savedSnapshots.push(saved);
-                }
-            }
-            logSuccess(`Saved ${savedSnapshots.length} snapshots`);
-        }
-        // 5. Save or update report
-        const snapshotIds = savedSnapshots.map((s) => s.id);
-        const reportPayload = {
-            product_id: productId,
-            report_type: reportType,
-            title: analysisResult.title ||
-                `Intelligence Report — ${reportType}`,
-            summary: analysisResult.summary || undefined,
-            full_report: analysisResult.full_report || undefined,
-            key_findings: analysisResult.key_findings || [],
-            recommendations: analysisResult.recommendations || [],
-            competitor_highlights: analysisResult.competitor_highlights || [],
-            market_signals: analysisResult.market_signals || [],
-            trends: analysisResult.trends || [],
-            persona_updates: analysisResult.persona_updates || undefined,
-            pmf_score: analysisResult.pmf_score || undefined,
-            pmf_signals: analysisResult.pmf_signals || undefined,
-            guidance: guidance || undefined,
-            status: 'completed',
-            snapshot_ids: snapshotIds,
-        };
-        let report = null;
-        if (reportId) {
-            logInfo('Updating existing report...');
-            report = await deps.updateRpt(reportId, reportPayload, verbose);
-        }
-        else {
-            logInfo('Saving intelligence report...');
-            report = await deps.saveRpt(reportPayload, verbose);
-        }
-        if (report) {
-            logSuccess(`Intelligence report saved: ${report.title}`);
-        }
-        else {
-            logWarning('Report could not be saved');
-        }
-        analysisSucceeded = true;
-        return {
-            status: 'success',
-            report,
-            discoveredCompetitors,
-            snapshots: savedSnapshots,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Intelligence analysis failed: ${errorMessage}`);
-        return {
-            status: 'error',
-            report: null,
-            discoveredCompetitors: [],
-            snapshots: [],
-            error: errorMessage,
-        };
-    }
-    finally {
-        if (analysisSucceeded) {
-            cleanupIssueRepo(repoCwd);
-        }
-    }
-}

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

@@ -1,2 +0,0 @@
-export declare const createIntelligenceSystemPrompt: (needsDiscovery: boolean, hasCodebase?: boolean, projectDir?: string) => Promise<string>;
-export declare const createIntelligencePromptWithContext: (productId: string, contextInfo: string, reportType: string, needsDiscovery: boolean) => string;

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

@@ -1,62 +0,0 @@
-import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createIntelligenceSystemPrompt = async (needsDiscovery, hasCodebase = false, projectDir) => {
-    const skill = await resolveSkill('phase/intelligence-analysis', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/intelligence-analysis');
-    }
-    let { prompt } = skill;
-    prompt = processConditionals(prompt, {
-        needsDiscovery,
-        hasCodebase,
-    });
-    return `${prompt}
-
-${OUTPUT_CONTRACTS['intelligence-analysis']}`;
-};
-export const createIntelligencePromptWithContext = (productId, contextInfo, reportType, needsDiscovery) => {
-    let discoveryInstructions = '';
-    if (needsDiscovery) {
-        discoveryInstructions = `
-
-**IMPORTANT — Competitor Discovery Required**: No competitors are registered for this product yet. Your FIRST task is to discover 5-10 relevant competitors by searching the web. Include them in the "discovered_competitors" array in your output so they can be saved for future tracking.`;
-    }
-    else if (reportType === 'competitive' || reportType === 'comprehensive') {
-        discoveryInstructions = `
-
-**Competitor Discovery**: While analyzing confirmed competitors, also look for new entrants or products that should be tracked. Include any new finds in the "discovered_competitors" array.`;
-    }
-    else {
-        let focusLabel;
-        if (reportType === 'research') {
-            focusLabel = 'papers and reports';
-        }
-        else if (reportType === 'market') {
-            focusLabel = 'market signals and trends';
-        }
-        else {
-            focusLabel = 'product-market fit metrics';
-        }
-        discoveryInstructions = `
-
-**Note**: This is a ${reportType} analysis — focus on ${focusLabel}. Do NOT discover new competitors. Set "discovered_competitors" to an empty array.`;
-    }
-    const researchInstructions = reportType === 'research'
-        ? `
-
-**Research Focus**: Search for the latest academic papers, industry reports, and technical deep-dives relevant to this product's domain. Use queries like:
-- "site:arxiv.org {relevant keywords}"
-- "{industry} report 2026 PDF"
-- "{technology} whitepaper"
-- "{domain} research trends"
-Focus on: emerging techniques, state-of-the-art approaches, industry benchmarks, and findings that could inform product direction. Include paper titles, authors, publication dates, and key takeaways in the market_signals array.`
-        : '';
-    return `Please conduct a comprehensive ${reportType} intelligence analysis for this product.
-${discoveryInstructions}${researchInstructions}
-
-${contextInfo}
-
-Use web search extensively to gather real-time data. Return the results as a JSON object in the format specified in your instructions.`;
-};

package/dist/phases/issue-analysis/agent.d.ts

@@ -1,21 +0,0 @@
-import { type EdsgerConfig, type WithExecutionSessionId } from '../../types/index.js';
-interface ParsedAnalysisResult {
-    analysis?: any;
-    error?: string;
-}
-/** Analysis result with typed session ID */
-export type AnalysisQueryResult = Record<string, unknown> & WithExecutionSessionId;
-/**
- * Parse the structured analysis response.
- *
- * Two acceptable forms:
- *   1. Sentinel-delimited markdown plan + a separate JSON metadata block (preferred).
- *   2. A single JSON object whose `analysis.execution_plan` field carries
- *      the full plan as an escaped string (legacy / fallback).
- *
- * The first form is robust to unescaped quotes/newlines in the markdown,
- * which models frequently get wrong when the plan is large.
- */
-export declare function parseAnalysisResult(responseText: string): ParsedAnalysisResult;
-export declare function executeAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<AnalysisQueryResult | null>;
-export {};