edsger 0.77.0 → 0.79.0

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

@@ -1,38 +0,0 @@
-import { runReleaseSync, } from '../../phases/release-sync/index.js';
-import { deregisterSession, registerSession, } from '../../system/session-manager.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
-export const runReleaseSyncCommand = async (options) => {
-    const { productId } = options;
-    if (!productId) {
-        throw new Error('Product ID is required for release-sync');
-    }
-    const config = validateConfiguration({
-        verbose: options.verbose,
-    });
-    await registerSession({ command: 'release-sync', productId });
-    logInfo(`Starting release sync for product: ${productId}`);
-    try {
-        const result = await runReleaseSync({
-            productId,
-            verbose: options.verbose,
-        }, config);
-        if (result.status === 'success') {
-            logInfo(result.summary);
-            for (const r of result.syncedReleases ?? []) {
-                logInfo(`  - ${r.tag}${r.isSnapshot ? ' (snapshot)' : ''}`);
-            }
-        }
-        else {
-            logError(`Release sync failed: ${result.summary}`);
-            process.exitCode = 1;
-        }
-    }
-    catch (error) {
-        logError(`Release sync failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exitCode = 1;
-    }
-    finally {
-        await deregisterSession();
-    }
-};

package/dist/commands/run-sheet/index.d.ts

@@ -1,6 +0,0 @@
-export interface RunSheetCliOptions {
-    releaseId: string;
-    force?: boolean;
-    verbose?: boolean;
-}
-export declare const runRunSheetCommand: (options: RunSheetCliOptions) => Promise<void>;

package/dist/commands/run-sheet/index.js

@@ -1,48 +0,0 @@
-import { runRunSheet, } from '../../phases/run-sheet/index.js';
-import { deregisterSession, registerSession, } from '../../system/session-manager.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
-export const runRunSheetCommand = async (options) => {
-    const { releaseId } = options;
-    if (!releaseId) {
-        throw new Error('Release ID is required for run-sheet');
-    }
-    validateConfiguration({ verbose: options.verbose });
-    await registerSession({ command: 'run-sheet' });
-    logInfo(`Starting run sheet generation for release: ${releaseId}`);
-    try {
-        const result = await runRunSheet({
-            releaseId,
-            force: options.force,
-            verbose: options.verbose,
-        });
-        if (result.status === 'error') {
-            logError(`Run sheet generation failed: ${result.summary}`);
-            process.exitCode = 1;
-            return;
-        }
-        if (result.status === 'cached') {
-            logInfo(`Run sheet unchanged for ${result.releaseTag} — skipped clone.`);
-        }
-        else if (result.isDraft) {
-            logInfo(`Generated DRAFT run sheet for ${result.releaseTag} (tag not yet cut; used default branch).`);
-        }
-        else {
-            logInfo(`Generated run sheet for ${result.releaseTag}`);
-        }
-        if (result.cloneError) {
-            logInfo(`Clone warning: ${result.cloneError}`);
-        }
-        if (typeof result.agentTurns === 'number') {
-            logInfo(`Agent used ${result.agentTurns} turn(s)${result.model ? ` on model ${result.model}` : ''}.`);
-        }
-        logInfo('View it in the Release detail page of your product dashboard.');
-    }
-    catch (error) {
-        logError(`Run sheet generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exitCode = 1;
-    }
-    finally {
-        await deregisterSession();
-    }
-};

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

@@ -1,18 +0,0 @@
-/**
- * CLI command: edsger screen-flow <productId> --diagram-id <id>
- *
- * Maps the product's user-facing screens and transitions into a structured
- * flow stored in diagrams / diagram_nodes / diagram_edges (rows tagged type='screen').
- *
- * 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 {
-    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 | undefined, options: ScreenFlowCliOptions): Promise<void>;

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

@@ -1,54 +0,0 @@
-/**
- * CLI command: edsger screen-flow <productId> --diagram-id <id>
- *
- * Maps the product's user-facing screens and transitions into a structured
- * flow stored in diagrams / diagram_nodes / diagram_edges (rows tagged type='screen').
- *
- * 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 { diagramId, repoId, guidance, verbose } = options;
-    if (!productId && !repoId) {
-        throw new Error('Either a product ID or --repo-id is required for screen-flow');
-    }
-    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}`);
-    }
-    try {
-        const result = await runScreenFlowPhase({
-            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/sequence-diagram/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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/session-serve/index.d.ts

@@ -1,32 +0,0 @@
-/**
- * `edsger session-serve <channelId>` — long-lived conversational agent for one
- * chat session.
- *
- * Where `session-turn` runs a single turn and exits, `session-serve` prepares
- * the session context once (repo clone, MCP toolbelt, system prompt) and then
- * stays alive, running one turn per command it reads from stdin. The SDK
- * session id is kept in memory and carried into the next turn automatically, so
- * the conversation (and prompt cache) stays warm without a per-turn cold start.
- *
- * Protocol — one JSON object per line on stdin:
- *   {"type":"turn"}                                  process pending messages
- *   {"type":"run-finished","runId":"…","command":"…"} report a finished cli_* run
- *   {"type":"shutdown"}                               drain + exit cleanly
- *
- * Turns run strictly one at a time (a session never has two turns in flight).
- * When stdin closes, the process exits after the current turn drains. Markers
- * (session id, background cli runs) are written to stdout exactly as the
- * one-shot command emits them, so the desktop's existing parsing is unchanged.
- */
-import { type SessionTurnCliOptions } from '../session-turn/index.js';
-/**
- * Emitted once the session context is built and the process is ready to accept
- * turn commands on stdin. The desktop may use it to know the daemon is live;
- * it is harmless to ignore.
- */
-export declare const SESSION_READY_MARKER = "__EDSGER_SESSION_READY__";
-export type SessionServeCliOptions = Omit<SessionTurnCliOptions, 'runFinished'> & {
-    /** SDK session id to resume on the first turn (e.g. after a crash-restart). */
-    resumeSessionId?: string;
-};
-export declare function runSessionServeCommand(options: SessionServeCliOptions): Promise<void>;

package/dist/commands/session-serve/index.js

@@ -1,100 +0,0 @@
-/**
- * `edsger session-serve <channelId>` — long-lived conversational agent for one
- * chat session.
- *
- * Where `session-turn` runs a single turn and exits, `session-serve` prepares
- * the session context once (repo clone, MCP toolbelt, system prompt) and then
- * stays alive, running one turn per command it reads from stdin. The SDK
- * session id is kept in memory and carried into the next turn automatically, so
- * the conversation (and prompt cache) stays warm without a per-turn cold start.
- *
- * Protocol — one JSON object per line on stdin:
- *   {"type":"turn"}                                  process pending messages
- *   {"type":"run-finished","runId":"…","command":"…"} report a finished cli_* run
- *   {"type":"shutdown"}                               drain + exit cleanly
- *
- * Turns run strictly one at a time (a session never has two turns in flight).
- * When stdin closes, the process exits after the current turn drains. Markers
- * (session id, background cli runs) are written to stdout exactly as the
- * one-shot command emits them, so the desktop's existing parsing is unchanged.
- */
-import { createInterface } from 'node:readline';
-import { logError, logInfo } from '../../utils/logger.js';
-import { prepareSessionContext, runTurn, } from '../session-turn/index.js';
-/**
- * Emitted once the session context is built and the process is ready to accept
- * turn commands on stdin. The desktop may use it to know the daemon is live;
- * it is harmless to ignore.
- */
-export const SESSION_READY_MARKER = '__EDSGER_SESSION_READY__';
-export async function runSessionServeCommand(options) {
-    const ctx = await prepareSessionContext(options);
-    process.stdout.write(`\n${SESSION_READY_MARKER}\n`);
-    logInfo(`Session ${ctx.channelId} ready — awaiting turns on stdin.`);
-    // Commands queue up here; we drain them one at a time so a session never has
-    // two turns running concurrently. `shuttingDown` stops accepting new work.
-    const queue = [];
-    let running = false;
-    let shuttingDown = false;
-    let stdinEnded = false;
-    const maybeExit = () => {
-        if ((shuttingDown || stdinEnded) && !running && queue.length === 0) {
-            logInfo(`Session ${ctx.channelId} shutting down.`);
-            process.exit(0);
-        }
-    };
-    const drain = async () => {
-        if (running) {
-            return;
-        }
-        running = true;
-        try {
-            while (queue.length > 0) {
-                const cmd = queue.shift();
-                if (cmd.type === 'shutdown') {
-                    shuttingDown = true;
-                    continue;
-                }
-                try {
-                    if (cmd.type === 'run-finished' && cmd.runId) {
-                        await runTurn(ctx, {
-                            runFinished: { runId: cmd.runId, command: cmd.command },
-                        });
-                    }
-                    else {
-                        await runTurn(ctx);
-                    }
-                }
-                catch (error) {
-                    logError(`Turn failed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        finally {
-            running = false;
-            maybeExit();
-        }
-    };
-    const rl = createInterface({ input: process.stdin });
-    rl.on('line', (line) => {
-        const trimmed = line.trim();
-        if (!trimmed || shuttingDown) {
-            return;
-        }
-        let cmd;
-        try {
-            cmd = JSON.parse(trimmed);
-        }
-        catch {
-            logError(`Ignoring malformed command: ${trimmed}`);
-            return;
-        }
-        queue.push(cmd);
-        void drain();
-    });
-    // stdin closing is the desktop's normal "stop this session" signal.
-    rl.on('close', () => {
-        stdinEnded = true;
-        maybeExit();
-    });
-}

package/dist/commands/session-turn/index.d.ts

@@ -1,73 +0,0 @@
-/**
- * Marker emitted on stdout carrying the SDK session id, so the desktop can
- * persist it on the channel and pass it back via --resume next turn. Kept on
- * its own line and free of logger formatting so it parses cleanly.
- */
-export declare const SESSION_ID_MARKER = "__EDSGER_SESSION_ID__=";
-/**
- * Marker emitted on stdout for each background `cli_*` run still in flight when
- * the turn ends. The desktop main process parses these, watches each run to
- * completion (the turn process itself exits immediately), and then re-engages
- * the agent via `--run-finished` so it reports results without the user having
- * to ask. The JSON payload is `{ run_id, pid, log_path, command }`.
- */
-export declare const CLI_RUN_MARKER = "__EDSGER_CLI_RUN__=";
-import { loadExternalMcpServers } from 'edsger-tools';
-export interface SessionTurnCliOptions {
-    channelId: string;
-    productId: string;
-    repositoryIds?: string[];
-    /** SDK session id from a previous turn, to resume the same conversation. */
-    resumeSessionId?: string;
-    /**
-     * Follow-up turn triggered by the desktop watcher when a background `cli_*`
-     * run finishes. When set, the turn is driven by a synthetic prompt instead of
-     * the channel's pending human messages: the agent inspects what the run
-     * produced and reports it to the user.
-     */
-    runFinished?: {
-        runId: string;
-        command?: string;
-    };
-    verbose?: boolean;
-}
-/**
- * Everything a session needs to run turns, built once and reused. The daemon
- * keeps a single instance alive across turns so repo clones, the MCP toolbelt,
- * the system prompt, and the SDK session id all persist.
- */
-export interface SessionContext {
-    channelId: string;
-    productId: string;
-    repositoryIds: string[];
-    verbose: boolean;
-    sessionDir?: string;
-    systemPrompt: string;
-    sessionServer: any;
-    external: ReturnType<typeof loadExternalMcpServers>;
-    /** Latest SDK session id; carried into the next turn's `resume`. Mutable. */
-    sdkSessionId: string;
-}
-/**
- * Build the one-time session context: clone repos, assemble the MCP toolbelt
- * and external servers, and build the system prompt. Cheap to call once per
- * session process; expensive to call per turn (which is why the daemon doesn't).
- */
-export declare function prepareSessionContext(options: SessionTurnCliOptions): Promise<SessionContext>;
-/**
- * Run a single agent turn against an already-prepared {@link SessionContext}.
- * Mutates `ctx.sdkSessionId` so the next turn resumes the same SDK conversation
- * (and prompt cache). Safe to call repeatedly for the life of the process.
- */
-export declare function runTurn(ctx: SessionContext, opts?: {
-    runFinished?: {
-        runId: string;
-        command?: string;
-    };
-}): Promise<void>;
-/**
- * One-shot `session-turn`: prepare the context and run a single turn. Retained
- * for callers that want the previous per-turn-process behaviour (and as the
- * building block the daemon reuses).
- */
-export declare function runSessionTurnCommand(options: SessionTurnCliOptions): Promise<void>;