edsger 0.69.0 → 0.71.0

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>;

package/dist/phases/diagram-shared/generate.js

@@ -0,0 +1,162 @@
+/**
+ * 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 { 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 { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
+import { cloneDiagramRepos, describeRepoScope } from './clone-repos.js';
+import { getDiagramRepositoryIds, isDiagramExtraction, markDiagramFailed, markDiagramRunning, markDiagramSuccess, persistDiagramGraph, validateGraphConsistency, } from './graph.js';
+import { createDiagramCaptureState, createDiagramMcpServer, } from './mcp.js';
+const MAX_TURNS = 150;
+export async function generateDiagram(options) {
+    const { productId, repoId, diagramId, guidance, verbose } = options;
+    const repoOnly = !productId && Boolean(repoId);
+    const label = options.mcpConfig.name;
+    logInfo(productId
+        ? `Starting ${label} generation for product ${productId}`
+        : `Starting ${label} 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: options.workspaceKey,
+        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 options.buildSystemPrompt({
+            projectDir,
+            hasCodebase: true,
+        });
+        const repoScope = describeRepoScope(repos);
+        const userPrompt = options.buildUserPrompt({
+            productName: product.name,
+            productDescription: product.description,
+            guidance: [guidance, repoScope].filter(Boolean).join('\n\n') || undefined,
+        });
+        logInfo(`Running Claude ${label} extraction...`);
+        const captureState = createDiagramCaptureState();
+        const mcpServer = createDiagramMcpServer(options.mcpConfig, captureState, {
+            onProgress: ({ phase, message }) => logInfo(`[${phase}] ${message}`),
+        });
+        let assistantBuffer = '';
+        let extraction = null;
+        const stream = query({
+            prompt: createPromptGenerator(userPrompt),
+            options: {
+                systemPrompt: {
+                    type: 'preset',
+                    preset: 'claude_code',
+                    append: systemPrompt,
+                },
+                model: DEFAULT_MODEL,
+                maxTurns: MAX_TURNS,
+                permissionMode: 'bypassPermissions',
+                cwd: projectDir,
+                mcpServers: { [options.mcpConfig.name]: mcpServer },
+            },
+        });
+        for await (const rawMessage of stream) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const message = rawMessage;
+            if (message.type === 'assistant') {
+                assistantBuffer += extractTextFromContent(message.message?.content ?? [], verbose);
+                continue;
+            }
+            if (message.type === 'user' && verbose) {
+                const userContent = message.message?.content;
+                if (Array.isArray(userContent)) {
+                    extractTextFromContent(userContent, verbose);
+                }
+                continue;
+            }
+            if (message.type !== 'result') {
+                continue;
+            }
+            if (captureState.captured) {
+                extraction = captureState.captured;
+                break;
+            }
+            const fallback = tryFallbackParse(message, assistantBuffer, options.fenceName);
+            if (fallback) {
+                logWarning(`Agent emitted a fenced ${options.fenceName} block instead of calling the submit tool; using the parsed text as a fallback.`);
+                extraction = fallback;
+            }
+            else if (message.subtype !== 'success') {
+                logError(`Extraction incomplete: ${message.subtype}`);
+            }
+        }
+        if (!extraction) {
+            const msg = `${label} extraction failed: agent did not call the submit tool and no parseable ${options.fenceName} block was found.`;
+            await markDiagramFailed(supabase, diagramId, msg);
+            return { status: 'error', message: msg };
+        }
+        logInfo(`Extraction produced ${extraction.nodes.length} ${options.nounPlural} / ${extraction.edges.length} ${options.edgeNounPlural}`);
+        const { nodesCreated, edgesCreated } = await persistDiagramGraph(supabase, diagramId, extraction);
+        await markDiagramSuccess(supabase, diagramId, extraction.summary);
+        succeeded = true;
+        logSuccess(`${label} generated: ${nodesCreated} ${options.nounPlural}, ${edgesCreated} ${options.edgeNounPlural}`);
+        return {
+            status: 'success',
+            message: `${label} generated (${nodesCreated} ${options.nounPlural}, ${edgesCreated} ${options.edgeNounPlural})`,
+            nodesCreated,
+            edgesCreated,
+            summary: extraction.summary,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`${label} failed: ${errorMessage}`);
+        await markDiagramFailed(supabase, diagramId, errorMessage);
+        return { status: 'error', message: errorMessage };
+    }
+    finally {
+        if (succeeded) {
+            cleanupIssueRepo(cleanupDir);
+        }
+    }
+}
+async function resolveRepoBasics(repositoryId, repos) {
+    const basics = await getRepositoryBasics(repositoryId).catch(() => null);
+    return {
+        name: basics?.fullName ?? repos[0]?.fullName ?? repositoryId,
+        description: basics?.description ?? undefined,
+    };
+}
+function tryFallbackParse(resultMessage, assistantText, fenceName) {
+    const responseText = resultMessage.subtype === 'success'
+        ? resultMessage.result || assistantText
+        : assistantText;
+    const parsed = tryExtractResult(responseText, fenceName);
+    if (!isDiagramExtraction(parsed)) {
+        return null;
+    }
+    const { error } = validateGraphConsistency(parsed);
+    if (error) {
+        logWarning(`Fallback extraction failed consistency check: ${error}`);
+        return null;
+    }
+    return parsed;
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Shared graph model + persistence for node/edge diagram types.
+ *
+ * Every diagram type (screen / data / er / sequence and the lean types built
+ * on this framework — state / class / architecture / flowchart) is a graph of
+ * nodes + edges stored in the generic `diagrams` / `diagram_nodes` /
+ * `diagram_edges` tables, discriminated by `diagrams.type`. This module owns
+ * the type-agnostic extraction shape, its consistency validation, and the
+ * persistence + status-transition helpers so each phase only has to describe
+ * its own domain schema and prompts.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+/** One node in a diagram. Domain-specific fields ride along and are stored
+ *  verbatim in `diagram_nodes.schema`. */
+export interface GraphNode {
+    /** Stable slug, unique within the diagram. */
+    slug: string;
+    name: string;
+    kind: string;
+    [key: string]: unknown;
+}
+/** One directed edge. fromSlug → toSlug must reference emitted node slugs. */
+export interface GraphEdge {
+    fromSlug: string;
+    toSlug: string;
+    kind: string;
+    label?: string;
+    /** File (jump-to-code) for the connection, stored as source_anchor. */
+    sourceFile?: string;
+    /** Extra per-edge data stored in diagram_edges.metadata (order, columns…). */
+    metadata?: Record<string, unknown>;
+}
+export interface DiagramExtraction {
+    summary: string;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+export declare function isGraphNode(value: unknown): value is GraphNode;
+export declare function isGraphEdge(value: unknown): value is GraphEdge;
+export declare function isDiagramExtraction(value: unknown): value is DiagramExtraction;
+/**
+ * Cross-field checks: unique node slugs and every edge endpoint references a
+ * node that was emitted. Returns a human-readable instruction on failure so
+ * the agent can self-correct and re-submit.
+ */
+export declare function validateGraphConsistency(extraction: DiagramExtraction): {
+    error: string | null;
+};
+export declare function markDiagramRunning(supabase: SupabaseClient, diagramId: string): Promise<void>;
+export declare function markDiagramFailed(supabase: SupabaseClient, diagramId: string, errorMessage: string): Promise<void>;
+export declare function markDiagramSuccess(supabase: SupabaseClient, diagramId: string, summary: string): Promise<void>;
+/** Read the ordered repo set a diagram was scoped to (may be empty). */
+export declare function getDiagramRepositoryIds(supabase: SupabaseClient, diagramId: string): Promise<string[]>;
+/**
+ * Replace the diagram's nodes and edges with a freshly extracted graph.
+ * Slugs are resolved to node ids for the edge foreign keys; edges whose
+ * endpoints weren't emitted are dropped.
+ */
+export declare function persistDiagramGraph(supabase: SupabaseClient, diagramId: string, extraction: DiagramExtraction): Promise<{
+    nodesCreated: number;
+    edgesCreated: number;
+}>;

package/dist/phases/diagram-shared/graph.js

@@ -0,0 +1,169 @@
+/**
+ * Shared graph model + persistence for node/edge diagram types.
+ *
+ * Every diagram type (screen / data / er / sequence and the lean types built
+ * on this framework — state / class / architecture / flowchart) is a graph of
+ * nodes + edges stored in the generic `diagrams` / `diagram_nodes` /
+ * `diagram_edges` tables, discriminated by `diagrams.type`. This module owns
+ * the type-agnostic extraction shape, its consistency validation, and the
+ * persistence + status-transition helpers so each phase only has to describe
+ * its own domain schema and prompts.
+ */
+import { logWarning } from '../../utils/logger.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function isGraphNode(value) {
+    return (isRecord(value) &&
+        typeof value.slug === 'string' &&
+        value.slug.length > 0 &&
+        typeof value.name === 'string' &&
+        value.name.length > 0 &&
+        typeof value.kind === 'string' &&
+        value.kind.length > 0);
+}
+export function isGraphEdge(value) {
+    return (isRecord(value) &&
+        typeof value.fromSlug === 'string' &&
+        typeof value.toSlug === 'string' &&
+        typeof value.kind === 'string');
+}
+export function isDiagramExtraction(value) {
+    return (isRecord(value) &&
+        typeof value.summary === 'string' &&
+        Array.isArray(value.nodes) &&
+        Array.isArray(value.edges) &&
+        value.nodes.every(isGraphNode) &&
+        value.edges.every(isGraphEdge));
+}
+/**
+ * Cross-field checks: unique node slugs and every edge endpoint references a
+ * node that was emitted. Returns a human-readable instruction on failure so
+ * the agent can self-correct and re-submit.
+ */
+export function validateGraphConsistency(extraction) {
+    const slugs = new Set();
+    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 diagram. Re-submit with deduplicated nodes.`,
+            };
+        }
+        slugs.add(node.slug);
+    }
+    for (const edge of extraction.edges) {
+        if (!slugs.has(edge.fromSlug)) {
+            return {
+                error: `Edge "${edge.fromSlug}" → "${edge.toSlug}": fromSlug does not match any node slug. Add the missing node or drop the edge, then re-submit.`,
+            };
+        }
+        if (!slugs.has(edge.toSlug)) {
+            return {
+                error: `Edge "${edge.fromSlug}" → "${edge.toSlug}": toSlug does not match any node slug. Add the missing node or drop the edge, then re-submit.`,
+            };
+        }
+    }
+    return { error: null };
+}
+// ============================================================================
+// Persistence
+// ============================================================================
+// Auto-layout grid; users drag afterwards and positions persist.
+const COLUMN_WIDTH = 320;
+const ROW_HEIGHT = 240;
+const COLUMNS = 4;
+export 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}`);
+    }
+}
+export async function markDiagramFailed(supabase, diagramId, errorMessage) {
+    await supabase
+        .from('diagrams')
+        .update({
+        status: 'failed',
+        error: errorMessage,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', diagramId);
+}
+export async function markDiagramSuccess(supabase, diagramId, summary) {
+    await supabase
+        .from('diagrams')
+        .update({
+        status: 'success',
+        summary,
+        error: null,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', diagramId);
+}
+/** Read the ordered repo set a diagram was scoped to (may be empty). */
+export async function getDiagramRepositoryIds(supabase, diagramId) {
+    const { data } = await supabase
+        .from('diagrams')
+        .select('repository_ids')
+        .eq('id', diagramId)
+        .single();
+    return (data?.repository_ids ?? []).filter(Boolean);
+}
+/**
+ * Replace the diagram's nodes and edges with a freshly extracted graph.
+ * Slugs are resolved to node ids for the edge foreign keys; edges whose
+ * endpoints weren't emitted are dropped.
+ */
+export async function persistDiagramGraph(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((node, i) => ({
+        diagram_id: diagramId,
+        slug: node.slug,
+        name: node.name,
+        kind: node.kind,
+        schema: node,
+        position_x: (i % COLUMNS) * COLUMN_WIDTH,
+        position_y: Math.floor(i / COLUMNS) * ROW_HEIGHT,
+    }));
+    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((edge) => {
+        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.label ?? null,
+            source_anchor: edge.sourceFile ?? null,
+            kind: edge.kind,
+            metadata: edge.metadata ?? {},
+        };
+    })
+        .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: nodeRows.length, edgesCreated: edgeRows.length };
+}