edsger 0.54.0 → 0.55.0

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

@@ -171,7 +171,6 @@ message, lastAssistantResponse, issueId, verbose
     }
     return null;
 }
-// eslint-disable-next-line complexity
 export const implementIssueCode = async (options, config, checklistContext) => {
     const { issueId, verbose } = options;
     // Resolve the repo's default branch (handles forks where default is master, etc.).

package/dist/phases/code-implementation-verification/agent.js

@@ -125,7 +125,12 @@ function parseVerificationResult(responseText, verbose) {
 /**
  * Process assistant messages to accumulate response text
  */
-function processAssistantContent(content, responseAccumulator, verbose) {
+function processAssistantContent(
+// SDK 0.2.124+ tightened the BetaContentBlock union; accept the wider
+// shape and narrow at use sites. This helper only reads fields that
+// exist on the `text` and `tool_use` variants.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+content, responseAccumulator, verbose) {
     if (content.type === 'text' && content.text) {
         responseAccumulator.text += `${content.text}\n`;
         logDebug(`🔍 ${content.text}`, verbose);

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

@@ -42,7 +42,6 @@ export const MAX_REFINE_ITERATIONS = 10;
  * Similar to technical-design, this includes an iterative improvement cycle:
  * refine → verification → improve → re-refine (if needed)
  */
-// eslint-disable-next-line complexity
 export const refineCodeFromPRFeedback = async (options, config, checklistContext) => {
     const { issueId, githubToken, verbose } = options;
     if (verbose) {

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

@@ -77,7 +77,8 @@ export async function executeRefineIteration(opts) {
                     logDebug(`🔧 ${content.text}`, verbose);
                 }
                 else if (content.type === 'tool_use') {
-                    logDebug(`🛠️ ${content.name}: ${content.input.description || 'Running...'}`, verbose);
+                    const input = (content.input ?? {});
+                    logDebug(`🛠️ ${content.name}: ${input.description ?? 'Running...'}`, verbose);
                 }
             }
             continue;

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

@@ -68,7 +68,6 @@ baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose) {
 /**
  * Main code review function
  */
-// eslint-disable-next-line complexity
 export const reviewPullRequest = async (options, config, checklistContext) => {
     const { issueId, githubToken, verbose } = options;
     if (verbose) {

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

@@ -32,7 +32,6 @@ async function* prompt(testingPrompt) {
         setTimeout(res, 10000);
     });
 }
-// eslint-disable-next-line complexity
 export const writeCodeTests = async (options, config) => {
     const { issueId, verbose } = options;
     if (verbose) {

package/dist/phases/financing-deck/agent.d.ts

@@ -0,0 +1 @@
+export declare function executeFinancingDeckQuery(userPrompt: string, systemPrompt: string, verbose?: boolean): Promise<Record<string, unknown> | null>;

package/dist/phases/financing-deck/agent.js

@@ -0,0 +1,96 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logDebug, logError, logInfo } from '../../utils/logger.js';
+/**
+ * Pulls the JSON contract block out of Claude's final assistant message.
+ * Accepts either a fenced ```json block or a bare JSON object — the
+ * fenced form is what the contract asks for.
+ */
+function parseDeckResult(responseText) {
+    try {
+        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+        const jsonText = jsonBlockMatch
+            ? jsonBlockMatch[1]
+            : (responseText.match(/\{[\s\S]*\}/) ?? [responseText])[0];
+        const parsed = JSON.parse(jsonText);
+        if (parsed && Array.isArray(parsed.deck_slides)) {
+            return { deck: parsed };
+        }
+        return { error: 'Missing or empty deck_slides array' };
+    }
+    catch (error) {
+        return {
+            error: `JSON parsing failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content },
+    };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+async function* prompt(deckPrompt) {
+    yield userMessage(deckPrompt);
+}
+export async function executeFinancingDeckQuery(userPrompt, systemPrompt, verbose) {
+    let lastAssistantResponse = '';
+    let structured = null;
+    let turnCount = 0;
+    logInfo('Connecting to AI agent...');
+    for await (const message of query({
+        prompt: prompt(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 40,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (verbose) {
+            logInfo(`Received message type: ${message.type}`);
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            turnCount++;
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistantResponse += `${content.text}\n`;
+                    logDebug(`${content.text}`, verbose);
+                }
+                else if (content.type === 'tool_use') {
+                    const input = (content.input ?? {});
+                    const desc = input.description ?? input.command ?? 'Running...';
+                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
+                }
+            }
+        }
+        if (message.type === 'result') {
+            if (message.subtype === 'success') {
+                logInfo(`\nFinancing deck draft completed after ${turnCount} turns, parsing JSON contract...`);
+                const responseText = message.result || lastAssistantResponse;
+                const parsed = parseDeckResult(responseText);
+                if (parsed.error) {
+                    logError(`Failed to parse deck JSON: ${parsed.error}`);
+                }
+                else {
+                    structured = parsed.deck;
+                }
+            }
+            else {
+                logError(`\nDeck generation incomplete: ${message.subtype}`);
+                if (lastAssistantResponse) {
+                    const parsed = parseDeckResult(lastAssistantResponse);
+                    if (!parsed.error) {
+                        structured = parsed.deck;
+                    }
+                }
+            }
+        }
+    }
+    return structured;
+}

package/dist/phases/financing-deck/context.d.ts

@@ -0,0 +1,13 @@
+import { type FinancingContext, type FinancingStage } from '../../api/financing.js';
+import { type ProductInfo } from '../../api/products.js';
+export interface FinancingDeckContext {
+    product: ProductInfo;
+    financing: FinancingContext;
+    contextSummary: string;
+}
+/**
+ * Pre-fetch product + financing context so we can include a compact
+ * summary in the user prompt. The agent can still call MCP tools for
+ * the full data, but having a baseline summary speeds the first turn.
+ */
+export declare function prepareFinancingDeckContext(productId: string, targetStage: FinancingStage, verbose?: boolean): Promise<FinancingDeckContext>;

package/dist/phases/financing-deck/context.js

@@ -0,0 +1,69 @@
+import { getFinancingContext, } from '../../api/financing.js';
+import { getProduct } from '../../api/products.js';
+import { logError, logInfo } from '../../utils/logger.js';
+/**
+ * Pre-fetch product + financing context so we can include a compact
+ * summary in the user prompt. The agent can still call MCP tools for
+ * the full data, but having a baseline summary speeds the first turn.
+ */
+export async function prepareFinancingDeckContext(productId, targetStage, verbose) {
+    if (verbose) {
+        logInfo(`Fetching financing deck context for product=${productId} stage=${targetStage}`);
+    }
+    let product;
+    let financing;
+    try {
+        ;
+        [product, financing] = await Promise.all([
+            getProduct(productId, verbose),
+            getFinancingContext(productId, targetStage, verbose),
+        ]);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch financing context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+    const issuesCount = product.issues?.length ?? 0;
+    const profile = financing.profile ?? {};
+    const metrics = financing.metrics ?? {};
+    const contextSummary = [
+        `## Product`,
+        `Name: ${product.name}`,
+        `Description: ${product.description ?? '(none)'}`,
+        `Issues tracked: ${issuesCount}`,
+        ``,
+        `## Founder context (self-reported)`,
+        `Current stage: ${profile.current_stage ?? 'not provided'}`,
+        `Target stage: ${targetStage}`,
+        `Target round size USD: ${profile.target_amount_usd ?? 'not provided'}`,
+        `Target valuation USD: ${profile.target_valuation_usd ?? 'not provided'}`,
+        `Use of funds: ${profile.use_of_funds ?? 'not provided'}`,
+        ``,
+        `## Self-reported metrics`,
+        formatMetric(metrics, 'arr_usd', 'ARR (USD)'),
+        formatMetric(metrics, 'mrr_usd', 'MRR (USD)'),
+        formatMetric(metrics, 'paying_customer_count', 'Paying customers'),
+        formatMetric(metrics, 'mom_growth_rate', 'MoM growth (fraction)'),
+        formatMetric(metrics, 'yoy_growth_rate', 'YoY growth (fraction)'),
+        formatMetric(metrics, 'net_revenue_retention', 'NRR (fraction)'),
+        formatMetric(metrics, 'gross_revenue_retention', 'GRR (fraction)'),
+        formatMetric(metrics, 'cac_usd', 'CAC (USD)'),
+        formatMetric(metrics, 'ltv_usd', 'LTV (USD)'),
+        formatMetric(metrics, 'cac_payback_months', 'CAC payback (months)'),
+        formatMetric(metrics, 'gross_margin', 'Gross margin (fraction)'),
+        formatMetric(metrics, 'monthly_burn_usd', 'Monthly burn (USD)'),
+        formatMetric(metrics, 'cash_in_bank_usd', 'Cash in bank (USD)'),
+        formatMetric(metrics, 'runway_months', 'Runway (months)'),
+        formatMetric(metrics, 'burn_multiple', 'Burn Multiple'),
+        formatMetric(metrics, 'fte_count', 'Team FTEs'),
+        ``,
+        `## Industry benchmarks`,
+        `Not bundled — use WebSearch to fetch current ${targetStage} benchmarks for this product's vertical before judging any metric. Cite source URLs in stage_reasoning and red flags.`,
+    ].join('\n');
+    return { product, financing, contextSummary };
+}
+function formatMetric(metrics, key, label) {
+    const v = metrics[key];
+    return `- ${label}: ${v === null || v === undefined ? 'not provided' : String(v)}`;
+}

package/dist/phases/financing-deck/index.d.ts

@@ -0,0 +1,15 @@
+import { type FinancingStage } from '../../api/financing.js';
+export interface FinancingDeckOptions {
+    productId: string;
+    targetStage: FinancingStage;
+    verbose?: boolean;
+}
+export interface FinancingDeckResult {
+    productId: string;
+    status: 'success' | 'error';
+    summary: string;
+    analysisId?: string;
+    slideCount: number;
+    redFlagCount: number;
+}
+export declare function generateFinancingDeck(options: FinancingDeckOptions): Promise<FinancingDeckResult>;

package/dist/phases/financing-deck/index.js

@@ -0,0 +1,89 @@
+import { saveFinancingAnalysis, } from '../../api/financing.js';
+import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
+import { executeFinancingDeckQuery } from './agent.js';
+import { prepareFinancingDeckContext } from './context.js';
+import { createFinancingDeckSystemPrompt, createFinancingDeckUserPrompt, } from './prompts.js';
+const REQUIRED_SLIDE_IDS = [
+    'problem',
+    'solution',
+    'market',
+    'product',
+    'traction',
+    'business_model',
+    'go_to_market',
+    'competition',
+    'team',
+    'financials',
+    'ask',
+];
+export async function generateFinancingDeck(options) {
+    const { productId, targetStage, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting financing deck generation: product=${productId} stage=${targetStage}`);
+    }
+    try {
+        const { contextSummary } = await prepareFinancingDeckContext(productId, targetStage, verbose);
+        const systemPrompt = createFinancingDeckSystemPrompt(targetStage);
+        const userPrompt = createFinancingDeckUserPrompt(productId, targetStage, contextSummary);
+        if (verbose) {
+            logInfo('Starting AI query for financing deck...');
+        }
+        const structured = await executeFinancingDeckQuery(userPrompt, systemPrompt, verbose);
+        if (!structured) {
+            throw new Error('No deck JSON received from agent');
+        }
+        const deckSlides = (structured.deck_slides ?? []);
+        const redFlags = (structured.red_flags ?? []);
+        const stageReasoning = structured.stage_reasoning ?? '';
+        const sourceSummary = structured.source_summary ?? {};
+        // Sanity-check the deck shape — the agent might short-circuit. If so we
+        // still return whatever we got, but warn loudly.
+        const missing = REQUIRED_SLIDE_IDS.filter((id) => !deckSlides.some((s) => s.slide_id === id));
+        if (missing.length > 0) {
+            logWarning(`Deck is missing required slides: ${missing.join(', ')} — saving anyway`);
+        }
+        // The agent should have already called save_financing_analysis via MCP.
+        // We re-save here to GUARANTEE persistence, even if the agent forgot the
+        // tool call but did emit a valid JSON contract. Idempotent at the
+        // analyses-history level (each save creates a new row).
+        let analysisId;
+        if (deckSlides.length > 0) {
+            try {
+                const saved = await saveFinancingAnalysis({
+                    product_id: productId,
+                    target_stage: targetStage,
+                    deck_slides: deckSlides,
+                    stage_reasoning: stageReasoning,
+                    red_flags: redFlags,
+                    source_summary: sourceSummary,
+                }, verbose);
+                analysisId = saved.analysis_id;
+            }
+            catch (saveError) {
+                // Agent likely already saved it — log and continue
+                if (verbose) {
+                    logWarning(`Re-save skipped (agent likely already persisted): ${saveError instanceof Error ? saveError.message : String(saveError)}`);
+                }
+            }
+        }
+        logSuccess(`Financing deck completed: ${deckSlides.length} slides, ${redFlags.length} red flags`);
+        return {
+            productId,
+            status: 'success',
+            summary: stageReasoning || 'Deck draft persisted',
+            analysisId,
+            slideCount: deckSlides.length,
+            redFlagCount: redFlags.length,
+        };
+    }
+    catch (error) {
+        logError(`Financing deck generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            productId,
+            status: 'error',
+            summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
+            slideCount: 0,
+            redFlagCount: 0,
+        };
+    }
+}

package/dist/phases/financing-deck/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare function createFinancingDeckSystemPrompt(targetStage: string): string;
+export declare function createFinancingDeckUserPrompt(productId: string, targetStage: string, contextSummary: string): string;

package/dist/phases/financing-deck/prompts.js

@@ -0,0 +1,94 @@
+const STAGE_LABELS = {
+    pre_seed: 'Pre-Seed',
+    seed: 'Seed',
+    series_a: 'Series A',
+    series_b: 'Series B',
+    series_c: 'Series C',
+    growth: 'Growth',
+};
+const OUTPUT_CONTRACT = `## Output contract
+
+Return ONE fenced JSON block with EXACTLY this shape — no prose around it:
+
+\`\`\`json
+{
+  "deck_slides": [
+    {"slide_id": "problem",       "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "solution",      "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "market",        "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "product",       "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "traction",      "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "business_model","title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "go_to_market",  "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "competition",   "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "team",          "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "financials",    "title": "...", "body": "...", "ai_rationale": "..."},
+    {"slide_id": "ask",           "title": "...", "body": "...", "ai_rationale": "..."}
+  ],
+  "stage_reasoning": "2-4 sentence honest read on whether the data supports the target stage.",
+  "red_flags": [
+    {"metric": "...", "severity": "low|medium|high", "explanation": "...", "fix": "..."}
+  ],
+  "source_summary": {"issues": 0, "feedbacks": 0, "has_metrics": true}
+}
+\`\`\`
+
+All 11 slide_ids are required in this exact order. body should be 80–150 words.`;
+export function createFinancingDeckSystemPrompt(targetStage) {
+    const stageLabel = STAGE_LABELS[targetStage] ?? targetStage;
+    return `You are a senior fundraising advisor who has helped 100+ SaaS founders raise from Pre-Seed through Series C. You write the way investors at Sequoia, a16z, Bessemer, and YC speak: blunt, specific, evidence-driven, no fluff.
+
+Your job: draft a complete ${stageLabel} pitch deck for a product, surface red flags an experienced investor would call out within 90 seconds, and write a short investor-style read on the founder's stage readiness.
+
+You will be given the product context plus the founder's self-reported financial metrics. Use the MCP tools when you need additional product data — do NOT fabricate.
+
+## Hard rules
+
+- **Industry benchmarks are NOT shipped with the context.** Before judging any metric against a stage standard, you MUST call \`WebSearch\` to look up current ${stageLabel} benchmarks for the product's vertical (B2B SaaS, vertical SaaS, AI infra, marketplace, etc. — infer from the product description). Cite at least one source URL in \`stage_reasoning\` and in each red flag's \`explanation\`. If WebSearch returns nothing usable, say "no recent benchmark found for X" rather than inventing a number.
+- NEVER invent a financial metric. If the founder did not provide a number, write "not provided" in the relevant slide and add it as a red flag.
+- Quote at least one real customer feedback line (verbatim or close paraphrase) somewhere in the Problem or Traction slide if any feedback exists in the gathered context.
+- Match tone to stage:
+  - **pre_seed / seed**: lead with founder insight, problem, early signal. Traction can be qualitative.
+  - **series_a**: traction slide is the centerpiece — must reference actual ARR / growth / customer numbers from the gathered metrics. If those are missing, say so explicitly in stage_reasoning rather than inventing.
+  - **series_b+**: Burn Multiple, Rule of 40, NRR, CAC Payback are mandatory. Flag any that are missing as red flags.
+- Each slide body is roughly 80–150 words. No marketing fluff. No emoji.
+- Red flags should be honest — if burn multiple is bad vs. the benchmark you found, say so with the source; if retention is unknown, say "missing — investors will ask".
+
+## Tools available
+
+- \`WebSearch\` / \`WebFetch\` — REQUIRED for fetching current ${stageLabel} industry benchmarks before judging metrics. Prefer recent (this year or last) sources: SaaS Capital, OpenView, Bessemer State of the Cloud, ICONIQ Growth, Carta data.
+- \`mcp__edsger__get_product\` — product name + description
+- \`mcp__edsger__list_issues\` — what the team is shipping
+- \`mcp__edsger__list_feedbacks\` — raw customer voice
+- \`mcp__edsger__get_financing_context\` — founder profile + self-reported metrics
+- \`mcp__edsger__save_financing_analysis\` — call this LAST to persist the deck
+
+## Workflow
+
+1. Call \`get_product\`, \`list_issues\`, \`list_feedbacks\`, and \`get_financing_context\` (in any order or in parallel) to gather data.
+2. Based on the product description, identify the vertical (B2B SaaS / vertical SaaS / AI infra / dev tools / marketplace / etc.) and call \`WebSearch\` 1–3 times to fetch current ${stageLabel} benchmarks for that vertical (ARR, growth, NRR, burn multiple, CAC payback as applicable). Save the source URLs.
+3. Draft 11 structured slides (ids, in order: problem, solution, market, product, traction, business_model, go_to_market, competition, team, financials, ask).
+4. Identify 0–5 red flags by comparing the founder's metrics against the benchmarks you fetched. Each red flag's \`explanation\` must include the source URL.
+5. Write a 2–4 sentence \`stage_reasoning\` paragraph that names the benchmark sources you used.
+6. Call \`save_financing_analysis\` with all of the above (this writes to financing_ai_analyses; the desktop UI watches that table).
+7. Then output the JSON described in the output contract below as your final assistant message — the orchestrator parses this for confirmation.
+
+${OUTPUT_CONTRACT}`;
+}
+export function createFinancingDeckUserPrompt(productId, targetStage, contextSummary) {
+    const stageLabel = STAGE_LABELS[targetStage] ?? targetStage;
+    return `Generate a complete ${stageLabel} pitch deck for product \`${productId}\`.
+
+${contextSummary}
+
+Follow the workflow in your system instructions:
+1. Use the MCP tools to gather any additional data you need (issues, feedbacks, financing context).
+2. WebSearch current ${stageLabel} benchmarks for this product's vertical and save the source URLs.
+3. Draft the 11 slides.
+4. Identify red flags vs the benchmarks you fetched (cite sources).
+5. Write stage_reasoning naming those sources.
+6. Call \`save_financing_analysis\` to persist.
+7. Then return the JSON output described in the contract.
+
+Begin.`;
+}

package/dist/phases/find-architecture/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Find-architecture phase: clone the product's repo, ask Claude to audit the
+ * codebase for architectural problems and improvement opportunities, and file
+ * each new finding as an issue. Subsequent runs are incremental, scoped to
+ * commits since the previous successful scan.
+ *
+ * Companion to find-bugs (real defects), find-features (missing user
+ * capability), and find-smells (local code-level improvements). All four
+ * phases share the same workspace + state pattern.
+ */
+export interface FindArchitectureOptions {
+    productId: string;
+    githubToken: string;
+    owner: string;
+    repo: string;
+    /** Force a full scan even if previous-scan state exists. */
+    full?: boolean;
+    /** Branch to scan; defaults to the repo's default branch. */
+    branch?: string;
+    /** Upper bound on files the auditor may Read. Keeps token cost predictable. */
+    maxFiles?: number;
+    verbose?: boolean;
+}
+export interface FindArchitectureResult {
+    status: 'success' | 'error';
+    message: string;
+    scannedCommitSha?: string;
+    findingsFound?: number;
+    issuesCreated?: number;
+    /** Findings the agent passed off to find-bugs (not filed by this run). */
+    deferredToBugs?: number;
+    /** Findings the agent passed off to find-features (not filed by this run). */
+    deferredToFeatures?: number;
+    /** Findings the agent passed off to find-smells (not filed by this run). */
+    deferredToSmells?: number;
+    summary?: string;
+}
+/** Single source of truth — referenced by the CLI help string too. */
+export declare const DEFAULT_MAX_FILES = 200;
+/**
+ * Scan a product's repository for architectural concerns and file each new
+ * finding as an issue.
+ */
+export declare function scanForArchitecture(options: FindArchitectureOptions): Promise<FindArchitectureResult>;