edsger 0.69.0 → 0.71.0

package/dist/index.js

@@ -9,17 +9,22 @@ import { runLogin, runLogout, runStatus } from './auth/login.js';
 import { runAgentWorkflow } from './commands/agent-workflow/index.js';
 import { runAnalyzeLogs } from './commands/analyze-logs/index.js';
 import { runAppStoreGeneration } from './commands/app-store/index.js';
+import { runArchitectureDiagram } from './commands/architecture-diagram/index.js';
 import { runBuild } from './commands/build/index.js';
 import { runChatServeCommand } from './commands/chat-serve/index.js';
 import { runChecklists } from './commands/checklists/index.js';
+import { runClassDiagram } from './commands/class-diagram/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 { runDiscover } from './commands/discover/index.js';
+import { runErDiagram } from './commands/er-diagram/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';
 import { runFindFeatures } from './commands/find-features/index.js';
 import { parseCategoriesOption, runFindSmells, } from './commands/find-smells/index.js';
+import { runFlowchart } from './commands/flowchart/index.js';
 import { runGrowthAnalysis } from './commands/growth-analysis/index.js';
 import { runInit } from './commands/init/index.js';
 import { runIntelligence } from './commands/intelligence/index.js';
@@ -33,9 +38,11 @@ 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 { runSequenceDiagram } from './commands/sequence-diagram/index.js';
 import { runSessionServeCommand } from './commands/session-serve/index.js';
 import { runSessionTurnCommand } from './commands/session-turn/index.js';
 import { runSmokeTestCommand } from './commands/smoke-test/index.js';
+import { runStateDiagram } from './commands/state-diagram/index.js';
 import { runSyncAws } from './commands/sync-aws/index.js';
 import { runSyncDatadog } from './commands/sync-datadog/index.js';
 import { runSyncGithubIssues } from './commands/sync-github-issues/index.js';
@@ -174,7 +181,7 @@ program
 program
     .command('screen-flow [productId]')
     .description('Generate a structured screen flow (screens + transitions) for a product (or standalone repository) from its source code')
-    .requiredOption('--flow-id <id>', 'Pending flows row id to populate')
+    .requiredOption('--diagram-id <id>', 'Pending diagrams row id to populate')
     .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
     .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
     .option('-v, --verbose', 'Verbose output')
@@ -184,7 +191,7 @@ program
             throw new Error('Provide a productId or --repo-id (repo-only mode) for screen-flow');
         }
         await runScreenFlow(productId, {
-            flowId: opts.flowId,
+            diagramId: opts.diagramId,
             repoId: opts.repoId,
             guidance: opts.guidance,
             verbose: opts.verbose,
@@ -201,7 +208,7 @@ program
 program
     .command('data-flow [productId]')
     .description('Generate a structured data flow (sources, datasets, transforms, sinks, queues, models) for a product (or standalone repository) from its source code')
-    .requiredOption('--flow-id <id>', 'Pending flows row id to populate')
+    .requiredOption('--diagram-id <id>', 'Pending diagrams row id to populate')
     .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
     .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
     .option('-v, --verbose', 'Verbose output')
@@ -211,7 +218,7 @@ program
             throw new Error('Provide a productId or --repo-id (repo-only mode) for data-flow');
         }
         await runDataFlow(productId, {
-            flowId: opts.flowId,
+            diagramId: opts.diagramId,
             repoId: opts.repoId,
             guidance: opts.guidance,
             verbose: opts.verbose,
@@ -223,6 +230,112 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger er-diagram <productId>
+// ============================================================
+program
+    .command('er-diagram [productId]')
+    .description('Generate a structured entity-relationship diagram (tables, views, enums, junctions + their relationships) for a product (or standalone repository) from its schema source')
+    .requiredOption('--diagram-id <id>', 'Pending diagrams row id to populate')
+    .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
+    .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for er-diagram');
+        }
+        await runErDiagram(productId, {
+            diagramId: opts.diagramId,
+            repoId: opts.repoId,
+            guidance: opts.guidance,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
+// Subcommand: edsger sequence-diagram <productId>
+// ============================================================
+program
+    .command('sequence-diagram [productId]')
+    .description('Generate a structured sequence diagram (participants + ordered messages for one scenario) for a product (or standalone repository) from its source code')
+    .requiredOption('--diagram-id <id>', 'Pending diagrams row id to populate')
+    .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
+    .option('-g, --guidance <text>', 'Human direction for the AI — the scenario to map (e.g. "user checkout")')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for sequence-diagram');
+        }
+        await runSequenceDiagram(productId, {
+            diagramId: opts.diagramId,
+            repoId: opts.repoId,
+            guidance: opts.guidance,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+const diagramSubcommands = [
+    {
+        name: 'state-diagram',
+        description: 'Generate a state diagram (states + transitions for one lifecycle) for a product (or standalone repository) from its source code',
+        guidance: 'Human direction for the AI — the lifecycle to map',
+        run: runStateDiagram,
+    },
+    {
+        name: 'class-diagram',
+        description: 'Generate a UML class diagram (types + relationships) for a product (or standalone repository) from its source code',
+        guidance: 'Human direction for the AI (focus areas, exclusions)',
+        run: runClassDiagram,
+    },
+    {
+        name: 'architecture-diagram',
+        description: 'Generate an architecture/component diagram (components + dependencies) for a product (or standalone repository) from its source code',
+        guidance: 'Human direction for the AI (focus areas, exclusions)',
+        run: runArchitectureDiagram,
+    },
+    {
+        name: 'flowchart',
+        description: 'Generate a flowchart (control flow of one process/function) for a product (or standalone repository) from its source code',
+        guidance: 'Human direction for the AI — the process to map',
+        run: runFlowchart,
+    },
+];
+for (const sub of diagramSubcommands) {
+    program
+        .command(`${sub.name} [productId]`)
+        .description(sub.description)
+        .requiredOption('--diagram-id <id>', 'Pending diagrams row id to populate')
+        .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
+        .option('-g, --guidance <text>', sub.guidance)
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (productId, opts) => {
+        try {
+            if (!productId && !opts.repoId) {
+                throw new Error(`Provide a productId or --repo-id (repo-only mode) for ${sub.name}`);
+            }
+            await sub.run(productId, {
+                diagramId: opts.diagramId,
+                repoId: opts.repoId,
+                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
@@ -659,7 +772,7 @@ program
     .command('quality-benchmark [productId]')
     .description("Run an industrial-grade code quality benchmark against the product's (or a standalone repository's) GitHub repo")
     .option('--repo <path>', "Override the auto-clone with a local checkout (default: clone the product's repo into ~/edsger/quality-<owner>-<repo>)")
-    .option('--repo-id <id>', "Benchmark a specific repository (id). With a productId, targets that linked repo; without a productId, runs in repo-only mode (no product)")
+    .option('--repo-id <id>', 'Benchmark a specific repository (id). With a productId, targets that linked repo; without a productId, runs in repo-only mode (no product)')
     .option('--branch <name>', 'Override the detected default branch on the report envelope')
     .option('--pkg-manager <name>', 'npm | pnpm | yarn (auto-detected if absent)')
     .option('--no-install', 'Refuse to install missing tools; mark them unmeasured')
@@ -776,6 +889,27 @@ program
         process.exit(1);
     }
 });
+// ============================================================
+// Subcommand: edsger discover <teamId> [runId]
+//
+// Scans every repo in the team's connected GitHub org and upserts an
+// inferred service for each into the service catalog. Drives an existing
+// discovery_runs row (created by the desktop) to running → success/failed.
+// ============================================================
+program
+    .command('discover <teamId> [runId]')
+    .description('Discover services by scanning every repo in the team’s connected GitHub organisation')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--org <name>', 'Override the GitHub organisation to scan')
+    .action(async (teamId, runId, opts) => {
+    try {
+        await runDiscover(teamId, runId, opts);
+    }
+    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)

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

@@ -0,0 +1,15 @@
+/**
+ * architecture-diagram phase: map a component/dependency diagram (C4-ish) —
+ * the modules / services / packages / datastores / external systems that make
+ * up the product and how they depend on one another. Persisted to the
+ * diagrams tables with `type = 'architecture'`.
+ */
+import { type DiagramPhaseResult } from '../diagram-shared/generate.js';
+export interface ArchitectureDiagramPhaseOptions {
+    productId?: string;
+    repoId?: string;
+    diagramId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runArchitectureDiagramPhase(options: ArchitectureDiagramPhaseOptions): Promise<DiagramPhaseResult>;

package/dist/phases/architecture-diagram/index.js

@@ -0,0 +1,51 @@
+/**
+ * architecture-diagram phase: map a component/dependency diagram (C4-ish) —
+ * the modules / services / packages / datastores / external systems that make
+ * up the product and how they depend on one another. Persisted to the
+ * diagrams tables with `type = 'architecture'`.
+ */
+import { z } from 'zod';
+import { generateDiagram, } from '../diagram-shared/generate.js';
+import { buildDiagramSystemPrompt, buildDiagramUserPrompt, } from '../diagram-shared/prompts.js';
+const archNode = z.object({
+    slug: z.string().min(1),
+    name: z.string().min(1),
+    kind: z.enum(['module', 'service', 'package', 'ui', 'datastore', 'external']),
+    file: z.string().optional(),
+    description: z.string().optional(),
+    tech: z.string().optional(),
+    responsibilities: z.array(z.string()).optional(),
+});
+const archEdge = z.object({
+    fromSlug: z.string().min(1),
+    toSlug: z.string().min(1),
+    kind: z.enum(['depends-on', 'calls', 'imports', 'data']),
+    label: z.string().optional(),
+    sourceFile: z.string().optional(),
+});
+export function runArchitectureDiagramPhase(options) {
+    return generateDiagram({
+        ...options,
+        workspaceKey: 'architecture-diagram',
+        fenceName: 'architecture_diagram',
+        nounPlural: 'components',
+        edgeNounPlural: 'dependencies',
+        mcpConfig: {
+            name: 'architecture-diagram',
+            toolName: 'architecture_diagram',
+            summaryDescribe: '1-3 sentence narrative of the system architecture and its main building blocks.',
+            nodesSchema: z.array(archNode),
+            nodesDescribe: 'Every component: module / service / package / ui / datastore / external. slug MUST be unique.',
+            edgesSchema: z.array(archEdge),
+            edgesDescribe: 'Dependencies. kind = depends-on / calls / imports / data. fromSlug is the depender. Endpoints MUST reference emitted components.',
+        },
+        buildSystemPrompt: (a) => buildDiagramSystemPrompt('phase/architecture-diagram', 'architecture-diagram', a),
+        buildUserPrompt: (a) => buildDiagramUserPrompt({
+            ...a,
+            task: 'Map the architecture (component & dependency) diagram for',
+            mcpName: 'architecture-diagram',
+            toolName: 'architecture_diagram',
+            process: 'Detect the stack and the top-level structure (workspaces/packages, service boundaries, top-level src dirs, deployment units). Treat each meaningful unit as a component of the right kind (a UI/front-end, backend services, internal modules/packages, datastores, third-party/external systems). Wire dependency edges from the import graph, cross-service calls, and datastore/external access. Aim for a readable ~10-25 components — group leaf files into their module; do not draw a file-level graph.',
+        }),
+    });
+}

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

@@ -0,0 +1,14 @@
+/**
+ * class-diagram phase: map a UML class diagram — classes / interfaces / enums
+ * with their members, and the inheritance / composition / association edges
+ * between them. Persisted to the diagrams tables with `type = 'class'`.
+ */
+import { type DiagramPhaseResult } from '../diagram-shared/generate.js';
+export interface ClassDiagramPhaseOptions {
+    productId?: string;
+    repoId?: string;
+    diagramId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runClassDiagramPhase(options: ClassDiagramPhaseOptions): Promise<DiagramPhaseResult>;

package/dist/phases/class-diagram/index.js

@@ -0,0 +1,76 @@
+/**
+ * class-diagram phase: map a UML class diagram — classes / interfaces / enums
+ * with their members, and the inheritance / composition / association edges
+ * between them. Persisted to the diagrams tables with `type = 'class'`.
+ */
+import { z } from 'zod';
+import { generateDiagram, } from '../diagram-shared/generate.js';
+import { buildDiagramSystemPrompt, buildDiagramUserPrompt, } from '../diagram-shared/prompts.js';
+const visibility = z.enum(['public', 'private', 'protected']);
+const classNode = z.object({
+    slug: z.string().min(1),
+    name: z.string().min(1),
+    kind: z.enum(['class', 'interface', 'abstract', 'enum']),
+    file: z.string().optional(),
+    description: z.string().optional(),
+    stereotype: z.string().optional(),
+    attributes: z
+        .array(z.object({
+        name: z.string(),
+        type: z.string().optional(),
+        visibility: visibility.optional(),
+        isStatic: z.boolean().optional(),
+    }))
+        .optional(),
+    methods: z
+        .array(z.object({
+        name: z.string(),
+        params: z.string().optional(),
+        returnType: z.string().optional(),
+        visibility: visibility.optional(),
+        isStatic: z.boolean().optional(),
+        isAbstract: z.boolean().optional(),
+    }))
+        .optional(),
+});
+const classEdge = z.object({
+    fromSlug: z.string().min(1),
+    toSlug: z.string().min(1),
+    kind: z.enum([
+        'inheritance',
+        'implementation',
+        'composition',
+        'aggregation',
+        'association',
+        'dependency',
+    ]),
+    /** Role name or multiplicity, e.g. "1..*", "owns". */
+    label: z.string().optional(),
+    sourceFile: z.string().optional(),
+});
+export function runClassDiagramPhase(options) {
+    return generateDiagram({
+        ...options,
+        workspaceKey: 'class-diagram',
+        fenceName: 'class_diagram',
+        nounPlural: 'classes',
+        edgeNounPlural: 'relationships',
+        mcpConfig: {
+            name: 'class-diagram',
+            toolName: 'class_diagram',
+            summaryDescribe: '1-3 sentence narrative of the core types and how they relate.',
+            nodesSchema: z.array(classNode),
+            nodesDescribe: 'Every class / interface / abstract / enum with its key attributes and methods. slug MUST be unique.',
+            edgesSchema: z.array(classEdge),
+            edgesDescribe: 'Relationships. kind = inheritance / implementation / composition / aggregation / association / dependency. fromSlug is the child / owner / dependent side. Endpoints MUST reference emitted classes.',
+        },
+        buildSystemPrompt: (a) => buildDiagramSystemPrompt('phase/class-diagram', 'class-diagram', a),
+        buildUserPrompt: (a) => buildDiagramUserPrompt({
+            ...a,
+            task: 'Map a UML class diagram for',
+            mcpName: 'class-diagram',
+            toolName: 'class_diagram',
+            process: 'Detect the language/OO model, then map the core domain types — classes, interfaces, abstract base types, enums — capturing each one\'s defining attributes and methods (visibility + static/abstract where it matters; you need not list every member of huge types). Wire edges: `inheritance` (extends), `implementation` (implements), `composition`/`aggregation` (owns/holds), `association` (references), `dependency` (uses). Prefer the ~30 most important types if there are many.',
+        }),
+    });
+}

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

@@ -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 +
@@ -14,7 +14,7 @@ export interface DataFlowPhaseOptions {
     productId?: string;
     /** Repo-only flow: a single repositories row, no product context. */
     repoId?: string;
-    flowId: string;
+    diagramId: string;
     guidance?: string;
     verbose?: boolean;
 }

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 +
@@ -13,10 +13,10 @@ 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 { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
 import { cleanupIssueRepo } from '../../workspace/workspace-manager.js';
+import { cloneDiagramRepos, describeRepoScope, } from '../diagram-shared/clone-repos.js';
 import { fetchProductBasics } from '../find-shared/mcp.js';
-import { cloneFlowRepos, describeRepoScope } from '../flow-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';
@@ -28,7 +28,7 @@ const COLUMN_WIDTH = 320;
 const ROW_HEIGHT = 220;
 const COLUMNS = 4;
 export async function runDataFlowPhase(options) {
-    const { productId, repoId, flowId, guidance, verbose } = options;
+    const { productId, repoId, diagramId, guidance, verbose } = options;
     const repoOnly = !productId && Boolean(repoId);
     if (productId) {
         logInfo(`Starting data-flow generation for product ${productId}`);
@@ -37,9 +37,9 @@ export async function runDataFlowPhase(options) {
         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,
@@ -47,7 +47,7 @@ export async function runDataFlowPhase(options) {
         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;
@@ -100,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 {
@@ -119,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 {
@@ -139,12 +139,12 @@ async function resolveRepoBasics(repositoryId, repos) {
         description: basics?.description ?? undefined,
     };
 }
-/** Read the ordered repo set a flow was scoped to (may be empty). */
-async function getFlowRepositoryIds(supabase, flowId) {
+/** 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);
 }
@@ -197,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) {
@@ -243,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}`);
@@ -258,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,
@@ -269,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.
  */
 // ============================================================================