edsger 0.68.0 → 0.70.0

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

@@ -2,7 +2,7 @@
  * data-flow phase: clone the product's repo, ask Claude to map every data
  * node (source / dataset / transform / sink / queue / model) and the
  * connections between them into a structured DataFlowExtraction, then
- * persist the result to flows / flow_nodes / flow_edges (rows tagged
+ * persist the result to diagrams / diagram_nodes / diagram_edges (rows tagged
  * `type = 'data'`) via the Supabase SDK.
  *
  * Companion to screen-flow: same generation pattern (workspace clone +
@@ -10,12 +10,13 @@
  * domain.
  */
 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 { createDataFlowCaptureState, createDataFlowMcpServer, validateConsistency, } from './mcp-server.js';
 import { createDataFlowSystemPrompt, createDataFlowUserPrompt, } from './prompts.js';
@@ -27,25 +28,34 @@ const COLUMN_WIDTH = 320;
 const ROW_HEIGHT = 220;
 const COLUMNS = 4;
 export async function runDataFlowPhase(options) {
-    const { productId, flowId, guidance, verbose } = options;
-    logInfo(`Starting data-flow generation for product ${productId}`);
+    const { productId, repoId, diagramId, guidance, verbose } = options;
+    const repoOnly = !productId && Boolean(repoId);
+    if (productId) {
+        logInfo(`Starting data-flow generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting data-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 createDataFlowSystemPrompt({
             projectDir,
             hasCodebase: true,
@@ -90,12 +100,12 @@ export async function runDataFlowPhase(options) {
         }
         if (!extraction) {
             const msg = 'Data flow extraction failed: agent did not call submit_data_flow and no parseable data_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} nodes / ${extraction.edges.length} connections`);
-        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(`Data flow generated: ${nodesCreated} nodes, ${edgesCreated} connections`);
         return {
@@ -109,7 +119,7 @@ export async function runDataFlowPhase(options) {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logError(`Data flow failed: ${errorMessage}`);
-        await markFlowFailed(supabase, flowId, errorMessage);
+        await markDiagramFailed(supabase, diagramId, errorMessage);
         return { status: 'error', message: errorMessage };
     }
     finally {
@@ -118,12 +128,23 @@ export async function runDataFlowPhase(options) {
         }
     }
 }
-/** 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);
 }
@@ -176,45 +197,45 @@ 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 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) {
-    await supabase.from('flow_edges').delete().eq('flow_id', flowId);
-    await supabase.from('flow_nodes').delete().eq('flow_id', flowId);
+async function persistDiagram(supabase, diagramId, extraction) {
+    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) {
@@ -222,11 +243,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}`);
@@ -237,9 +258,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,
@@ -248,14 +269,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.label ?? null,

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

@@ -27,8 +27,8 @@ export declare function createSubmitDataFlowTool(state: DataFlowCaptureState): i
         kind: z.ZodEnum<{
             model: "model";
             source: "source";
-            dataset: "dataset";
             transform: "transform";
+            dataset: "dataset";
             sink: "sink";
             queue: "queue";
         }>;

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

@@ -53,7 +53,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_data_flow with deduplicated nodes.`,
+                error: `Duplicate node slug "${node.slug}". Each node.slug MUST be unique within the diagram. Re-call submit_data_flow with deduplicated nodes.`,
             };
         }
         slugs.add(node.slug);
@@ -87,7 +87,7 @@ export function createSubmitDataFlowTool(state) {
             .describe('1-3 sentence narrative of what this system does with data and the primary pipelines.'),
         nodes: z
             .array(dataNodeSchema)
-            .describe('Every data node: source / dataset / transform / sink / queue / model. node.slug MUST be unique within the flow.'),
+            .describe('Every data node: source / dataset / transform / sink / queue / model. node.slug MUST be unique within the diagram.'),
         edges: z
             .array(dataEdgeSchema)
             .describe('Connections. fromSlug = upstream, toSlug = downstream. Every fromSlug / toSlug MUST reference a slug present in nodes; drop edges whose endpoints you did not emit.'),

package/dist/phases/data-flow/types.d.ts

@@ -8,7 +8,7 @@
  * unified <DataNodePreview> component.
  *
  * Companion to ScreenSchema: same flow-graph shape (nodes + edges with a
- * shared `flows` table storing the JSONB schema), different domain. Data
+ * shared `diagrams` table storing the JSONB schema), different domain. Data
  * flow edges describe how data moves between nodes, not user navigation.
  */
 export type DataNodeKind = 'source' | 'dataset' | 'transform' | 'sink' | 'queue' | 'model';

package/dist/phases/data-flow/types.js

@@ -8,7 +8,7 @@
  * unified <DataNodePreview> component.
  *
  * Companion to ScreenSchema: same flow-graph shape (nodes + edges with a
- * shared `flows` table storing the JSONB schema), different domain. Data
+ * shared `diagrams` table storing the JSONB schema), different domain. Data
  * flow edges describe how data moves between nodes, not user navigation.
  */
 // ============================================================================

package/dist/phases/diagram-shared/clone-repos.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared multi-repo cloning for flow generation (screen-flow / data-flow).
+ *
+ * A flow can be scoped to one or several repositories (the user picks them in
+ * the desktop UI; the chosen set is stored on `diagrams.repository_ids`). This
+ * helper resolves that set, clones each repo into a per-flow parent workspace
+ * directory, and returns the directory the agent should run against:
+ *   - single repo  → the repo's own clone dir
+ *   - many repos   → the parent dir holding every clone as a subdirectory,
+ *                    so the agent can explore them all and produce one unified
+ *                    flow.
+ *
+ * Falls back to the product's primary repo when `repository_ids` is empty
+ * (older diagrams, or single-repo products).
+ */
+export interface ClonedRepo {
+    fullName: string;
+    owner: string;
+    repo: string;
+    dir: string;
+}
+export interface CloneFlowReposSuccess {
+    ok: true;
+    /** Directory to point the agent at (parent dir for multi-repo). */
+    projectDir: string;
+    /** Directory to clean up afterwards (always the per-flow parent). */
+    cleanupDir: string;
+    repos: ClonedRepo[];
+}
+export interface CloneFlowReposFailure {
+    ok: false;
+    message: string;
+}
+export declare function safeDirName(fullName: string): string;
+/**
+ * Resolve the repositories a flow targets (by id, preserving the stored
+ * order), falling back to the product's primary repo.
+ *
+ * In repo-only mode there is no product, so no `fallback` is provided: the
+ * set is resolved purely from `repositoryIds`.
+ */
+export declare function resolveTargetRepos(productId: string | undefined, repositoryIds: string[], fallback?: {
+    owner: string;
+    repo: string;
+}): Promise<{
+    fullName: string;
+    owner: string;
+    repo: string;
+}[]>;
+export declare function cloneDiagramRepos(opts: {
+    /** Product-scoped flow. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only flow: a single repositories row, no product context. */
+    repoId?: string;
+    repositoryIds: string[];
+    workspaceKey: string;
+    verbose?: boolean;
+}): Promise<CloneFlowReposSuccess | CloneFlowReposFailure>;
+/**
+ * Build a short note describing the repo scope, appended to the agent's user
+ * prompt so it knows whether to map one repo or unify several.
+ */
+export declare function describeRepoScope(repos: ClonedRepo[]): string;

package/dist/phases/diagram-shared/clone-repos.js

@@ -0,0 +1,153 @@
+/**
+ * Shared multi-repo cloning for flow generation (screen-flow / data-flow).
+ *
+ * A flow can be scoped to one or several repositories (the user picks them in
+ * the desktop UI; the chosen set is stored on `diagrams.repository_ids`). This
+ * helper resolves that set, clones each repo into a per-flow parent workspace
+ * directory, and returns the directory the agent should run against:
+ *   - single repo  → the repo's own clone dir
+ *   - many repos   → the parent dir holding every clone as a subdirectory,
+ *                    so the agent can explore them all and produce one unified
+ *                    flow.
+ *
+ * Falls back to the product's primary repo when `repository_ids` is empty
+ * (older diagrams, or single-repo products).
+ */
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
+import { getSupabase } from '../../supabase/client.js';
+import { logInfo, logWarning } from '../../utils/logger.js';
+import { cloneIssueRepo, ensureWorkspaceDir, getIssueRepoPath, } from '../../workspace/workspace-manager.js';
+export function safeDirName(fullName) {
+    return fullName.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+/**
+ * Resolve the repositories a flow targets (by id, preserving the stored
+ * order), falling back to the product's primary repo.
+ *
+ * In repo-only mode there is no product, so no `fallback` is provided: the
+ * set is resolved purely from `repositoryIds`.
+ */
+export async function resolveTargetRepos(productId, repositoryIds, fallback) {
+    if (repositoryIds.length === 0) {
+        if (fallback) {
+            return [
+                {
+                    fullName: `${fallback.owner}/${fallback.repo}`,
+                    owner: fallback.owner,
+                    repo: fallback.repo,
+                },
+            ];
+        }
+        return [];
+    }
+    const supabase = getSupabase();
+    const { data } = await supabase
+        .from('repositories')
+        .select('id, full_name')
+        .in('id', repositoryIds);
+    const byId = new Map((data ?? []).map((r) => [r.id, r.full_name]));
+    // Preserve the caller's order (diagrams.repository_ids is ordered).
+    const resolved = [];
+    for (const id of repositoryIds) {
+        const fullName = byId.get(id);
+        if (!fullName) {
+            continue;
+        }
+        const [owner, repo] = fullName.split('/');
+        if (!owner || !repo) {
+            continue;
+        }
+        resolved.push({ fullName, owner, repo });
+    }
+    // If none resolved (deleted repos / RLS), fall back to the primary repo so
+    // generation still produces something useful (product mode only).
+    if (resolved.length === 0 && fallback) {
+        return [
+            {
+                fullName: `${fallback.owner}/${fallback.repo}`,
+                owner: fallback.owner,
+                repo: fallback.repo,
+            },
+        ];
+    }
+    return resolved;
+}
+export async function cloneDiagramRepos(opts) {
+    const { productId, repoId, repositoryIds, workspaceKey, verbose } = opts;
+    const repoOnly = !productId && Boolean(repoId);
+    // Resolve the auth token. Product mode reuses the product's installation /
+    // PAT for every repo; repo-only mode resolves it from the first (only) repo.
+    const gh = repoOnly
+        ? await getGitHubConfigByRepository(repositoryIds[0] ?? repoId, verbose)
+        : await getGitHubConfigByProduct(productId, verbose);
+    if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
+        return {
+            ok: false,
+            message: gh.message ||
+                (repoOnly
+                    ? 'GitHub repository not configured. Connect the repo first.'
+                    : 'GitHub repository not configured for this product. Connect a repo first.'),
+        };
+    }
+    // In repo-only mode there is no product primary-repo fallback; targets come
+    // purely from repositoryIds.
+    const targets = await resolveTargetRepos(productId, repositoryIds, repoOnly ? undefined : { owner: gh.owner, repo: gh.repo });
+    if (targets.length === 0) {
+        return {
+            ok: false,
+            message: 'No repositories resolved for this flow.',
+        };
+    }
+    const workspaceRoot = ensureWorkspaceDir();
+    const parentDir = getIssueRepoPath(workspaceRoot, `${workspaceKey}-${repoOnly ? `repo-${repoId}` : productId}`);
+    const repos = [];
+    for (const target of targets) {
+        try {
+            // The product-level token (installation or user PAT/OAuth) is reused for
+            // every repo; if it can't access one, that clone fails and we skip it
+            // rather than aborting the whole generation.
+            const { repoPath } = cloneIssueRepo(parentDir, safeDirName(target.fullName), target.owner, target.repo, gh.token);
+            repos.push({
+                fullName: target.fullName,
+                owner: target.owner,
+                repo: target.repo,
+                dir: repoPath,
+            });
+        }
+        catch (err) {
+            logWarning(`Skipping ${target.fullName}: clone failed (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+    if (repos.length === 0) {
+        return {
+            ok: false,
+            message: 'Failed to clone any of the selected repositories.',
+        };
+    }
+    if (repos.length > 1) {
+        logInfo(`Cloned ${repos.length} repos for ${workspaceKey}: ${repos.map((r) => r.fullName).join(', ')}`);
+    }
+    return {
+        ok: true,
+        // Single repo: run directly in its dir. Multi-repo: run in the parent so
+        // the agent sees every clone as a subdirectory.
+        projectDir: repos.length === 1 ? repos[0].dir : parentDir,
+        cleanupDir: parentDir,
+        repos,
+    };
+}
+/**
+ * Build a short note describing the repo scope, appended to the agent's user
+ * prompt so it knows whether to map one repo or unify several.
+ */
+export function describeRepoScope(repos) {
+    if (repos.length <= 1) {
+        return '';
+    }
+    const list = repos.map((r) => `- ${r.fullName} (subdirectory: ${safeDirName(r.fullName)})`);
+    return [
+        `This product spans ${repos.length} repositories, each cloned into its own subdirectory of the working directory:`,
+        ...list,
+        'Explore all of them and produce a single unified flow that spans the repositories.',
+    ].join('\n');
+}

package/dist/phases/diagram-shared/generate.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared diagram generation runner.
+ *
+ * Encapsulates the common pipeline every node/edge diagram phase uses: clone
+ * the repo(s), resolve product/repo basics, build prompts, run the Claude
+ * Agent SDK loop with an in-process MCP capture server, fall back to a fenced
+ * block if the agent forgot the tool, then persist to the diagrams tables and
+ * flip status. Each lean phase just supplies its domain MCP config + prompts.
+ */
+import { type DiagramMcpConfig } from './mcp.js';
+export interface GenerateDiagramOptions {
+    productId?: string;
+    repoId?: string;
+    diagramId: string;
+    guidance?: string;
+    verbose?: boolean;
+    /** Workspace clone key, e.g. 'state-diagram'. */
+    workspaceKey: string;
+    /** Fenced block name for the fallback parser, e.g. 'state_diagram'. */
+    fenceName: string;
+    /** Plural noun for log/result messages, e.g. 'states', 'classes'. */
+    nounPlural: string;
+    edgeNounPlural: string;
+    mcpConfig: DiagramMcpConfig;
+    buildSystemPrompt: (args: {
+        projectDir: string;
+        hasCodebase: boolean;
+    }) => Promise<string>;
+    buildUserPrompt: (args: {
+        productName: string;
+        productDescription?: string;
+        guidance?: string;
+    }) => string;
+}
+export interface DiagramPhaseResult {
+    status: 'success' | 'error';
+    message: string;
+    nodesCreated?: number;
+    edgesCreated?: number;
+    summary?: string;
+}
+export declare function generateDiagram(options: GenerateDiagramOptions): Promise<DiagramPhaseResult>;