edsger 0.77.0 → 0.78.0

package/dist/phases/adr-generation/index.d.ts

@@ -1,15 +0,0 @@
-export interface AdrGenerationOptions {
-    adrId: string;
-    verbose?: boolean;
-}
-export interface AdrGenerationResult {
-    status: 'success' | 'error';
-    optionCount: number;
-    error?: string;
-}
-/**
- * Generate decision options for a draft ADR: gather context, run the agent,
- * persist the resulting options, and flip the ADR to `proposed`/`ready` for the
- * human to choose. The draft row is created by the desktop app beforehand.
- */
-export declare function generateAdr(options: AdrGenerationOptions): Promise<AdrGenerationResult>;

package/dist/phases/adr-generation/index.js

@@ -1,66 +0,0 @@
-import { getAdr, loadAdrContext, markGenerationFailed, markGenerationReady, saveAdrOptions, } from '../../api/adr.js';
-import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
-import { executeAdrQuery } from './agent.js';
-import { buildAdrUserPrompt, createAdrSystemPrompt } from './prompts.js';
-/** Best-effort clone of the relevant repo so the agent can read the codebase. */
-async function tryCloneRepo(adr, verbose) {
-    try {
-        const gh = adr.product_id
-            ? await getGitHubConfigByProduct(adr.product_id, verbose)
-            : await getGitHubConfigByRepository(adr.repository_id, verbose);
-        if (gh.configured && gh.token && gh.owner && gh.repo) {
-            const workspaceRoot = ensureWorkspaceDir();
-            const { repoPath } = cloneIssueRepo(workspaceRoot, `adr-${adr.id}`, gh.owner, gh.repo, gh.token);
-            logInfo(`Repository cloned to: ${repoPath}`);
-            return repoPath;
-        }
-    }
-    catch (error) {
-        logInfo(`Could not clone repo (continuing without codebase): ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return undefined;
-}
-/**
- * Generate decision options for a draft ADR: gather context, run the agent,
- * persist the resulting options, and flip the ADR to `proposed`/`ready` for the
- * human to choose. The draft row is created by the desktop app beforehand.
- */
-export async function generateAdr(options) {
-    const { adrId, verbose } = options;
-    let repoCwd;
-    try {
-        const adr = await getAdr(adrId);
-        logInfo(`Generating decision options for: ${adr.title}`);
-        const context = await loadAdrContext(adr);
-        repoCwd = await tryCloneRepo(adr, verbose);
-        const systemPrompt = await createAdrSystemPrompt(Boolean(repoCwd));
-        const userPrompt = buildAdrUserPrompt(adr, context);
-        const generated = await executeAdrQuery(userPrompt, systemPrompt, verbose, repoCwd);
-        if (!generated || generated.length === 0) {
-            const message = 'The agent did not return any decision options.';
-            await markGenerationFailed(adrId, message);
-            return { status: 'error', optionCount: 0, error: message };
-        }
-        await saveAdrOptions(adrId, generated);
-        await markGenerationReady(adrId);
-        logSuccess(`Generated ${generated.length} decision options.`);
-        for (const o of generated) {
-            logInfo(`  ${o.is_recommended ? '★' : '•'} ${o.title}`);
-        }
-        logInfo('\nReview and choose one in the Desktop app → ADR tab');
-        return { status: 'success', optionCount: generated.length };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logError(`ADR generation failed: ${message}`);
-        await markGenerationFailed(adrId, message);
-        return { status: 'error', optionCount: 0, error: message };
-    }
-    finally {
-        if (repoCwd) {
-            cleanupIssueRepo(repoCwd);
-        }
-    }
-}

package/dist/phases/adr-generation/parse.d.ts

@@ -1,12 +0,0 @@
-import { type AdrOptionInput } from '../../api/adr.js';
-/**
- * Pure parsing/normalization helpers for the ADR agent response. Kept separate
- * from agent.ts (which owns the SDK query loop) so they can be unit-tested
- * without spinning up the model.
- */
-/** Index of the matching closer for the opener at `start`, respecting strings. */
-export declare function findMatchingClose(text: string, start: number): number;
-export declare function extractJSON(text: string): any | null;
-export declare function asStringArray(value: unknown): string[];
-/** Coerce the parsed JSON into validated option inputs. */
-export declare function normalizeOptions(parsed: unknown): AdrOptionInput[];

package/dist/phases/adr-generation/parse.js

@@ -1,123 +0,0 @@
-/**
- * Pure parsing/normalization helpers for the ADR agent response. Kept separate
- * from agent.ts (which owns the SDK query loop) so they can be unit-tested
- * without spinning up the model.
- */
-/** Index of the matching closer for the opener at `start`, respecting strings. */
-export function findMatchingClose(text, start) {
-    const opener = text[start];
-    const closer = opener === '{' ? '}' : ']';
-    let depth = 0;
-    let inString = false;
-    let escape = false;
-    for (let i = start; i < text.length; i++) {
-        const ch = text[i];
-        if (escape) {
-            escape = false;
-            continue;
-        }
-        if (ch === '\\' && inString) {
-            escape = true;
-            continue;
-        }
-        if (ch === '"') {
-            inString = !inString;
-            continue;
-        }
-        if (inString) {
-            continue;
-        }
-        if (ch === opener) {
-            depth++;
-        }
-        else if (ch === closer) {
-            depth--;
-            if (depth === 0) {
-                return i;
-            }
-        }
-    }
-    return -1;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function extractJSON(text) {
-    // Largest ```json block first.
-    const jsonBlocks = [...text.matchAll(/```json\s*\n([\s\S]*?)\n\s*```/g)];
-    if (jsonBlocks.length > 0) {
-        const largest = jsonBlocks.reduce((a, b) => a[1].length >= b[1].length ? a : b);
-        try {
-            return JSON.parse(largest[1]);
-        }
-        catch {
-            /* fall through */
-        }
-    }
-    // Generic code block.
-    const codeBlock = text.match(/```\s*\n([\s\S]*?)\n\s*```/);
-    if (codeBlock) {
-        try {
-            return JSON.parse(codeBlock[1]);
-        }
-        catch {
-            /* fall through */
-        }
-    }
-    // Balanced { ... } scan.
-    for (let i = 0; i < text.length; i++) {
-        if (text[i] === '{') {
-            const end = findMatchingClose(text, i);
-            if (end !== -1) {
-                try {
-                    return JSON.parse(text.slice(i, end + 1));
-                }
-                catch {
-                    i = end;
-                }
-            }
-        }
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-export function asStringArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value
-        .map((v) => (typeof v === 'string' ? v : String(v)))
-        .map((s) => s.trim())
-        .filter(Boolean);
-}
-/** Coerce the parsed JSON into validated option inputs. */
-export function normalizeOptions(parsed) {
-    const root = parsed;
-    const rawOptions = Array.isArray(root?.options)
-        ? root?.options
-        : Array.isArray(parsed)
-            ? parsed
-            : [];
-    const options = [];
-    for (const raw of rawOptions ?? []) {
-        const o = raw;
-        const title = typeof o.title === 'string' ? o.title.trim() : '';
-        if (!title) {
-            continue;
-        }
-        options.push({
-            title,
-            summary: typeof o.summary === 'string' ? o.summary.trim() : undefined,
-            pros: asStringArray(o.pros),
-            cons: asStringArray(o.cons),
-            is_recommended: o.is_recommended === true,
-        });
-    }
-    // Guarantee exactly one recommended option when any exist.
-    if (options.length > 0 && !options.some((o) => o.is_recommended)) {
-        options[0].is_recommended = true;
-    }
-    return options;
-}

package/dist/phases/adr-generation/prompts.d.ts

@@ -1,8 +0,0 @@
-import { type AdrContext, type AdrRow } from '../../api/adr.js';
-/**
- * Build the ADR agent's system prompt from the bundled (and user-overridable)
- * `phase/adr-generation` SKILL.md. Conditional blocks are toggled by whether a
- * codebase is available in the working directory.
- */
-export declare function createAdrSystemPrompt(hasCodebase: boolean, projectDir?: string): Promise<string>;
-export declare function buildAdrUserPrompt(adr: AdrRow, context: AdrContext): string;

package/dist/phases/adr-generation/prompts.js

@@ -1,35 +0,0 @@
-import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
-/**
- * Build the ADR agent's system prompt from the bundled (and user-overridable)
- * `phase/adr-generation` SKILL.md. Conditional blocks are toggled by whether a
- * codebase is available in the working directory.
- */
-export async function createAdrSystemPrompt(hasCodebase, projectDir) {
-    const skill = await resolveSkill('phase/adr-generation', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/adr-generation');
-    }
-    return processConditionals(skill.prompt, { hasCodebase });
-}
-export function buildAdrUserPrompt(adr, context) {
-    const lines = [];
-    lines.push(`# Decision to make\n${adr.title}`);
-    if (adr.generation_prompt && adr.generation_prompt !== adr.title) {
-        lines.push(`\n## Direction from the human\n${adr.generation_prompt}`);
-    }
-    if (adr.context) {
-        lines.push(`\n## Additional context\n${adr.context}`);
-    }
-    lines.push(`\n## ${context.scope === 'product' ? 'Product' : 'Repository'}\n${context.name}${context.description ? `\n${context.description}` : ''}`);
-    if (context.repos.length > 0) {
-        lines.push(`\n## Linked repositories\n${context.repos.join('\n')}`);
-    }
-    if (context.issues.length > 0) {
-        lines.push(`\n## Recent issues (for situational awareness)\n${context.issues
-            .slice(0, 25)
-            .map((i) => `- ${i}`)
-            .join('\n')}`);
-    }
-    lines.push(`\nProduce the options JSON per the output contract. Investigate before answering.`);
-    return lines.join('\n');
-}

package/dist/phases/analyze-logs/agent.d.ts

@@ -1,11 +0,0 @@
-export interface AnalyzedFeedback {
-    category: 'bug' | 'feature_request' | 'improvement' | 'question' | 'other';
-    title: string;
-    description: string;
-    priority: 'low' | 'medium' | 'high' | 'critical';
-}
-export interface AnalysisResult {
-    summary: string;
-    feedbacks: AnalyzedFeedback[];
-}
-export declare function executeLogAnalysis(userPrompt: string, systemPrompt: string, verbose?: boolean): Promise<AnalysisResult | null>;

package/dist/phases/analyze-logs/agent.js

@@ -1,66 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-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(text) {
-    yield userMessage(text);
-}
-function parseAnalysisResult(responseText) {
-    try {
-        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        const jsonText = jsonBlockMatch ? jsonBlockMatch[1] : responseText;
-        const parsed = JSON.parse(jsonText);
-        if (parsed &&
-            typeof parsed.summary === 'string' &&
-            Array.isArray(parsed.feedbacks)) {
-            return parsed;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function executeLogAnalysis(userPrompt, systemPrompt, verbose) {
-    let lastAssistantResponse = '';
-    let result = null;
-    for await (const message of query({
-        prompt: prompt(userPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 10,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (message.type === 'assistant' && message.message?.content) {
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistantResponse += `${content.text}\n`;
-                    logDebug(content.text, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            const responseText = ('result' in message ? message.result : '') || lastAssistantResponse;
-            result = parseAnalysisResult(responseText);
-            if (!result) {
-                logError('Failed to parse log analysis result');
-            }
-            else {
-                logInfo(`Analysis complete: ${result.feedbacks.length} feedback items found`);
-            }
-        }
-    }
-    return result;
-}

package/dist/phases/analyze-logs/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * Analyze Logs Phase
- *
- * Fetches unanalyzed product logs grouped by user, runs AI analysis on each
- * user's session logs (only if the latest log is >1 hour old), and creates
- * product_user_feedbacks for any issues or improvement suggestions found.
- */
-export interface AnalyzeLogsOptions {
-    productId: string;
-    verbose?: boolean;
-}
-export interface AnalyzeLogsResult {
-    status: 'success' | 'error';
-    groupsProcessed: number;
-    feedbacksCreated: number;
-    logsAnalyzed: number;
-    summary: string;
-}
-/**
- * Run log analysis for a product.
- * Processes each user's pending logs through AI and creates feedback.
- */
-export declare function analyzeLogs(options: AnalyzeLogsOptions): Promise<AnalyzeLogsResult>;

package/dist/phases/analyze-logs/index.js

@@ -1,152 +0,0 @@
-/**
- * Analyze Logs Phase
- *
- * Fetches unanalyzed product logs grouped by user, runs AI analysis on each
- * user's session logs (only if the latest log is >1 hour old), and creates
- * product_user_feedbacks for any issues or improvement suggestions found.
- */
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { getProduct } from '../../api/products.js';
-import { getPendingLogsByUser, markLogsAnalyzed, } from '../../services/product-logs.js';
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-import { executeLogAnalysis } from './agent.js';
-import { createAnalyzeLogsSystemPrompt, createAnalyzeLogsUserPrompt, } from './prompts.js';
-/**
- * Run log analysis for a product.
- * Processes each user's pending logs through AI and creates feedback.
- */
-export async function analyzeLogs(options) {
-    const { productId, verbose } = options;
-    // 1. Get product info for context
-    let productName = productId;
-    try {
-        // Use the shared product wrapper — it tries the user-JWT SDK path first
-        // and falls back to the resources/read MCP path when the row isn't
-        // directly accessible (e.g. slug lookup).
-        const product = (await getProduct(productId));
-        if (product?.name) {
-            productName = product.name;
-        }
-    }
-    catch {
-        // Continue with product ID as name
-    }
-    // 2. Fetch pending logs grouped by user
-    logInfo(`Fetching pending logs for product: ${productName}`);
-    const groups = await getPendingLogsByUser(productId, verbose);
-    if (groups.length === 0) {
-        logInfo('No pending log groups to analyze');
-        return {
-            status: 'success',
-            groupsProcessed: 0,
-            feedbacksCreated: 0,
-            logsAnalyzed: 0,
-            summary: 'No pending logs to analyze',
-        };
-    }
-    logInfo(`Found ${groups.length} user log group(s) to analyze`);
-    // 3. Filter: only process groups where latest log is >1 hour old
-    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
-    const readyGroups = groups.filter((group) => group.latestLogAt < oneHourAgo);
-    if (readyGroups.length === 0) {
-        logInfo('All user sessions are still active (latest log within 1 hour). Skipping.');
-        return {
-            status: 'success',
-            groupsProcessed: 0,
-            feedbacksCreated: 0,
-            logsAnalyzed: 0,
-            summary: 'All sessions still active, nothing to analyze yet',
-        };
-    }
-    logInfo(`${readyGroups.length} group(s) ready for analysis (inactive >1 hour)`);
-    const systemPrompt = await createAnalyzeLogsSystemPrompt();
-    let totalFeedbacks = 0;
-    let totalLogs = 0;
-    // 4. Process each user group
-    for (const group of readyGroups) {
-        const userLabel = group.userId || 'anonymous';
-        logInfo(`Analyzing ${group.logs.length} logs for user: ${userLabel}`);
-        const userPrompt = createAnalyzeLogsUserPrompt(productName, group.userId, group.logs);
-        try {
-            const result = await executeLogAnalysis(userPrompt, systemPrompt, verbose);
-            if (result && result.feedbacks.length > 0) {
-                // 5. Create feedback entries
-                await createFeedbacksFromAnalysis(productId, group, result, verbose);
-                totalFeedbacks += result.feedbacks.length;
-            }
-            else if (result) {
-                logInfo(`No issues found for user ${userLabel}: ${result.summary}`);
-            }
-            // 6. Mark logs as analyzed
-            const logIds = group.logs.map((l) => l.id);
-            await markLogsAnalyzed(logIds, verbose);
-            totalLogs += logIds.length;
-        }
-        catch (error) {
-            logError(`Failed to analyze logs for user ${userLabel}: ${error instanceof Error ? error.message : String(error)}`);
-            // Continue with next group
-        }
-    }
-    logSuccess(`Analysis complete: ${readyGroups.length} groups, ${totalFeedbacks} feedbacks created, ${totalLogs} logs processed`);
-    return {
-        status: 'success',
-        groupsProcessed: readyGroups.length,
-        feedbacksCreated: totalFeedbacks,
-        logsAnalyzed: totalLogs,
-        summary: `Processed ${readyGroups.length} user groups, created ${totalFeedbacks} feedback items`,
-    };
-}
-/**
- * Create product_user_feedbacks from AI analysis results
- */
-async function createFeedbacksFromAnalysis(productId, group, result, verbose) {
-    for (const feedback of result.feedbacks) {
-        try {
-            const payload = {
-                product_id: productId,
-                category: feedback.category,
-                title: feedback.title,
-                description: feedback.description,
-                priority: feedback.priority,
-                reporter_name: group.userId
-                    ? `AI Analysis (user: ${group.userId})`
-                    : 'AI Analysis (anonymous user)',
-                metadata: {
-                    source: 'log_analysis',
-                    user_id: group.userId,
-                    log_count: group.logs.length,
-                    analysis_summary: result.summary,
-                    time_range: {
-                        from: group.logs[0]?.created_at,
-                        to: group.logs[group.logs.length - 1]?.created_at,
-                    },
-                },
-            };
-            let usedSdk = false;
-            if (hasSupabaseSession()) {
-                try {
-                    const { error } = await getSupabase()
-                        .from('product_user_feedbacks')
-                        .insert({ ...payload, status: 'new' });
-                    if (error) {
-                        throw new Error(error.message);
-                    }
-                    usedSdk = true;
-                }
-                catch {
-                    // Fall through to MCP
-                }
-            }
-            if (!usedSdk) {
-                await callMcpEndpoint('product_user_feedbacks/create', payload);
-            }
-            if (verbose) {
-                logInfo(`Created feedback: [${feedback.category}] ${feedback.title}`);
-            }
-        }
-        catch (error) {
-            logError(`Failed to create feedback "${feedback.title}": ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}

package/dist/phases/analyze-logs/prompts.d.ts

@@ -1,3 +0,0 @@
-import { type ProductLog } from '../../services/product-logs.js';
-export declare function createAnalyzeLogsSystemPrompt(projectDir?: string): Promise<string>;
-export declare function createAnalyzeLogsUserPrompt(productName: string, userId: string | null, logs: ProductLog[]): string;

package/dist/phases/analyze-logs/prompts.js

@@ -1,27 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export async function createAnalyzeLogsSystemPrompt(projectDir) {
-    const skill = await resolveSkill('phase/analyze-logs', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/analyze-logs');
-    }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['analyze-logs']}`;
-}
-export function createAnalyzeLogsUserPrompt(productName, userId, logs) {
-    const logsText = logs
-        .map((log) => `[${log.created_at}] [${log.log_type}] ${log.message}${Object.keys(log.metadata).length > 0
-        ? ` | metadata: ${JSON.stringify(log.metadata)}`
-        : ''}`)
-        .join('\n');
-    return `Analyze the following user interaction logs for product "${productName}".
-
-User ID: ${userId || 'anonymous'}
-Total logs: ${logs.length}
-Time range: ${logs[0]?.created_at} to ${logs[logs.length - 1]?.created_at}
-
---- BEGIN LOGS ---
-${logsText}
---- END LOGS ---
-
-Analyze these logs and identify any issues, bugs, or product improvement opportunities. Return your analysis as the JSON format specified in your instructions.`;
-}

package/dist/phases/api-docs/index.d.ts

@@ -1,47 +0,0 @@
-/**
- * API docs phase: clone the repository, ask Claude to work out the API surface
- * it exposes, and persist a generated API reference (Markdown + an optional
- * OpenAPI document) onto the pending api_doc_runs row.
- *
- * Production-grade behaviours (mirrors the recipes phase):
- *
- *   - Heartbeat: `last_heartbeat_at` on the api_doc_runs row is refreshed on
- *     every assistant message so the reader can detect stalled / crashed runs
- *     (see desktop-app/.../services/db/api-doc-runs.ts for the lazy reaper).
- *   - Cancellation-safe writes: markRunning / persistAndSucceed / markFailed
- *     only touch rows whose status is in {pending, running}. If the user
- *     clicked Stop and the row is now 'cancelled', the final write no-ops.
- *   - Capture-then-persist: the agent submits the reference via a single
- *     `submit_api_docs` MCP tool; the artifact is written in one atomic update
- *     alongside the success flip, so a run never leaves a half-written doc.
- */
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { ApiDocsArtifact } from './types.js';
-export interface ApiDocsPhaseOptions {
-    /** Product-scoped run. Mutually exclusive with `repoId`. */
-    productId?: string;
-    /** Repo-only run: a single repositories row, no product context. */
-    repoId?: string;
-    runId: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export interface ApiDocsPhaseResult {
-    status: 'success' | 'error' | 'cancelled';
-    message: string;
-}
-export declare function runApiDocsPhase(options: ApiDocsPhaseOptions): Promise<ApiDocsPhaseResult>;
-/**
- * Claim the row by flipping `pending` → `running`. Returns true on success and
- * false when the row has already moved on (e.g. user cancelled before the CLI
- * started). Bounded by the status filter so we can't resurrect a 'cancelled'
- * row.
- */
-export declare function markRunning(supabase: SupabaseClient, runId: string): Promise<boolean>;
-export declare function heartbeat(supabase: SupabaseClient, runId: string): Promise<void>;
-export declare function markFailed(supabase: SupabaseClient, runId: string, errorMessage: string): Promise<boolean>;
-/**
- * Write the captured artifact AND flip the row to success in one update,
- * bounded by the {pending, running} status filter so a cancelled run no-ops.
- */
-export declare function persistAndSucceed(supabase: SupabaseClient, runId: string, artifact: ApiDocsArtifact): Promise<boolean>;