edsger 0.68.0 → 0.70.0

package/dist/phases/recipes/mcp-server.js

@@ -19,6 +19,27 @@
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
 import { RECIPE_CONTENT_MAX, RECIPE_EVIDENCE_MAX, RECIPE_NAME_MAX, RECIPE_SERVICE_NAME_MAX, RECIPE_SERVICES_MAX, RECIPE_SUMMARY_MAX, } from './types.js';
+function resolveLinkScope(ctx) {
+    if (ctx.repositoryId) {
+        return {
+            table: 'repository_recipes',
+            column: 'repository_id',
+            id: ctx.repositoryId,
+            onConflict: 'repository_id,recipe_id',
+            label: 'this repository',
+        };
+    }
+    if (ctx.productId) {
+        return {
+            table: 'product_recipes',
+            column: 'product_id',
+            id: ctx.productId,
+            onConflict: 'product_id,recipe_id',
+            label: 'this product',
+        };
+    }
+    throw new Error('RecipesToolContext requires either productId or repositoryId to scope links');
+}
 export function createRecipesMutationCounts() {
     return { created: 0, updated: 0, linked: 0, unlinked: 0 };
 }
@@ -92,17 +113,18 @@ export function createCreateRecipeTool(ctx, counts, teamRecipeIds) {
             return textError(`Failed to create recipe: ${insertRecipe.error?.message ?? 'unknown error'}`);
         }
         const recipeId = insertRecipe.data.id;
-        const linkErr = await ctx.supabase.from('product_recipes').insert({
-            product_id: ctx.productId,
+        const scope = resolveLinkScope(ctx);
+        const linkErr = await ctx.supabase.from(scope.table).insert({
+            [scope.column]: scope.id,
             recipe_id: recipeId,
             evidence: args.evidence.trim(),
         });
         if (linkErr.error) {
-            return textError(`Recipe created (${recipeId}) but linking to product failed: ${linkErr.error.message}`);
+            return textError(`Recipe created (${recipeId}) but linking to ${scope.label} failed: ${linkErr.error.message}`);
         }
         teamRecipeIds.add(recipeId);
         counts.created += 1;
-        return textOk(`Created recipe ${recipeId} and linked to this product.`);
+        return textOk(`Created recipe ${recipeId} and linked to ${scope.label}.`);
     });
 }
 export function createUpdateRecipeTool(ctx, counts, teamRecipeIds) {
@@ -136,16 +158,17 @@ export function createUpdateRecipeTool(ctx, counts, teamRecipeIds) {
                 return textError(`Failed to update recipe: ${updateErr.error.message}`);
             }
         }
-        const linkErr = await ctx.supabase.from('product_recipes').upsert({
-            product_id: ctx.productId,
+        const scope = resolveLinkScope(ctx);
+        const linkErr = await ctx.supabase.from(scope.table).upsert({
+            [scope.column]: scope.id,
             recipe_id: args.recipe_id,
             evidence: args.evidence.trim(),
-        }, { onConflict: 'product_id,recipe_id' });
+        }, { onConflict: scope.onConflict });
         if (linkErr.error) {
-            return textError(`Recipe updated but linking to product failed: ${linkErr.error.message}`);
+            return textError(`Recipe updated but linking to ${scope.label} failed: ${linkErr.error.message}`);
         }
         counts.updated += 1;
-        return textOk(`Updated recipe ${args.recipe_id} and linked to this product.`);
+        return textOk(`Updated recipe ${args.recipe_id} and linked to ${scope.label}.`);
     });
 }
 export function createLinkRecipeTool(ctx, counts, teamRecipeIds) {
@@ -156,36 +179,38 @@ export function createLinkRecipeTool(ctx, counts, teamRecipeIds) {
         if (!teamRecipeIds.has(args.recipe_id)) {
             return textError(`recipe_id ${args.recipe_id} is not in this team's recipe list. Use create_recipe for new entries.`);
         }
-        const linkErr = await ctx.supabase.from('product_recipes').upsert({
-            product_id: ctx.productId,
+        const scope = resolveLinkScope(ctx);
+        const linkErr = await ctx.supabase.from(scope.table).upsert({
+            [scope.column]: scope.id,
             recipe_id: args.recipe_id,
             evidence: args.evidence.trim(),
-        }, { onConflict: 'product_id,recipe_id' });
+        }, { onConflict: scope.onConflict });
         if (linkErr.error) {
             return textError(`Failed to link recipe: ${linkErr.error.message}`);
         }
         counts.linked += 1;
-        return textOk(`Linked recipe ${args.recipe_id} to this product.`);
+        return textOk(`Linked recipe ${args.recipe_id} to ${scope.label}.`);
     });
 }
 export function createUnlinkRecipeTool(ctx, counts, existingLinkIds) {
-    return tool('unlink_recipe', 'Drop a previously-linked recipe that you have confirmed is NO LONGER present in this repo. Only call this for ids in the "Currently linked to this product" list. Does not delete the recipe itself.', {
+    return tool('unlink_recipe', 'Drop a previously-linked recipe that you have confirmed is NO LONGER present in this repo. Only call this for ids in the "Currently linked" list. Does not delete the recipe itself.', {
         recipe_id: z.string().uuid(),
     }, async (args) => {
         if (!existingLinkIds.has(args.recipe_id)) {
-            return textError(`recipe_id ${args.recipe_id} is not in the "Currently linked to this product" list — nothing to unlink.`);
+            return textError(`recipe_id ${args.recipe_id} is not in the "Currently linked" list — nothing to unlink.`);
         }
+        const scope = resolveLinkScope(ctx);
         const { error } = await ctx.supabase
-            .from('product_recipes')
+            .from(scope.table)
             .delete()
-            .eq('product_id', ctx.productId)
+            .eq(scope.column, scope.id)
             .eq('recipe_id', args.recipe_id);
         if (error) {
             return textError(`Failed to unlink recipe: ${error.message}`);
         }
         existingLinkIds.delete(args.recipe_id);
         counts.unlinked += 1;
-        return textOk(`Unlinked recipe ${args.recipe_id} from this product.`);
+        return textOk(`Unlinked recipe ${args.recipe_id} from ${scope.label}.`);
     });
 }
 export function createRecipesMcpServer(ctx, counts, teamRecipes, existingLinkIds) {

package/dist/phases/screen-flow/index.d.ts

@@ -1,15 +1,18 @@
 /**
  * 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 flows / flow_nodes /
- * flow_edges (rows tagged `type = 'screen'`) via the Supabase SDK.
+ * 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.
  */
 export interface ScreenFlowOptions {
-    productId: string;
-    flowId: string;
+    /** Product-scoped flow. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only flow: a single repositories row, no product context. */
+    repoId?: string;
+    diagramId: string;
     guidance?: string;
     verbose?: boolean;
 }

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

@@ -1,19 +1,20 @@
 /**
  * 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 flows / flow_nodes /
- * flow_edges (rows tagged `type = 'screen'`) via the Supabase SDK.
+ * 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 { fetchProductBasics } from '../find-shared/mcp.js';
-import { cloneFlowRepos, describeRepoScope } from '../flow-shared/clone-repos.js';
+import { cloneDiagramRepos, describeRepoScope } from '../diagram-shared/clone-repos.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';
@@ -26,25 +27,34 @@ const COLUMN_WIDTH = 380;
 const ROW_HEIGHT = 480;
 const COLUMNS = 4;
 export async function runScreenFlowPhase(options) {
-    const { productId, flowId, guidance, verbose } = options;
-    logInfo(`Starting screen-flow generation for product ${productId}`);
+    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 markFlowRunning(supabase, flowId);
-    const repositoryIds = await getFlowRepositoryIds(supabase, flowId);
-    const cloneResult = await cloneFlowRepos({
+    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 markFlowFailed(supabase, flowId, cloneResult.message);
+        await markDiagramFailed(supabase, diagramId, cloneResult.message);
         return { status: 'error', message: cloneResult.message };
     }
     const { projectDir, cleanupDir, repos } = cloneResult;
     let succeeded = false;
     try {
-        const product = await fetchProductBasics(productId);
+        const product = repoOnly
+            ? await resolveRepoBasics(repoId, repos)
+            : await fetchProductBasics(productId);
         const systemPrompt = await createScreenFlowSystemPrompt({
             projectDir,
             hasCodebase: true,
@@ -94,17 +104,17 @@ export async function runScreenFlowPhase(options) {
         }
         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 markFlowFailed(supabase, flowId, msg);
+            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, flowId, theme);
+            await persistTheme(supabase, diagramId, theme);
         }
-        const { nodesCreated, edgesCreated } = await persistFlow(supabase, flowId, extraction);
-        await markFlowSuccess(supabase, flowId, extraction.summary);
+        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 {
@@ -118,7 +128,7 @@ export async function runScreenFlowPhase(options) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logError(`Screen flow failed: ${errorMessage}`);
-        await markFlowFailed(supabase, flowId, errorMessage);
+        await markDiagramFailed(supabase, diagramId, errorMessage);
         return { status: 'error', message: errorMessage };
     }
     finally {
@@ -148,12 +158,23 @@ function resolveTheme(agentTheme, repos) {
     }
     return {};
 }
-/** Read the ordered repo set a flow was scoped to (may be empty). */
-async function getFlowRepositoryIds(supabase, flowId) {
+/**
+ * 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('flows')
+        .from('diagrams')
         .select('repository_ids')
-        .eq('id', flowId)
+        .eq('id', diagramId)
         .single();
     return (data?.repository_ids ?? []).filter(Boolean);
 }
@@ -213,31 +234,31 @@ function tryFallbackParse(resultMessage, assistantText) {
 // ============================================================================
 // Persistence
 // ============================================================================
-async function markFlowRunning(supabase, flowId) {
+async function markDiagramRunning(supabase, diagramId) {
     const { error } = await supabase
-        .from('flows')
+        .from('diagrams')
         .update({ status: 'running', error: null })
-        .eq('id', flowId);
+        .eq('id', diagramId);
     if (error) {
-        logWarning(`Could not mark flow as running: ${error.message}`);
+        logWarning(`Could not mark diagram as running: ${error.message}`);
     }
 }
-async function markFlowFailed(supabase, flowId, errorMessage) {
+async function markDiagramFailed(supabase, diagramId, errorMessage) {
     await supabase
-        .from('flows')
+        .from('diagrams')
         .update({
         status: 'failed',
         error: errorMessage,
         completed_at: new Date().toISOString(),
     })
-        .eq('id', flowId);
+        .eq('id', diagramId);
 }
-async function persistTheme(supabase, flowId, theme) {
+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('flows')
+        .from('diagrams')
         .select('options')
-        .eq('id', flowId)
+        .eq('id', diagramId)
         .single();
     if (readError) {
         logWarning(`Could not read flow options: ${readError.message}`);
@@ -248,34 +269,34 @@ async function persistTheme(supabase, flowId, theme) {
         theme,
     };
     const { error } = await supabase
-        .from('flows')
+        .from('diagrams')
         .update({ options: nextOptions })
-        .eq('id', flowId);
+        .eq('id', diagramId);
     if (error) {
         logWarning(`Could not persist extracted theme: ${error.message}`);
     }
 }
-async function markFlowSuccess(supabase, flowId, summary) {
+async function markDiagramSuccess(supabase, diagramId, summary) {
     await supabase
-        .from('flows')
+        .from('diagrams')
         .update({
         status: 'success',
         summary,
         error: null,
         completed_at: new Date().toISOString(),
     })
-        .eq('id', flowId);
+        .eq('id', diagramId);
 }
-async function persistFlow(supabase, flowId, extraction) {
+async function persistDiagram(supabase, diagramId, extraction) {
     // Re-runs replace prior content for the same flow row.
-    await supabase.from('flow_edges').delete().eq('flow_id', flowId);
-    await supabase.from('flow_nodes').delete().eq('flow_id', flowId);
+    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(flowId, n, i));
+    const nodeRows = extraction.nodes.map((n, i) => buildNodeRow(diagramId, n, i));
     const { data: insertedNodes, error: nodesError } = await supabase
-        .from('flow_nodes')
+        .from('diagram_nodes')
         .insert(nodeRows)
         .select('id, slug');
     if (nodesError) {
@@ -283,11 +304,11 @@ async function persistFlow(supabase, flowId, extraction) {
     }
     const slugToId = new Map((insertedNodes ?? []).map((n) => [n.slug, n.id]));
     const edgeRows = extraction.edges
-        .map((e) => buildEdgeRow(flowId, e, slugToId))
+        .map((e) => buildEdgeRow(diagramId, e, slugToId))
         .filter((e) => e !== null);
     if (edgeRows.length > 0) {
         const { error: edgesError } = await supabase
-            .from('flow_edges')
+            .from('diagram_edges')
             .insert(edgeRows);
         if (edgesError) {
             throw new Error(`Failed to insert edges: ${edgesError.message}`);
@@ -298,9 +319,9 @@ async function persistFlow(supabase, flowId, extraction) {
         edgesCreated: edgeRows.length,
     };
 }
-function buildNodeRow(flowId, node, index) {
+function buildNodeRow(diagramId, node, index) {
     return {
-        flow_id: flowId,
+        diagram_id: diagramId,
         slug: node.slug,
         name: node.name,
         kind: node.kind,
@@ -309,14 +330,14 @@ function buildNodeRow(flowId, node, index) {
         position_y: Math.floor(index / COLUMNS) * ROW_HEIGHT,
     };
 }
-function buildEdgeRow(flowId, edge, slugToId) {
+function buildEdgeRow(diagramId, edge, slugToId) {
     const fromId = slugToId.get(edge.fromSlug);
     const toId = slugToId.get(edge.toSlug);
     if (!fromId || !toId) {
         return null;
     }
     return {
-        flow_id: flowId,
+        diagram_id: diagramId,
         from_node_id: fromId,
         to_node_id: toId,
         label: edge.triggerLabel,

package/dist/phases/screen-flow/mcp-server.js

@@ -166,7 +166,7 @@ export function validateConsistency(extraction) {
     for (const node of extraction.nodes) {
         if (slugs.has(node.slug)) {
             return {
-                error: `Duplicate node slug "${node.slug}". Each node.slug MUST be unique within the flow. Re-call submit_screen_flow with deduplicated nodes.`,
+                error: `Duplicate node slug "${node.slug}". Each node.slug MUST be unique within the diagram. Re-call submit_screen_flow with deduplicated nodes.`,
             };
         }
         slugs.add(node.slug);
@@ -208,7 +208,7 @@ export function createSubmitScreenFlowTool(state) {
             .describe('1-3 sentence narrative of what kind of app this is and its primary user flows.'),
         nodes: z
             .array(screenNodeSchema)
-            .describe('Every user-facing screen, modal, drawer, tab, or named state. node.slug MUST be unique within the flow.'),
+            .describe('Every user-facing screen, modal, drawer, tab, or named state. node.slug MUST be unique within the diagram.'),
         edges: z
             .array(screenEdgeSchema)
             .describe('Transitions between screens. Every fromSlug / toSlug MUST reference a slug present in nodes; drop edges whose endpoints you did not emit.'),

package/dist/phases/sequence-diagram/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * sequence-diagram phase: clone the product's repo, ask Claude to trace one
+ * scenario through the code and map the participants (actor / service /
+ * component / database / queue / external) and the ordered messages between
+ * them into a structured SequenceDiagramExtraction, then persist the result
+ * to diagrams / diagram_nodes / diagram_edges (rows tagged `type = 'sequence'`) via the
+ * Supabase SDK.
+ *
+ * Companion to data-flow / screen-flow / er-diagram: same generation pattern
+ * (workspace clone + Claude Agent SDK + in-process MCP server), same storage
+ * tables, different domain. Message ordering is persisted in the edge's
+ * `metadata.order`.
+ */
+export interface SequenceDiagramPhaseOptions {
+    /** Product-scoped diagram. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only diagram: a single repositories row, no product context. */
+    repoId?: string;
+    diagramId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export interface SequenceDiagramPhaseResult {
+    status: 'success' | 'error';
+    message: string;
+    nodesCreated?: number;
+    edgesCreated?: number;
+    summary?: string;
+}
+export declare function runSequenceDiagramPhase(options: SequenceDiagramPhaseOptions): Promise<SequenceDiagramPhaseResult>;