edsger 0.69.0 → 0.71.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/discover/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI command: `edsger discover <teamId> [runId]`
+ *
+ * Runs GitHub service discovery for a team: scans every repo in the team's
+ * connected GitHub org and upserts an inferred service for each. When invoked
+ * with an existing `runId` (the desktop creates a pending `discovery_runs` row
+ * first), the scan drives that row to running → success/failed; otherwise it
+ * creates its own run row.
+ */
+export interface DiscoverOptions {
+    verbose?: boolean;
+    org?: string;
+}
+export declare function runDiscover(teamId: string, runId: string | undefined, options?: DiscoverOptions): Promise<void>;

package/dist/commands/discover/index.js

@@ -0,0 +1,29 @@
+/**
+ * CLI command: `edsger discover <teamId> [runId]`
+ *
+ * Runs GitHub service discovery for a team: scans every repo in the team's
+ * connected GitHub org and upserts an inferred service for each. When invoked
+ * with an existing `runId` (the desktop creates a pending `discovery_runs` row
+ * first), the scan drives that row to running → success/failed; otherwise it
+ * creates its own run row.
+ */
+import { discoverServices } from '../../phases/discover-services/index.js';
+import { hasSupabaseSession } from '../../supabase/client.js';
+import { logError, logInfo } from '../../utils/logger.js';
+export async function runDiscover(teamId, runId, options = {}) {
+    if (!hasSupabaseSession()) {
+        logError('Supabase session unavailable. Sign in to the Edsger desktop app to authorize the CLI.');
+        process.exit(1);
+    }
+    logInfo(`Starting GitHub service discovery for team ${teamId}`);
+    const result = await discoverServices({
+        teamId,
+        runId,
+        org: options.org,
+        verbose: options.verbose,
+    });
+    if (result.status === 'error') {
+        logError(result.message);
+        process.exit(1);
+    }
+}

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);
+}