edsger 0.69.0 → 0.70.0

package/dist/api/github.d.ts

@@ -63,7 +63,7 @@ export interface RepositoryBasics {
 export declare function getRepositoryBasics(repositoryId: string): Promise<RepositoryBasics>;
 /**
  * Get GitHub config and token by repository ID (no product / issue required).
- * Used for repo-scoped analysis (quality-benchmark / recipes / flows running
+ * Used for repo-scoped analysis (quality-benchmark / recipes / diagrams running
  * against a single `repositories` row with no product context).
  */
 export declare function getGitHubConfigByRepository(repositoryId: string, verbose?: boolean): Promise<{

package/dist/api/github.js

@@ -118,7 +118,7 @@ export async function getRepositoryBasics(repositoryId) {
 }
 /**
  * Get GitHub config and token by repository ID (no product / issue required).
- * Used for repo-scoped analysis (quality-benchmark / recipes / flows running
+ * Used for repo-scoped analysis (quality-benchmark / recipes / diagrams running
  * against a single `repositories` row with no product context).
  */
 export async function getGitHubConfigByRepository(repositoryId, verbose) {

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

@@ -0,0 +1,8 @@
+/**
+ * CLI command: edsger architecture-diagram <productId> --diagram-id <id>
+ * Maps a component/dependency diagram into the diagrams tables
+ * (type='architecture').
+ */
+import { type DiagramCommandOptions } from '../diagram-shared/index.js';
+export type ArchitectureDiagramCliOptions = DiagramCommandOptions;
+export declare function runArchitectureDiagram(productId: string | undefined, options: ArchitectureDiagramCliOptions): Promise<void>;

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

@@ -0,0 +1,10 @@
+/**
+ * CLI command: edsger architecture-diagram <productId> --diagram-id <id>
+ * Maps a component/dependency diagram into the diagrams tables
+ * (type='architecture').
+ */
+import { runArchitectureDiagramPhase } from '../../phases/architecture-diagram/index.js';
+import { runDiagramCommand, } from '../diagram-shared/index.js';
+export function runArchitectureDiagram(productId, options) {
+    return runDiagramCommand('architecture-diagram', productId, options, runArchitectureDiagramPhase);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * CLI command: edsger class-diagram <productId> --diagram-id <id>
+ * Maps a UML class diagram into the diagrams tables (type='class').
+ */
+import { type DiagramCommandOptions } from '../diagram-shared/index.js';
+export type ClassDiagramCliOptions = DiagramCommandOptions;
+export declare function runClassDiagram(productId: string | undefined, options: ClassDiagramCliOptions): Promise<void>;

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

@@ -0,0 +1,9 @@
+/**
+ * CLI command: edsger class-diagram <productId> --diagram-id <id>
+ * Maps a UML class diagram into the diagrams tables (type='class').
+ */
+import { runClassDiagramPhase } from '../../phases/class-diagram/index.js';
+import { runDiagramCommand, } from '../diagram-shared/index.js';
+export function runClassDiagram(productId, options) {
+    return runDiagramCommand('class-diagram', productId, options, runClassDiagramPhase);
+}

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

@@ -1,16 +1,16 @@
 /**
- * CLI command: edsger data-flow <productId> --flow-id <id>
+ * CLI command: edsger data-flow <productId> --diagram-id <id>
  *
  * Maps the product's data nodes (source/dataset/transform/sink/queue/model)
  * and the connections between them into a structured flow stored in
- * flows / flow_nodes / flow_edges (rows tagged type='data').
+ * diagrams / diagram_nodes / diagram_edges (rows tagged type='data').
  *
- * The desktop UI creates a pending flows row first, then invokes the CLI
- * with --flow-id; the CLI flips status running → success/failed and
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
  * populates the nodes/edges tables.
  */
 export interface DataFlowCliOptions {
-    flowId: string;
+    diagramId: string;
     /** Repo-only mode: generate against a single repositories row, no product. */
     repoId?: string;
     guidance?: string;

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

@@ -1,24 +1,24 @@
 /**
- * CLI command: edsger data-flow <productId> --flow-id <id>
+ * CLI command: edsger data-flow <productId> --diagram-id <id>
  *
  * Maps the product's data nodes (source/dataset/transform/sink/queue/model)
  * and the connections between them into a structured flow stored in
- * flows / flow_nodes / flow_edges (rows tagged type='data').
+ * diagrams / diagram_nodes / diagram_edges (rows tagged type='data').
  *
- * The desktop UI creates a pending flows row first, then invokes the CLI
- * with --flow-id; the CLI flips status running → success/failed and
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
  * populates the nodes/edges tables.
  */
 import { runDataFlowPhase } from '../../phases/data-flow/index.js';
 import { deregisterSession, registerSession, } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runDataFlow(productId, options) {
-    const { flowId, repoId, guidance, verbose } = options;
+    const { diagramId, repoId, guidance, verbose } = options;
     if (!productId && !repoId) {
         throw new Error('Either a product ID or --repo-id is required for data-flow');
     }
-    if (!flowId) {
-        throw new Error('--flow-id is required (the pending flows row id)');
+    if (!diagramId) {
+        throw new Error('--diagram-id is required (the pending diagrams row id)');
     }
     await registerSession({
         command: 'data-flow',
@@ -34,7 +34,7 @@ export async function runDataFlow(productId, options) {
         const result = await runDataFlowPhase({
             productId,
             repoId,
-            flowId,
+            diagramId,
             guidance,
             verbose,
         });

package/dist/commands/diagram-shared/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared CLI command runner for graph diagram phases (state / class /
+ * architecture / flowchart). Handles session registration and the
+ * success/failure → exit-code mapping; each command just passes its phase
+ * runner.
+ */
+import type { DiagramPhaseResult } from '../../phases/diagram-shared/generate.js';
+export interface DiagramCommandOptions {
+    diagramId: string;
+    /** Repo-only mode: generate against a single repositories row, no product. */
+    repoId?: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runDiagramCommand(command: string, productId: string | undefined, options: DiagramCommandOptions, run: (args: {
+    productId?: string;
+    repoId?: string;
+    diagramId: string;
+    guidance?: string;
+    verbose?: boolean;
+}) => Promise<DiagramPhaseResult>): Promise<void>;

package/dist/commands/diagram-shared/index.js

@@ -0,0 +1,37 @@
+/**
+ * Shared CLI command runner for graph diagram phases (state / class /
+ * architecture / flowchart). Handles session registration and the
+ * success/failure → exit-code mapping; each command just passes its phase
+ * runner.
+ */
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runDiagramCommand(command, productId, options, run) {
+    const { diagramId, repoId, guidance, verbose } = options;
+    if (!productId && !repoId) {
+        throw new Error(`Either a product ID or --repo-id is required for ${command}`);
+    }
+    if (!diagramId) {
+        throw new Error('--diagram-id is required (the pending diagrams row id)');
+    }
+    await registerSession({ command, ...(productId ? { productId } : {}) });
+    logInfo(productId
+        ? `Starting ${command} for product ${productId}`
+        : `Starting ${command} for repository ${repoId}`);
+    try {
+        const result = await run({ productId, repoId, diagramId, guidance, verbose });
+        if (result.status === 'success') {
+            logSuccess(result.message);
+            if (result.summary) {
+                logInfo(`\nSummary: ${result.summary}`);
+            }
+        }
+        else {
+            logError(result.message);
+            process.exit(1);
+        }
+    }
+    finally {
+        await deregisterSession();
+    }
+}

package/dist/commands/er-diagram/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * CLI command: edsger er-diagram <productId> --diagram-id <id>
+ *
+ * Maps the product's persistence entities (tables / views / enums / junction
+ * tables) and the relationships between them into a structured flow stored in
+ * diagrams / diagram_nodes / diagram_edges (rows tagged type='er').
+ *
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
+ */
+export interface ErDiagramCliOptions {
+    diagramId: string;
+    /** Repo-only mode: generate against a single repositories row, no product. */
+    repoId?: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runErDiagram(productId: string | undefined, options: ErDiagramCliOptions): Promise<void>;

package/dist/commands/er-diagram/index.js

@@ -0,0 +1,55 @@
+/**
+ * CLI command: edsger er-diagram <productId> --diagram-id <id>
+ *
+ * Maps the product's persistence entities (tables / views / enums / junction
+ * tables) and the relationships between them into a structured flow stored in
+ * diagrams / diagram_nodes / diagram_edges (rows tagged type='er').
+ *
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
+ */
+import { runErDiagramPhase } from '../../phases/er-diagram/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runErDiagram(productId, options) {
+    const { diagramId, repoId, guidance, verbose } = options;
+    if (!productId && !repoId) {
+        throw new Error('Either a product ID or --repo-id is required for er-diagram');
+    }
+    if (!diagramId) {
+        throw new Error('--diagram-id is required (the pending diagrams row id)');
+    }
+    await registerSession({
+        command: 'er-diagram',
+        ...(productId ? { productId } : {}),
+    });
+    if (productId) {
+        logInfo(`Starting ER diagram generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting ER diagram generation for repository ${repoId}`);
+    }
+    try {
+        const result = await runErDiagramPhase({
+            productId,
+            repoId,
+            diagramId,
+            guidance,
+            verbose,
+        });
+        if (result.status === 'success') {
+            logSuccess(result.message);
+            if (result.summary) {
+                logInfo(`\nSummary: ${result.summary}`);
+            }
+        }
+        else {
+            logError(result.message);
+            process.exit(1);
+        }
+    }
+    finally {
+        await deregisterSession();
+    }
+}

package/dist/commands/flowchart/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI command: edsger flowchart <productId> --diagram-id <id>
+ * Maps a process/control-flow flowchart into the diagrams tables
+ * (type='flowchart').
+ */
+import { type DiagramCommandOptions } from '../diagram-shared/index.js';
+export type FlowchartCliOptions = DiagramCommandOptions;
+export declare function runFlowchart(productId: string | undefined, options: FlowchartCliOptions): Promise<void>;

package/dist/commands/flowchart/index.js

@@ -0,0 +1,10 @@
+/**
+ * CLI command: edsger flowchart <productId> --diagram-id <id>
+ * Maps a process/control-flow flowchart into the diagrams tables
+ * (type='flowchart').
+ */
+import { runFlowchartPhase } from '../../phases/flowchart/index.js';
+import { runDiagramCommand, } from '../diagram-shared/index.js';
+export function runFlowchart(productId, options) {
+    return runDiagramCommand('flowchart', productId, options, runFlowchartPhase);
+}

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

@@ -1,15 +1,15 @@
 /**
- * CLI command: edsger screen-flow <productId> --flow-id <id>
+ * CLI command: edsger screen-flow <productId> --diagram-id <id>
  *
  * Maps the product's user-facing screens and transitions into a structured
- * flow stored in flows / flow_nodes / flow_edges (rows tagged type='screen').
+ * flow stored in diagrams / diagram_nodes / diagram_edges (rows tagged type='screen').
  *
- * The desktop UI creates a pending flows row first, then invokes the CLI
- * with --flow-id; the CLI flips status running → success/failed and
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
  * populates the nodes/edges tables.
  */
 export interface ScreenFlowCliOptions {
-    flowId: string;
+    diagramId: string;
     /** Repo-only mode: generate against a single repositories row, no product. */
     repoId?: string;
     guidance?: string;

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

@@ -1,23 +1,23 @@
 /**
- * CLI command: edsger screen-flow <productId> --flow-id <id>
+ * CLI command: edsger screen-flow <productId> --diagram-id <id>
  *
  * Maps the product's user-facing screens and transitions into a structured
- * flow stored in flows / flow_nodes / flow_edges (rows tagged type='screen').
+ * flow stored in diagrams / diagram_nodes / diagram_edges (rows tagged type='screen').
  *
- * The desktop UI creates a pending flows row first, then invokes the CLI
- * with --flow-id; the CLI flips status running → success/failed and
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
  * populates the nodes/edges tables.
  */
 import { runScreenFlowPhase } from '../../phases/screen-flow/index.js';
 import { deregisterSession, registerSession, } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runScreenFlow(productId, options) {
-    const { flowId, repoId, guidance, verbose } = options;
+    const { diagramId, repoId, guidance, verbose } = options;
     if (!productId && !repoId) {
         throw new Error('Either a product ID or --repo-id is required for screen-flow');
     }
-    if (!flowId) {
-        throw new Error('--flow-id is required (the pending flows row id)');
+    if (!diagramId) {
+        throw new Error('--diagram-id is required (the pending diagrams row id)');
     }
     await registerSession({
         command: 'screen-flow',
@@ -33,7 +33,7 @@ export async function runScreenFlow(productId, options) {
         const result = await runScreenFlowPhase({
             productId,
             repoId,
-            flowId,
+            diagramId,
             guidance,
             verbose,
         });

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

@@ -0,0 +1,19 @@
+/**
+ * CLI command: edsger sequence-diagram <productId> --diagram-id <id>
+ *
+ * Traces one scenario through the product's code and maps the participants
+ * and the ordered messages between them into a structured flow stored in
+ * diagrams / diagram_nodes / diagram_edges (rows tagged type='sequence').
+ *
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
+ */
+export interface SequenceDiagramCliOptions {
+    diagramId: string;
+    /** Repo-only mode: generate against a single repositories row, no product. */
+    repoId?: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runSequenceDiagram(productId: string | undefined, options: SequenceDiagramCliOptions): Promise<void>;

package/dist/commands/sequence-diagram/index.js

@@ -0,0 +1,55 @@
+/**
+ * CLI command: edsger sequence-diagram <productId> --diagram-id <id>
+ *
+ * Traces one scenario through the product's code and maps the participants
+ * and the ordered messages between them into a structured flow stored in
+ * diagrams / diagram_nodes / diagram_edges (rows tagged type='sequence').
+ *
+ * The desktop UI creates a pending diagrams row first, then invokes the CLI
+ * with --diagram-id; the CLI flips status running → success/failed and
+ * populates the nodes/edges tables.
+ */
+import { runSequenceDiagramPhase } from '../../phases/sequence-diagram/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runSequenceDiagram(productId, options) {
+    const { diagramId, repoId, guidance, verbose } = options;
+    if (!productId && !repoId) {
+        throw new Error('Either a product ID or --repo-id is required for sequence-diagram');
+    }
+    if (!diagramId) {
+        throw new Error('--diagram-id is required (the pending diagrams row id)');
+    }
+    await registerSession({
+        command: 'sequence-diagram',
+        ...(productId ? { productId } : {}),
+    });
+    if (productId) {
+        logInfo(`Starting sequence diagram generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting sequence diagram generation for repository ${repoId}`);
+    }
+    try {
+        const result = await runSequenceDiagramPhase({
+            productId,
+            repoId,
+            diagramId,
+            guidance,
+            verbose,
+        });
+        if (result.status === 'success') {
+            logSuccess(result.message);
+            if (result.summary) {
+                logInfo(`\nSummary: ${result.summary}`);
+            }
+        }
+        else {
+            logError(result.message);
+            process.exit(1);
+        }
+    }
+    finally {
+        await deregisterSession();
+    }
+}

package/dist/commands/state-diagram/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI command: edsger state-diagram <productId> --diagram-id <id>
+ * Maps a state machine into the diagrams tables (type='state').
+ */
+import { type DiagramCommandOptions } from '../diagram-shared/index.js';
+export type StateDiagramCliOptions = DiagramCommandOptions;
+export declare function runStateDiagram(productId: string | undefined, options: StateDiagramCliOptions): Promise<void>;

package/dist/commands/state-diagram/index.js

@@ -0,0 +1,9 @@
+/**
+ * CLI command: edsger state-diagram <productId> --diagram-id <id>
+ * Maps a state machine into the diagrams tables (type='state').
+ */
+import { runStateDiagramPhase } from '../../phases/state-diagram/index.js';
+import { runDiagramCommand, } from '../diagram-shared/index.js';
+export function runStateDiagram(productId, options) {
+    return runDiagramCommand('state-diagram', productId, options, runStateDiagramPhase);
+}

package/dist/index.js

@@ -9,17 +9,21 @@ 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 { 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 +37,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 +180,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 +190,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 +207,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 +217,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 +229,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 +771,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')

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