edsger 0.68.0 → 0.70.0

package/dist/api/github.d.ts

@@ -50,6 +50,29 @@ export declare function getGitHubConfigByProduct(productId: string, verbose?: bo
     repo?: string;
     message?: string;
 }>;
+export interface RepositoryBasics {
+    teamId: string | null;
+    fullName: string | null;
+    description: string | null;
+}
+/**
+ * Fetch a repository row's team_id, full_name and description (RLS-scoped).
+ * Used by repo-scoped analysis to resolve the team (recipes are team-scoped)
+ * and to build prompt "product basics" from the repo instead of a product.
+ */
+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 / diagrams running
+ * against a single `repositories` row with no product context).
+ */
+export declare function getGitHubConfigByRepository(repositoryId: string, verbose?: boolean): Promise<{
+    configured: boolean;
+    token?: string;
+    owner?: string;
+    repo?: string;
+    message?: string;
+}>;
 /**
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config

package/dist/api/github.js

@@ -2,6 +2,7 @@
  * GitHub API client for accessing GitHub via MCP server
  * Uses product developer configuration from the database
  */
+import { getSupabase } from '../supabase/client.js';
 import { logDebug, logError, logSuccess, logWarning } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
@@ -98,6 +99,66 @@ export async function getGitHubConfigByProduct(productId, verbose) {
         };
     }
 }
+/**
+ * Fetch a repository row's team_id, full_name and description (RLS-scoped).
+ * Used by repo-scoped analysis to resolve the team (recipes are team-scoped)
+ * and to build prompt "product basics" from the repo instead of a product.
+ */
+export async function getRepositoryBasics(repositoryId) {
+    const { data } = await getSupabase()
+        .from('repositories')
+        .select('team_id, full_name, description')
+        .eq('id', repositoryId)
+        .maybeSingle();
+    return {
+        teamId: data?.team_id ?? null,
+        fullName: data?.full_name ?? null,
+        description: data?.description ?? null,
+    };
+}
+/**
+ * Get GitHub config and token by repository ID (no product / issue required).
+ * 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) {
+    logDebug(`Fetching GitHub config for repository: ${repositoryId}`, verbose);
+    try {
+        const result = (await callMcpEndpoint('github/config_and_token_by_repository', {
+            repository_id: repositoryId,
+        }));
+        if (verbose) {
+            if (result.configured) {
+                logSuccess(`GitHub ready: ${result.repository_full_name}`);
+            }
+            else {
+                logWarning(`GitHub not configured: ${result.message}`);
+            }
+        }
+        if (result.configured && result.token && result.owner && result.repo) {
+            return {
+                configured: true,
+                token: result.token,
+                owner: result.owner,
+                repo: result.repo,
+            };
+        }
+        return {
+            configured: false,
+            message: result.message ||
+                'GitHub not configured for this repository. Connect the repo first.',
+        };
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to get GitHub config for repository: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return {
+            configured: false,
+            message: error instanceof Error ? error.message : 'Failed to get GitHub config',
+        };
+    }
+}
 /**
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config

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,17 +1,19 @@
 /**
- * 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;
     verbose?: boolean;
 }
-export declare function runDataFlow(productId: string, options: DataFlowCliOptions): Promise<void>;
+export declare function runDataFlow(productId: string | undefined, options: DataFlowCliOptions): Promise<void>;

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

@@ -1,31 +1,40 @@
 /**
- * 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, guidance, verbose } = options;
-    if (!productId) {
-        throw new Error('Product ID is required for data-flow');
+    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',
+        ...(productId ? { productId } : {}),
+    });
+    if (productId) {
+        logInfo(`Starting data flow generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting data flow generation for repository ${repoId}`);
     }
-    await registerSession({ command: 'data-flow', productId });
-    logInfo(`Starting data flow generation for product ${productId}`);
     try {
         const result = await runDataFlowPhase({
             productId,
-            flowId,
+            repoId,
+            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/quality-benchmark/index.js

@@ -25,7 +25,7 @@
  */
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, getRepositoryBasics, } from '../../api/github.js';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { fetchProductBasics } from '../../phases/find-shared/mcp.js';
 import { runQualityBenchmark, } from '../../phases/quality-benchmark/index.js';
@@ -34,15 +34,46 @@ import { getSupabase } from '../../supabase/client.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
 export async function runQualityBenchmarkCli(productId, options) {
     const installEnabled = options.install !== false;
-    logInfo(`Starting quality benchmark for product ${productId}`);
+    // Repo-only mode: no product context, benchmark a single repositories row.
+    const repoOnly = !productId && Boolean(options.repoId);
+    if (repoOnly) {
+        logInfo(`Starting quality benchmark for repository ${options.repoId}`);
+    }
+    else {
+        logInfo(`Starting quality benchmark for product ${productId}`);
+    }
     let repoRoot;
     let resolvedBranch;
     // Recorded on the report so it's scoped to the repo that was benchmarked.
     let repositoryId = options.repoId ?? null;
+    // Display name used on the prompt + report (repo full_name in repo-only mode).
+    let productName = productId;
     if (options.repo) {
         repoRoot = resolve(options.repo);
         resolvedBranch = options.branch;
         logInfo(`Repo (override): ${repoRoot}`);
+        if (repoOnly) {
+            const basics = await getRepositoryBasics(options.repoId).catch(() => null);
+            productName = basics?.fullName ?? options.repoId;
+        }
+    }
+    else if (repoOnly) {
+        const gh = await getGitHubConfigByRepository(options.repoId, options.verbose);
+        if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
+            logError(`Cannot run quality benchmark: ${gh.message ??
+                'GitHub is not configured for this repository. Connect the repo first.'}`);
+            process.exit(1);
+        }
+        const ws = prepareQualityWorkspace({
+            owner: gh.owner,
+            repo: gh.repo,
+            token: gh.token,
+            verbose: options.verbose,
+        });
+        repoRoot = ws.repoPath;
+        resolvedBranch = options.branch ?? ws.branch;
+        productName = `${gh.owner}/${gh.repo}`;
+        logInfo(`Repo: ${repoRoot} (branch: ${resolvedBranch})`);
     }
     else {
         const gh = await getGitHubConfigByProduct(productId, options.verbose);
@@ -82,10 +113,12 @@ export async function runQualityBenchmarkCli(productId, options) {
     if (!installEnabled) {
         logWarning('Install consent NOT granted (--no-install). Missing tools will be marked unmeasured.');
     }
-    const basics = await fetchProductBasics(productId).catch(() => ({
-        name: productId,
-    }));
-    const productName = basics.name;
+    if (!repoOnly) {
+        const basics = await fetchProductBasics(productId).catch(() => ({
+            name: productId,
+        }));
+        productName = basics.name;
+    }
     const onProgress = (event) => {
         if (options.verbose) {
             logInfo(`[${event.phase}] ${event.message}`);
@@ -100,7 +133,7 @@ export async function runQualityBenchmarkCli(productId, options) {
         }
     };
     const outcome = await runQualityBenchmark({
-        productId,
+        productId: repoOnly ? '' : productId,
         productName,
         repoRoot,
         branch: resolvedBranch,
@@ -121,7 +154,8 @@ export async function runQualityBenchmarkCli(productId, options) {
         resolve(process.cwd(), `quality-report-${outcome.commitSha.slice(0, 8)}.json`);
     const reportEnvelope = {
         run_id: outcome.runId,
-        product_id: productId,
+        product_id: repoOnly ? null : productId,
+        repository_id: repositoryId,
         commit_sha: outcome.commitSha,
         branch: resolvedBranch ?? null,
         started_at: outcome.startedAt,
@@ -136,7 +170,7 @@ export async function runQualityBenchmarkCli(productId, options) {
     if (options.save !== false) {
         try {
             const saved = (await callMcpEndpoint('quality_reports/save', {
-                product_id: productId,
+                product_id: repoOnly ? null : productId,
                 repository_id: repositoryId,
                 commit_sha: outcome.commitSha,
                 rubric_version: outcome.report.rubric_version,

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

@@ -9,7 +9,9 @@
  */
 export interface RecipesCliOptions {
     scanId: string;
+    /** Repo-only mode: scan a single repositories row with no product context. */
+    repoId?: string;
     guidance?: string;
     verbose?: boolean;
 }
-export declare function runRecipes(productId: string, options: RecipesCliOptions): Promise<void>;
+export declare function runRecipes(productId: string | undefined, options: RecipesCliOptions): Promise<void>;

package/dist/commands/recipes/index.js

@@ -10,16 +10,22 @@
 import { runRecipesPhase } from '../../phases/recipes/index.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runRecipes(productId, options) {
-    const { scanId, guidance, verbose } = options;
-    if (!productId) {
-        throw new Error('Product ID is required for recipes');
+    const { scanId, repoId, guidance, verbose } = options;
+    if (!productId && !repoId) {
+        throw new Error('Either a product ID or --repo-id is required for recipes');
     }
     if (!scanId) {
         throw new Error('--scan-id is required (the pending recipe_scans row id)');
     }
-    logInfo(`Starting recipes scan for product ${productId}`);
+    if (productId) {
+        logInfo(`Starting recipes scan for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting recipes scan for repository ${repoId}`);
+    }
     const result = await runRecipesPhase({
         productId,
+        repoId,
         scanId,
         guidance,
         verbose,

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

@@ -1,16 +1,18 @@
 /**
- * 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;
     verbose?: boolean;
 }
-export declare function runScreenFlow(productId: string, options: ScreenFlowCliOptions): Promise<void>;
+export declare function runScreenFlow(productId: string | undefined, options: ScreenFlowCliOptions): Promise<void>;

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

@@ -1,30 +1,39 @@
 /**
- * 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, guidance, verbose } = options;
-    if (!productId) {
-        throw new Error('Product ID is required for screen-flow');
+    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',
+        ...(productId ? { productId } : {}),
+    });
+    if (productId) {
+        logInfo(`Starting screen flow generation for product ${productId}`);
+    }
+    else {
+        logInfo(`Starting screen flow generation for repository ${repoId}`);
     }
-    await registerSession({ command: 'screen-flow', productId });
-    logInfo(`Starting screen flow generation for product ${productId}`);
     try {
         const result = await runScreenFlowPhase({
             productId,
-            flowId,
+            repoId,
+            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>;