edsger 0.76.0 → 0.78.0

package/dist/phases/screen-flow/index.js

@@ -1,349 +0,0 @@
-/**
- * screen-flow phase: clone the product's repo, ask Claude to map every
- * user-facing screen and the transitions between them into a structured
- * ScreenFlowExtraction, then persist the result to diagrams / diagram_nodes /
- * diagram_edges (rows tagged `type = 'screen'`) via the Supabase SDK.
- *
- * Companion to find-architecture / find-bugs / find-features. Same workspace
- * pattern, but writes to its own tables rather than filing issues.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getRepositoryBasics } from '../../api/github.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getSupabase } from '../../supabase/client.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cleanupIssueRepo } from '../../workspace/workspace-manager.js';
-import { cloneDiagramRepos, describeRepoScope, } from '../diagram-shared/clone-repos.js';
-import { fetchProductBasics } from '../find-shared/mcp.js';
-import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
-import { createScreenFlowCaptureState, createScreenFlowMcpServer, validateConsistency, } from './mcp-server.js';
-import { createScreenFlowSystemPrompt, createScreenFlowUserPrompt, } from './prompts.js';
-import { extractTheme } from './theme.js';
-import { isScreenFlowExtraction, } from './types.js';
-const WORKSPACE_KEY = 'screen-flow';
-const MAX_TURNS = 150;
-// Auto-layout: simple grid; users can drag afterwards and we persist positions.
-const COLUMN_WIDTH = 380;
-const ROW_HEIGHT = 480;
-const COLUMNS = 4;
-export async function runScreenFlowPhase(options) {
-    const { productId, repoId, diagramId, guidance, verbose } = options;
-    const repoOnly = !productId && Boolean(repoId);
-    if (productId) {
-        logInfo(`Starting screen-flow generation for product ${productId}`);
-    }
-    else {
-        logInfo(`Starting screen-flow generation for repository ${repoId}`);
-    }
-    const supabase = getSupabase();
-    await markDiagramRunning(supabase, diagramId);
-    const repositoryIds = await getDiagramRepositoryIds(supabase, diagramId);
-    const cloneResult = await cloneDiagramRepos({
-        productId,
-        repoId,
-        repositoryIds,
-        workspaceKey: WORKSPACE_KEY,
-        verbose,
-    });
-    if (!cloneResult.ok) {
-        await markDiagramFailed(supabase, diagramId, cloneResult.message);
-        return { status: 'error', message: cloneResult.message };
-    }
-    const { projectDir, cleanupDir, repos } = cloneResult;
-    let succeeded = false;
-    try {
-        const product = repoOnly
-            ? await resolveRepoBasics(repoId, repos)
-            : await fetchProductBasics(productId);
-        const systemPrompt = await createScreenFlowSystemPrompt({
-            projectDir,
-            hasCodebase: true,
-        });
-        const repoScope = describeRepoScope(repos);
-        const userPrompt = createScreenFlowUserPrompt({
-            productName: product.name,
-            productDescription: product.description,
-            guidance: [guidance, repoScope].filter(Boolean).join('\n\n') || undefined,
-        });
-        logInfo('Running Claude screen-flow extraction...');
-        // The agent submits the extraction by calling submit_screen_flow on the
-        // in-process MCP server. The handler validates with Zod + cross-field
-        // checks and stores the result in `captureState.captured`. If the agent
-        // never calls the tool, we fall back to parsing a fenced screen_flow
-        // block out of the assistant text.
-        const captureState = createScreenFlowCaptureState();
-        const mcpServer = createScreenFlowMcpServer(captureState, {
-            onProgress: ({ phase, message }) => {
-                logInfo(`[${phase}] ${message}`);
-            },
-        });
-        let lastAssistantResponse = '';
-        let extraction = null;
-        for await (const message of query({
-            prompt: createPromptGenerator(userPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: MAX_TURNS,
-                permissionMode: 'bypassPermissions',
-                cwd: projectDir,
-                mcpServers: {
-                    'screen-flow': mcpServer,
-                },
-            },
-        })) {
-            const { assistantBuffer, extraction: nextExtraction } = processSdkMessage(message, lastAssistantResponse, captureState, verbose);
-            lastAssistantResponse = assistantBuffer;
-            if (nextExtraction) {
-                extraction = nextExtraction;
-            }
-        }
-        if (!extraction) {
-            const msg = 'Screen flow extraction failed: agent did not call submit_screen_flow and no parseable screen_flow block was found in the response';
-            await markDiagramFailed(supabase, diagramId, msg);
-            return { status: 'error', message: msg };
-        }
-        logInfo(`Extraction produced ${extraction.nodes.length} screens / ${extraction.edges.length} transitions`);
-        const theme = resolveTheme(extraction.theme, repos);
-        if (Object.keys(theme).length > 0) {
-            logInfo(`Theme: ${Object.entries(theme)
-                .map(([k, v]) => `${k}=${v}`)
-                .join(', ')}`);
-            await persistTheme(supabase, diagramId, theme);
-        }
-        const { nodesCreated, edgesCreated } = await persistDiagram(supabase, diagramId, extraction);
-        await markDiagramSuccess(supabase, diagramId, extraction.summary);
-        succeeded = true;
-        logSuccess(`Screen flow generated: ${nodesCreated} screens, ${edgesCreated} transitions`);
-        return {
-            status: 'success',
-            message: `Screen flow generated (${nodesCreated} screens, ${edgesCreated} transitions)`,
-            nodesCreated,
-            edgesCreated,
-            summary: extraction.summary,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Screen flow failed: ${errorMessage}`);
-        await markDiagramFailed(supabase, diagramId, errorMessage);
-        return { status: 'error', message: errorMessage };
-    }
-    finally {
-        if (succeeded) {
-            cleanupIssueRepo(cleanupDir);
-        }
-    }
-}
-/**
- * Settle on the theme to persist. The agent decides which repo's design
- * tokens represent the product (it can see every clone), so its answer wins.
- * Only if it returned nothing do we fall back to deterministic static
- * extraction, scanning each repo and taking the first non-empty result.
- */
-function resolveTheme(agentTheme, repos) {
-    const cleaned = agentTheme
-        ? Object.fromEntries(Object.entries(agentTheme).filter(([, v]) => v !== null && v !== undefined && v !== ''))
-        : {};
-    if (Object.keys(cleaned).length > 0) {
-        return cleaned;
-    }
-    for (const repo of repos) {
-        const parsed = extractTheme(repo.dir);
-        if (Object.keys(parsed).length > 0) {
-            return parsed;
-        }
-    }
-    return {};
-}
-/**
- * Build "product basics" for repo-only mode from the repositories row,
- * falling back to the cloned repo's full name when the row has no name.
- */
-async function resolveRepoBasics(repositoryId, repos) {
-    const basics = await getRepositoryBasics(repositoryId).catch(() => null);
-    return {
-        name: basics?.fullName ?? repos[0]?.fullName ?? repositoryId,
-        description: basics?.description ?? undefined,
-    };
-}
-/** Read the ordered repo set a diagram was scoped to (may be empty). */
-async function getDiagramRepositoryIds(supabase, diagramId) {
-    const { data } = await supabase
-        .from('diagrams')
-        .select('repository_ids')
-        .eq('id', diagramId)
-        .single();
-    return (data?.repository_ids ?? []).filter(Boolean);
-}
-// Per-message handler — extracted out of the SDK loop to keep
-// runScreenFlowPhase under the eslint complexity ceiling.
-//
-function processSdkMessage(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-message, assistantBuffer, captureState, verbose) {
-    if (message.type === 'assistant') {
-        const next = assistantBuffer +
-            extractTextFromContent(message.message?.content ?? [], verbose);
-        return { assistantBuffer: next, extraction: null };
-    }
-    if (message.type === 'user' && verbose) {
-        // Surface tool_result blocks (incl. submit_screen_flow validation
-        // errors) so verbose mode shows the round-trip.
-        const userContent = message.message?.content;
-        if (Array.isArray(userContent)) {
-            extractTextFromContent(userContent, verbose);
-        }
-        return { assistantBuffer, extraction: null };
-    }
-    if (message.type !== 'result') {
-        return { assistantBuffer, extraction: null };
-    }
-    if (captureState.captured) {
-        return { assistantBuffer, extraction: captureState.captured };
-    }
-    const fallback = tryFallbackParse(message, assistantBuffer);
-    if (fallback) {
-        logWarning('Agent emitted a fenced screen_flow block instead of calling submit_screen_flow; using the parsed text as a fallback.');
-        return { assistantBuffer, extraction: fallback };
-    }
-    if (message.subtype !== 'success') {
-        logError(`Extraction incomplete: ${message.subtype}`);
-    }
-    return { assistantBuffer, extraction: null };
-}
-// Fallback parser: extract a screen_flow JSON block from the final assistant
-// text if the agent skipped the submit_screen_flow tool call.
-function tryFallbackParse(resultMessage, assistantText) {
-    const responseText = resultMessage.subtype === 'success'
-        ? resultMessage.result || assistantText
-        : assistantText;
-    const parsed = tryExtractResult(responseText, 'screen_flow');
-    if (!isScreenFlowExtraction(parsed)) {
-        return null;
-    }
-    const { error } = validateConsistency(parsed);
-    if (error) {
-        logWarning(`Fallback extraction failed consistency check: ${error}`);
-        return null;
-    }
-    return parsed;
-}
-// ============================================================================
-// Persistence
-// ============================================================================
-async function markDiagramRunning(supabase, diagramId) {
-    const { error } = await supabase
-        .from('diagrams')
-        .update({ status: 'running', error: null })
-        .eq('id', diagramId);
-    if (error) {
-        logWarning(`Could not mark diagram as running: ${error.message}`);
-    }
-}
-async function markDiagramFailed(supabase, diagramId, errorMessage) {
-    await supabase
-        .from('diagrams')
-        .update({
-        status: 'failed',
-        error: errorMessage,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', diagramId);
-}
-async function persistTheme(supabase, diagramId, theme) {
-    // Theme is screen-flow-specific; stash it inside the generic options JSONB.
-    const { data, error: readError } = await supabase
-        .from('diagrams')
-        .select('options')
-        .eq('id', diagramId)
-        .single();
-    if (readError) {
-        logWarning(`Could not read flow options: ${readError.message}`);
-        return;
-    }
-    const nextOptions = {
-        ...(data?.options ?? {}),
-        theme,
-    };
-    const { error } = await supabase
-        .from('diagrams')
-        .update({ options: nextOptions })
-        .eq('id', diagramId);
-    if (error) {
-        logWarning(`Could not persist extracted theme: ${error.message}`);
-    }
-}
-async function markDiagramSuccess(supabase, diagramId, summary) {
-    await supabase
-        .from('diagrams')
-        .update({
-        status: 'success',
-        summary,
-        error: null,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', diagramId);
-}
-async function persistDiagram(supabase, diagramId, extraction) {
-    // Re-runs replace prior content for the same flow row.
-    await supabase.from('diagram_edges').delete().eq('diagram_id', diagramId);
-    await supabase.from('diagram_nodes').delete().eq('diagram_id', diagramId);
-    if (extraction.nodes.length === 0) {
-        return { nodesCreated: 0, edgesCreated: 0 };
-    }
-    const nodeRows = extraction.nodes.map((n, i) => buildNodeRow(diagramId, n, i));
-    const { data: insertedNodes, error: nodesError } = await supabase
-        .from('diagram_nodes')
-        .insert(nodeRows)
-        .select('id, slug');
-    if (nodesError) {
-        throw new Error(`Failed to insert nodes: ${nodesError.message}`);
-    }
-    const slugToId = new Map((insertedNodes ?? []).map((n) => [n.slug, n.id]));
-    const edgeRows = extraction.edges
-        .map((e) => buildEdgeRow(diagramId, e, slugToId))
-        .filter((e) => e !== null);
-    if (edgeRows.length > 0) {
-        const { error: edgesError } = await supabase
-            .from('diagram_edges')
-            .insert(edgeRows);
-        if (edgesError) {
-            throw new Error(`Failed to insert edges: ${edgesError.message}`);
-        }
-    }
-    return {
-        nodesCreated: insertedNodes?.length ?? 0,
-        edgesCreated: edgeRows.length,
-    };
-}
-function buildNodeRow(diagramId, node, index) {
-    return {
-        diagram_id: diagramId,
-        slug: node.slug,
-        name: node.name,
-        kind: node.kind,
-        schema: node,
-        position_x: (index % COLUMNS) * COLUMN_WIDTH,
-        position_y: Math.floor(index / COLUMNS) * ROW_HEIGHT,
-    };
-}
-function buildEdgeRow(diagramId, edge, slugToId) {
-    const fromId = slugToId.get(edge.fromSlug);
-    const toId = slugToId.get(edge.toSlug);
-    if (!fromId || !toId) {
-        return null;
-    }
-    return {
-        diagram_id: diagramId,
-        from_node_id: fromId,
-        to_node_id: toId,
-        label: edge.triggerLabel,
-        source_anchor: edge.triggerFile ?? null,
-        kind: edge.kind,
-    };
-}

package/dist/phases/screen-flow/mcp-server.d.ts

@@ -1,201 +0,0 @@
-/**
- * In-process MCP server exposing a single tool — `submit_screen_flow` —
- * that the Claude Agent SDK session calls to return the structured
- * extraction.
- *
- * Using a tool call instead of parsing a fenced text block lets the SDK
- * enforce the schema (via Zod) and lets the agent self-correct when
- * validation fails — the validation error is returned to the agent as
- * the tool result and it can re-call the tool with corrected data.
- *
- * The capture pattern: callers pass in a `ScreenFlowCaptureState`. The
- * tool handler stores the validated args on `state.captured` and the
- * orchestrator reads it after the SDK loop ends. If the agent never
- * calls the tool, `state.captured` stays null and the caller can fall
- * back to parsing the assistant text.
- */
-import { z } from 'zod';
-import type { ScreenFlowExtraction } from './types.js';
-export interface ScreenFlowCaptureState {
-    captured: ScreenFlowExtraction | null;
-}
-export declare function createScreenFlowCaptureState(): ScreenFlowCaptureState;
-/** Optional sink for streaming progress messages from the agent. */
-export type ScreenFlowProgressSink = (event: {
-    phase: 'detection' | 'routing' | 'screens' | 'transitions' | 'submission';
-    message: string;
-}) => void;
-export declare function validateConsistency(extraction: ScreenFlowExtraction): {
-    error: string | null;
-};
-/**
- * Build the `submit_screen_flow` tool. Exported separately from the server
- * so tests can exercise the handler directly without going through the
- * MCP transport.
- */
-export declare function createSubmitScreenFlowTool(state: ScreenFlowCaptureState): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    summary: z.ZodString;
-    nodes: z.ZodArray<z.ZodObject<{
-        slug: z.ZodString;
-        name: z.ZodString;
-        route: z.ZodOptional<z.ZodString>;
-        file: z.ZodOptional<z.ZodString>;
-        kind: z.ZodEnum<{
-            page: "page";
-            state: "state";
-            modal: "modal";
-            drawer: "drawer";
-            tab: "tab";
-        }>;
-        layout: z.ZodEnum<{
-            split: "split";
-            centered: "centered";
-            sidebar: "sidebar";
-            "list-detail": "list-detail";
-            tabs: "tabs";
-            stacked: "stacked";
-        }>;
-        header: z.ZodOptional<z.ZodObject<{
-            title: z.ZodString;
-            subtitle: z.ZodOptional<z.ZodString>;
-            back: z.ZodOptional<z.ZodBoolean>;
-            actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                label: z.ZodString;
-                variant: z.ZodOptional<z.ZodEnum<{
-                    primary: "primary";
-                    secondary: "secondary";
-                    ghost: "ghost";
-                    destructive: "destructive";
-                }>>;
-                icon: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>;
-        body: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"form">;
-            fields: z.ZodArray<z.ZodObject<{
-                label: z.ZodString;
-                kind: z.ZodEnum<{
-                    number: "number";
-                    text: "text";
-                    date: "date";
-                    select: "select";
-                    email: "email";
-                    password: "password";
-                    textarea: "textarea";
-                    checkbox: "checkbox";
-                }>;
-                placeholder: z.ZodOptional<z.ZodString>;
-                value: z.ZodOptional<z.ZodString>;
-                required: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strip>>;
-            submitLabel: z.ZodString;
-            secondaryLabel: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"list">;
-            items: z.ZodArray<z.ZodObject<{
-                title: z.ZodString;
-                subtitle: z.ZodOptional<z.ZodString>;
-                meta: z.ZodOptional<z.ZodString>;
-                icon: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            emptyMessage: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"card-grid">;
-            cards: z.ZodArray<z.ZodObject<{
-                title: z.ZodString;
-                subtitle: z.ZodOptional<z.ZodString>;
-                meta: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            columns: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"table">;
-            columns: z.ZodArray<z.ZodString>;
-            rows: z.ZodArray<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"kanban">;
-            columns: z.ZodArray<z.ZodObject<{
-                title: z.ZodString;
-                cards: z.ZodArray<z.ZodObject<{
-                    title: z.ZodString;
-                    meta: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"text">;
-            content: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"image">;
-            alt: z.ZodString;
-            aspect: z.ZodOptional<z.ZodEnum<{
-                video: "video";
-                square: "square";
-                wide: "wide";
-            }>>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"chart">;
-            chartKind: z.ZodEnum<{
-                line: "line";
-                bar: "bar";
-                pie: "pie";
-            }>;
-            label: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"stats">;
-            items: z.ZodArray<z.ZodObject<{
-                label: z.ZodString;
-                value: z.ZodString;
-                delta: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"empty-state">;
-            title: z.ZodString;
-            message: z.ZodOptional<z.ZodString>;
-            cta: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"tabs">;
-            tabs: z.ZodArray<z.ZodString>;
-            activeIndex: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"custom">;
-            label: z.ZodString;
-        }, z.core.$strip>], "type">>;
-    }, z.core.$strip>>;
-    edges: z.ZodArray<z.ZodObject<{
-        fromSlug: z.ZodString;
-        toSlug: z.ZodString;
-        triggerLabel: z.ZodString;
-        triggerFile: z.ZodOptional<z.ZodString>;
-        kind: z.ZodEnum<{
-            modal: "modal";
-            navigate: "navigate";
-            redirect: "redirect";
-            back: "back";
-        }>;
-    }, z.core.$strip>>;
-    theme: z.ZodOptional<z.ZodObject<{
-        primary: z.ZodOptional<z.ZodString>;
-        neutral: z.ZodOptional<z.ZodString>;
-        radius: z.ZodOptional<z.ZodString>;
-        font: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}>;
-/**
- * Build the `record_progress` tool. A side-channel that lets the agent
- * push a human-readable status message to the CLI / desktop UI so a
- * multi-minute extraction doesn't look frozen between text emissions.
- * Returning `{ ok: true }` keeps it cheap — it has no semantic effect
- * on the extraction.
- */
-export declare function createRecordProgressTool(sink?: ScreenFlowProgressSink): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    phase: z.ZodEnum<{
-        detection: "detection";
-        submission: "submission";
-        routing: "routing";
-        screens: "screens";
-        transitions: "transitions";
-    }>;
-    message: z.ZodString;
-}>;
-export declare function createScreenFlowMcpServer(state: ScreenFlowCaptureState, options?: {
-    onProgress?: ScreenFlowProgressSink;
-}): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;