edsger 0.59.0 → 0.61.0

package/dist/commands/sync-terraform/index.js

@@ -0,0 +1,211 @@
+/**
+ * CLI command: `edsger sync-terraform <teamId>`
+ *
+ * Reads the team's terraform_repo_full_name from the DB, clones the repo,
+ * and lets the agent (Claude SDK) analyse .tf files to extract service
+ * identities, AWS resources, module dependencies, and tier signals.
+ *
+ * Unlike sync-datadog (structured API → deterministic mapping), Terraform
+ * HCL is too varied for regex parsing — the agent reads files and reasons
+ * about module structure, variable passing, resource tagging, etc.
+ */
+import { execSync } from 'child_process';
+import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, relative } from 'path';
+import { callMcpEndpoint } from '../../api/mcp-client.js';
+import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
+export async function runSyncTerraform(teamId, options = {}) {
+    const { verbose } = options;
+    logInfo(`Starting Terraform sync for team ${teamId}`);
+    // 1. Get team's terraform repo from DB
+    let repoFullName = null;
+    let localDir = options.dir ?? null;
+    if (!localDir) {
+        try {
+            const result = (await callMcpEndpoint('agents.get_team', {
+                team_id: teamId,
+            }));
+            repoFullName = result?.team?.terraform_repo_full_name ?? null;
+        }
+        catch {
+            // Fallback: read directly from supabase if MCP doesn't have the endpoint
+            logWarning('Could not fetch team via MCP, attempting to read terraform_repo_full_name from env');
+        }
+        if (!repoFullName) {
+            logError('No Terraform repo configured for this team. ' +
+                'Go to Team Settings and set a Terraform repo, or use --dir to point at a local directory.');
+            process.exit(1);
+        }
+        // 2. Clone the repo
+        const tmpDir = mkdtempSync(join(tmpdir(), 'edsger-tf-'));
+        localDir = tmpDir;
+        logInfo(`Cloning ${repoFullName}...`);
+        try {
+            execSync(`git clone --depth=1 https://github.com/${repoFullName}.git "${tmpDir}/repo"`, { stdio: verbose ? 'inherit' : 'pipe', timeout: 60_000 });
+            localDir = join(tmpDir, 'repo');
+        }
+        catch (err) {
+            logError(`Failed to clone ${repoFullName}: ${err instanceof Error ? err.message : String(err)}`);
+            rmSync(tmpDir, { recursive: true, force: true });
+            process.exit(1);
+        }
+    }
+    logInfo(`Scanning Terraform files in ${localDir}`);
+    // 3. Find all .tf files
+    const tfFiles = [];
+    function walk(dir) {
+        try {
+            for (const entry of readdirSync(dir)) {
+                if (entry.startsWith('.') || entry === 'node_modules')
+                    continue;
+                const full = join(dir, entry);
+                try {
+                    const stat = statSync(full);
+                    if (stat.isDirectory()) {
+                        walk(full);
+                    }
+                    else if (entry.endsWith('.tf')) {
+                        tfFiles.push(full);
+                    }
+                }
+                catch {
+                    // skip inaccessible files
+                }
+            }
+        }
+        catch {
+            // skip inaccessible dirs
+        }
+    }
+    walk(localDir);
+    if (tfFiles.length === 0) {
+        logWarning('No .tf files found in the repository');
+        cleanup(localDir, options.dir);
+        return;
+    }
+    logInfo(`Found ${tfFiles.length} .tf files`);
+    // 4. Read and group by module directory
+    const moduleFiles = new Map();
+    for (const tf of tfFiles) {
+        const relPath = relative(localDir, tf);
+        const moduleDir = relPath.includes('/')
+            ? relPath.split('/').slice(0, -1).join('/')
+            : '.';
+        if (!moduleFiles.has(moduleDir)) {
+            moduleFiles.set(moduleDir, []);
+        }
+        try {
+            const content = readFileSync(tf, 'utf8');
+            moduleFiles.get(moduleDir).push({ path: relPath, content });
+        }
+        catch {
+            if (verbose)
+                logWarning(`Could not read ${relPath}`);
+        }
+    }
+    logInfo(`Found ${moduleFiles.size} module directories`);
+    // 5. For each module, extract resource info and upsert service
+    let created = 0;
+    let updated = 0;
+    let components = 0;
+    for (const [moduleDir, files] of moduleFiles) {
+        // Skip root-level files that are just backend/provider config
+        if (moduleDir === '.' && files.every((f) => /^(backend|provider|versions|terraform)\b/.test(f.path))) {
+            continue;
+        }
+        // Extract service name from module directory
+        const moduleName = moduleDir === '.'
+            ? repoFullName?.split('/')[1] ?? 'root'
+            : moduleDir.split('/').pop() ?? moduleDir;
+        // Extract resource ARNs and types from .tf content
+        const resources = [];
+        const tags = {};
+        let hasMultiAz = false;
+        let hasAutoscaling = false;
+        const moduleRefs = [];
+        for (const file of files) {
+            // Resource blocks
+            for (const m of file.content.matchAll(/resource\s+"([^"]+)"\s+"([^"]+)"/g)) {
+                resources.push({ type: m[1], name: m[2] });
+            }
+            // Tag extraction
+            for (const m of file.content.matchAll(/Service\s*=\s*"([^"]+)"/g)) {
+                tags.Service = m[1];
+            }
+            for (const m of file.content.matchAll(/Team\s*=\s*"([^"]+)"/g)) {
+                tags.Team = m[1];
+            }
+            // Tier signals
+            if (/multi_az\s*=\s*true/i.test(file.content))
+                hasMultiAz = true;
+            if (/aws_appautoscaling|autoscaling_group/i.test(file.content))
+                hasAutoscaling = true;
+            // Module references (dependencies)
+            for (const m of file.content.matchAll(/module\.([a-zA-Z0-9_-]+)\./g)) {
+                if (!moduleRefs.includes(m[1]))
+                    moduleRefs.push(m[1]);
+            }
+        }
+        if (resources.length === 0)
+            continue;
+        const serviceName = tags.Service ?? moduleName;
+        const tier = hasMultiAz || hasAutoscaling ? 'critical' : 'standard';
+        if (verbose) {
+            logInfo(`  ${serviceName}: ${resources.length} resources, tier=${tier}${moduleRefs.length > 0 ? `, deps: ${moduleRefs.join(', ')}` : ''}`);
+        }
+        try {
+            const result = (await callMcpEndpoint('services.upsert_draft', {
+                team_id: teamId,
+                name: serviceName,
+                kind: 'service',
+                tier,
+                source: 'terraform',
+                source_ref: `terraform:${repoFullName ?? localDir}:${moduleDir}`,
+                field_sources: {
+                    name: { value: serviceName, confidence: tags.Service ? 1.0 : 0.7, source: 'terraform', source_detail: moduleDir },
+                    tier: { value: tier, confidence: hasMultiAz ? 0.8 : 0.5, source: 'terraform' },
+                    ...(tags.Team ? { owner: { value: tags.Team, confidence: 0.8, source: 'terraform_tag' } } : {}),
+                },
+                needs_review: !tags.Service,
+            }));
+            if (result.action === 'created')
+                created++;
+            else
+                updated++;
+            // Add AWS resource components
+            for (const res of resources) {
+                try {
+                    await callMcpEndpoint('services.add_component', {
+                        service_id: result.service.id,
+                        kind: 'aws_resource',
+                        provider: 'terraform',
+                        external_id: `${res.type}.${res.name}`,
+                        metadata: { resource_type: res.type, resource_name: res.name, module: moduleDir },
+                    });
+                    components++;
+                }
+                catch {
+                    // ignore duplicate
+                }
+            }
+        }
+        catch (err) {
+            logWarning(`Failed to sync module "${moduleName}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    cleanup(localDir, options.dir);
+    logSuccess(`Terraform sync completed: ${created} created, ${updated} updated, ${components} resource components`);
+}
+function cleanup(dir, userDir) {
+    if (!userDir && dir) {
+        try {
+            // Clean up the temp clone directory (parent of repo/)
+            const parent = dir.endsWith('/repo') ? dir.replace(/\/repo$/, '') : dir;
+            rmSync(parent, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+}

package/dist/index.js

@@ -13,6 +13,7 @@ import { runBuild } from './commands/build/index.js';
 import { runChecklists } from './commands/checklists/index.js';
 import { runCodeReview } from './commands/code-review/index.js';
 import { runConfigGet, runConfigList, runConfigSet, runConfigUnset, } from './commands/config/index.js';
+import { runDataFlow } from './commands/data-flow/index.js';
 import { runFinancingDeck } from './commands/financing-deck/index.js';
 import { runFindArchitecture } from './commands/find-architecture/index.js';
 import { runFindBugs } from './commands/find-bugs/index.js';
@@ -24,15 +25,18 @@ import { runIntelligence } from './commands/intelligence/index.js';
 import { runIssueAnalysisCommand } from './commands/issue-analysis/index.js';
 import { runPRResolve } from './commands/pr-resolve/index.js';
 import { runPRReview } from './commands/pr-review/index.js';
-import { runProductTechniques } from './commands/product-techniques/index.js';
 import { runProductTestCases } from './commands/product-test-cases/index.js';
 import { runQualityBenchmarkCli } from './commands/quality-benchmark/index.js';
+import { runRecipes } from './commands/recipes/index.js';
 import { runRefactor } from './commands/refactor/refactor.js';
 import { runReleaseSyncCommand } from './commands/release-sync/index.js';
 import { runRunSheetCommand } from './commands/run-sheet/index.js';
 import { runScreenFlow } from './commands/screen-flow/index.js';
 import { runSmokeTestCommand } from './commands/smoke-test/index.js';
 import { runSyncGithubIssues } from './commands/sync-github-issues/index.js';
+import { runSyncAws } from './commands/sync-aws/index.js';
+import { runSyncDatadog } from './commands/sync-datadog/index.js';
+import { runSyncTerraform } from './commands/sync-terraform/index.js';
 import { runSyncSentryIssues } from './commands/sync-sentry-issues/index.js';
 import { runTaskWorker } from './commands/task-worker/index.js';
 import { runTechnicalDesignCommand } from './commands/technical-design/index.js';
@@ -166,7 +170,7 @@ program
 program
     .command('screen-flow <productId>')
     .description('Generate a structured screen flow (screens + transitions) for a product from its source code')
-    .requiredOption('--flow-id <id>', 'Pending screen_flows row id to populate')
+    .requiredOption('--flow-id <id>', 'Pending flows row id to populate')
     .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
@@ -183,6 +187,28 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger data-flow <productId>
+// ============================================================
+program
+    .command('data-flow <productId>')
+    .description('Generate a structured data flow (sources, datasets, transforms, sinks, queues, models) for a product from its source code')
+    .requiredOption('--flow-id <id>', 'Pending flows row id to populate')
+    .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        await runDataFlow(productId, {
+            flowId: opts.flowId,
+            guidance: opts.guidance,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
 // Subcommand: edsger user-psychology <productId>
 // ============================================================
 program
@@ -594,6 +620,71 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger sync-datadog <teamId>
+//
+// Requires DD_API_KEY, DD_APP_KEY in env (set via `edsger config set`
+// or desktop Settings → Credentials → Datadog). Optional DD_SITE.
+// ============================================================
+program
+    .command('sync-datadog <teamId>')
+    .description('Import services from Datadog Service Catalog into the edsger service catalog (requires DD_API_KEY, DD_APP_KEY env)')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (teamId, opts) => {
+    try {
+        await runSyncDatadog(teamId, opts);
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
+// ============================================================
+// Subcommand: edsger sync-aws <teamId>
+//
+// Uses the standard AWS credential chain to discover services by
+// their Service tag and optionally pull cost data.
+// ============================================================
+program
+    .command('sync-aws <teamId>')
+    .description('Discover services from AWS by Service tag and pull cost data from Cost Explorer')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--region <region>', 'AWS region (default: AWS_REGION env or us-east-1)')
+    .option('--no-cost', 'Skip Cost Explorer query')
+    .action(async (teamId, opts) => {
+    try {
+        await runSyncAws(teamId, {
+            verbose: opts.verbose,
+            region: opts.region,
+            noCost: opts.cost === false,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// Subcommand: edsger sync-terraform <teamId>
+//
+// Clones the team's terraform repo (from teams.terraform_repo_full_name)
+// and lets the agent analyse .tf files to extract services, resources,
+// and dependencies. Alternatively, --dir for a local directory.
+// ============================================================
+program
+    .command('sync-terraform <teamId>')
+    .description('Scan a Terraform repo to discover services, AWS resources, and infrastructure dependencies')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--dir <path>', 'Local directory to scan instead of cloning from GitHub')
+    .action(async (teamId, opts) => {
+    try {
+        await runSyncTerraform(teamId, opts);
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
 // Subcommand: edsger find-features <productId>
 // ============================================================
 program
@@ -695,18 +786,18 @@ program
     }
 });
 // ============================================================
-// Subcommand: edsger product-techniques <productId>
+// Subcommand: edsger recipes <productId>
 // ============================================================
 program
-    .command('product-techniques <productId>')
-    .description("Generate a catalogue of the techniques a product's repo uses (languages, frameworks, patterns, state idioms, build & deploy, notable bits). Writes the result to the pending product_techniques row identified by --techniques-id.")
-    .requiredOption('--techniques-id <id>', 'Pending product_techniques row id to populate')
+    .command('recipes <productId>')
+    .description("Scan a product's repo for the implementation recipes it uses (which services/tools are chained together to deliver each capability) and persist them via the recipes / product_recipes tables. Writes against the pending recipe_scans row identified by --scan-id.")
+    .requiredOption('--scan-id <id>', 'Pending recipe_scans row id to drive (created by the desktop UI before invocation)')
     .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {
-        await runProductTechniques(productId, {
-            techniquesId: opts.techniquesId,
+        await runRecipes(productId, {
+            scanId: opts.scanId,
             guidance: opts.guidance,
             verbose: opts.verbose,
         });

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

@@ -0,0 +1,25 @@
+/**
+ * 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
+ * `type = 'data'`) via the Supabase SDK.
+ *
+ * Companion to screen-flow: same generation pattern (workspace clone +
+ * Claude Agent SDK + in-process MCP server), same storage tables, different
+ * domain.
+ */
+export interface DataFlowPhaseOptions {
+    productId: string;
+    flowId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export interface DataFlowPhaseResult {
+    status: 'success' | 'error';
+    message: string;
+    nodesCreated?: number;
+    edgesCreated?: number;
+    summary?: string;
+}
+export declare function runDataFlowPhase(options: DataFlowPhaseOptions): Promise<DataFlowPhaseResult>;

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

@@ -0,0 +1,257 @@
+/**
+ * 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
+ * `type = 'data'`) via the Supabase SDK.
+ *
+ * Companion to screen-flow: same generation pattern (workspace clone +
+ * Claude Agent SDK + in-process MCP server), same storage tables, different
+ * domain.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getGitHubConfigByProduct } 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, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
+import { fetchProductBasics } from '../find-shared/mcp.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';
+import { isDataFlowExtraction, } from './types.js';
+const WORKSPACE_KEY = 'data-flow';
+const MAX_TURNS = 150;
+// Auto-layout: simple grid; users can drag afterwards and we persist positions.
+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 supabase = getSupabase();
+    await markFlowRunning(supabase, flowId);
+    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    if (!githubConfig.configured ||
+        !githubConfig.token ||
+        !githubConfig.owner ||
+        !githubConfig.repo) {
+        const msg = githubConfig.message ||
+            'GitHub repository not configured for this product. Connect a repo first.';
+        await markFlowFailed(supabase, flowId, msg);
+        return { status: 'error', message: msg };
+    }
+    let repoPath;
+    let succeeded = false;
+    try {
+        const workspaceRoot = ensureWorkspaceDir();
+        const repoKey = `${WORKSPACE_KEY}-${productId}`;
+        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, githubConfig.owner, githubConfig.repo, githubConfig.token));
+        const product = await fetchProductBasics(productId);
+        const systemPrompt = await createDataFlowSystemPrompt({
+            projectDir: repoPath,
+            hasCodebase: true,
+        });
+        const userPrompt = createDataFlowUserPrompt({
+            productName: product.name,
+            productDescription: product.description,
+            guidance,
+        });
+        logInfo('Running Claude data-flow extraction...');
+        const captureState = createDataFlowCaptureState();
+        const mcpServer = createDataFlowMcpServer(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: repoPath,
+                mcpServers: {
+                    'data-flow': mcpServer,
+                },
+            },
+        })) {
+            const { assistantBuffer, extraction: nextExtraction } = processSdkMessage(message, lastAssistantResponse, captureState, verbose);
+            lastAssistantResponse = assistantBuffer;
+            if (nextExtraction) {
+                extraction = nextExtraction;
+            }
+        }
+        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);
+            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);
+        succeeded = true;
+        logSuccess(`Data flow generated: ${nodesCreated} nodes, ${edgesCreated} connections`);
+        return {
+            status: 'success',
+            message: `Data flow generated (${nodesCreated} nodes, ${edgesCreated} connections)`,
+            nodesCreated,
+            edgesCreated,
+            summary: extraction.summary,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Data flow failed: ${errorMessage}`);
+        await markFlowFailed(supabase, flowId, errorMessage);
+        return { status: 'error', message: errorMessage };
+    }
+    finally {
+        if (succeeded) {
+            cleanupIssueRepo(repoPath);
+        }
+    }
+}
+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) {
+        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 data_flow block instead of calling submit_data_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 };
+}
+function tryFallbackParse(resultMessage, assistantText) {
+    const responseText = resultMessage.subtype === 'success'
+        ? resultMessage.result || assistantText
+        : assistantText;
+    const parsed = tryExtractResult(responseText, 'data_flow');
+    if (!isDataFlowExtraction(parsed)) {
+        return null;
+    }
+    const { error } = validateConsistency(parsed);
+    if (error) {
+        logWarning(`Fallback extraction failed consistency check: ${error}`);
+        return null;
+    }
+    return parsed;
+}
+// ============================================================================
+// Persistence
+// ============================================================================
+async function markFlowRunning(supabase, flowId) {
+    const { error } = await supabase
+        .from('flows')
+        .update({ status: 'running', error: null })
+        .eq('id', flowId);
+    if (error) {
+        logWarning(`Could not mark flow as running: ${error.message}`);
+    }
+}
+async function markFlowFailed(supabase, flowId, errorMessage) {
+    await supabase
+        .from('flows')
+        .update({
+        status: 'failed',
+        error: errorMessage,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', flowId);
+}
+async function markFlowSuccess(supabase, flowId, summary) {
+    await supabase
+        .from('flows')
+        .update({
+        status: 'success',
+        summary,
+        error: null,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', flowId);
+}
+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);
+    if (extraction.nodes.length === 0) {
+        return { nodesCreated: 0, edgesCreated: 0 };
+    }
+    const nodeRows = extraction.nodes.map((n, i) => buildNodeRow(flowId, n, i));
+    const { data: insertedNodes, error: nodesError } = await supabase
+        .from('flow_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(flowId, e, slugToId))
+        .filter((e) => e !== null);
+    if (edgeRows.length > 0) {
+        const { error: edgesError } = await supabase
+            .from('flow_edges')
+            .insert(edgeRows);
+        if (edgesError) {
+            throw new Error(`Failed to insert edges: ${edgesError.message}`);
+        }
+    }
+    return {
+        nodesCreated: nodeRows.length,
+        edgesCreated: edgeRows.length,
+    };
+}
+function buildNodeRow(flowId, node, index) {
+    return {
+        flow_id: flowId,
+        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(flowId, edge, slugToId) {
+    const fromId = slugToId.get(edge.fromSlug);
+    const toId = slugToId.get(edge.toSlug);
+    if (!fromId || !toId) {
+        return null;
+    }
+    return {
+        flow_id: flowId,
+        from_node_id: fromId,
+        to_node_id: toId,
+        label: edge.label ?? null,
+        source_anchor: edge.sourceFile ?? null,
+        kind: edge.kind,
+    };
+}