edsger 0.76.0 → 0.78.0

package/dist/commands/chat-serve/chat-server.js

@@ -1,339 +0,0 @@
-/**
- * Chat Server — the engine behind the standalone `edsger chat-serve` daemon.
- *
- * A single long-lived process that answers human messages on **issue** and
- * **product group** chat channels (the chat surfaces in the issue- and
- * product-detail pages). It is deliberately independent of the autonomous
- * agent workflow: unlike the previous `chat-worker`, it is not forked by
- * `AgentWorkflowProcessor` and needs no IPC from it — so chat keeps working
- * whether or not the workflow is running.
- *
- * Two channel kinds are served here:
- *   - `issue`   — `channel_type='issue'`
- *   - `product` — `channel_type='product'` AND `chat_mode='group'`
- *
- * Session chats (`chat_mode='ai_assistant'`) are deliberately excluded — they
- * are owned by the per-session `edsger session-serve` daemon. Letting both
- * claim the same messages would produce duplicate replies.
- *
- * Message intake prefers Supabase Realtime (a `chat_messages` INSERT wakes the
- * claim+process path immediately); when no Supabase session is available it
- * falls back to MCP polling. Either way, messages are claimed atomically
- * (`claimPendingMessages`) so multiple workers never process the same message.
- *
- * Issue chats can give the AI read access to the issue's cloned repo. The repo
- * path is derived locally from the workspace root + issue id (the same pure
- * mapping the workflow uses), so no IPC hand-off is required; when the clone
- * isn't present the chat simply runs without code context.
- *
- * Side-effectful collaborators are injected via {@link ChatServerDeps} (with
- * real implementations as the default) so the routing/repo logic is unit
- * testable without a live Supabase or filesystem.
- */
-import { randomUUID } from 'node:crypto';
-import { claimPendingMessages, listChannels } from '../../api/chat.js';
-import { processHumanMessages, processProductHumanMessages, } from '../../phases/chat-processor/index.js';
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { getIssueRepoPath, issueRepoExists, } from '../../workspace/workspace-manager.js';
-/**
- * Classify a channel into the kind this server serves, or `null` to ignore it.
- * Pure — the single source of truth for "should chat-serve touch this channel",
- * shared by the initial refresh and the Realtime registration path.
- *
- * Note the precise product rule: only `chat_mode='group'` product channels are
- * served. `ai_assistant` (session) channels belong to `edsger session-serve`;
- * any other mode (e.g. `direct`) is not a product group chat and is ignored.
- */
-export function classifyChannel(channel) {
-    if (channel.channel_type === 'issue') {
-        return 'issue';
-    }
-    if (channel.channel_type === 'product' && channel.chat_mode === 'group') {
-        return 'product';
-    }
-    return null;
-}
-const POLL_INTERVAL_MS = 5_000;
-/** Periodic channel re-discovery (also a Realtime-mode safety net + keepalive). */
-const REFRESH_INTERVAL_MS = 60_000;
-/** Max time `stop()` waits for in-flight message processing before exiting. */
-const DRAIN_TIMEOUT_MS = 15_000;
-const defaultDeps = {
-    listChannels,
-    claimPendingMessages,
-    processHumanMessages,
-    processProductHumanMessages,
-    issueRepoExists,
-    getIssueRepoPath,
-    hasSupabaseSession,
-    getSupabase,
-};
-export class ChatServer {
-    deps;
-    config;
-    workspaceRoot;
-    verbose;
-    /** Unique id for atomic message claiming across competing workers. */
-    workerId = `chat-serve-${process.pid}-${randomUUID().slice(0, 8)}`;
-    /** issueId -> channelId */
-    issueChannels = new Map();
-    /** productId -> channelId */
-    productChannels = new Map();
-    /** channelId -> { kind, refId } */
-    metaByChannel = new Map();
-    /** In-flight message processing, awaited on shutdown so we drain cleanly. */
-    inflight = new Set();
-    realtimeChannel = null;
-    pollTimer = null;
-    refreshTimer = null;
-    running = false;
-    constructor(options, deps = defaultDeps) {
-        this.config = options.config;
-        this.workspaceRoot = options.workspaceRoot;
-        this.verbose = options.verbose ?? false;
-        this.deps = deps;
-    }
-    /** Bring the server up: seed channels, drain backlog, start intake. */
-    async start() {
-        if (this.running) {
-            return;
-        }
-        this.running = true;
-        logInfo(`Chat server starting (id: ${this.workerId})`);
-        // Seed the channel cache before subscriptions so Realtime events can be
-        // routed by channel id without an extra round-trip.
-        await this.refreshChannels();
-        // Drain anything that arrived while we were offline.
-        for (const channelId of this.metaByChannel.keys()) {
-            this.dispatch(channelId);
-        }
-        if (this.startRealtime()) {
-            logInfo('Chat server running in Realtime mode');
-            // Low-frequency refresh as a safety net for missed channel INSERTs and
-            // to keep the event loop alive even if the Realtime socket drops.
-            this.refreshTimer = setInterval(() => {
-                void this.refreshChannels();
-            }, REFRESH_INTERVAL_MS);
-            return;
-        }
-        logWarning('No Supabase session — chat server using MCP polling mode');
-        this.startPolling();
-    }
-    /**
-     * Stop accepting new work, tear down timers/subscriptions, then wait for any
-     * in-flight message processing to finish (bounded by DRAIN_TIMEOUT_MS) so a
-     * mid-flight reply isn't abandoned. Idempotent.
-     */
-    async stop() {
-        this.running = false;
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-        if (this.refreshTimer) {
-            clearInterval(this.refreshTimer);
-            this.refreshTimer = null;
-        }
-        this.stopRealtime();
-        if (this.inflight.size > 0) {
-            logInfo(`Draining ${this.inflight.size} in-flight message turn(s)…`);
-            await Promise.race([
-                Promise.allSettled([...this.inflight]),
-                delay(DRAIN_TIMEOUT_MS),
-            ]);
-        }
-        logInfo('Chat server stopped');
-    }
-    // ── Channel discovery ──────────────────────────────────────────────────
-    async refreshChannels() {
-        try {
-            const [issueChannels, productChannels] = await Promise.all([
-                this.deps.listChannels('issue'),
-                this.deps.listChannels('product'),
-            ]);
-            let added = 0;
-            for (const channel of [...issueChannels, ...productChannels]) {
-                if (this.registerChannel(channel)) {
-                    added++;
-                }
-            }
-            if (added > 0) {
-                logInfo(`Discovered ${added} new channel(s) (issues: ${this.issueChannels.size}, products: ${this.productChannels.size})`);
-            }
-        }
-        catch (error) {
-            logError(`Failed to refresh channels: ${describe(error)}`);
-        }
-    }
-    /**
-     * Register a channel into the routing maps. Returns true if it was newly
-     * added. Ignores channels this server doesn't serve (e.g. session chats).
-     */
-    registerChannel(channel) {
-        if (!channel.channel_ref_id) {
-            return false;
-        }
-        const kind = classifyChannel(channel);
-        if (!kind) {
-            return false; // session / general channel — not ours
-        }
-        const refMap = kind === 'issue' ? this.issueChannels : this.productChannels;
-        const isNew = !refMap.has(channel.channel_ref_id);
-        refMap.set(channel.channel_ref_id, channel.id);
-        this.metaByChannel.set(channel.id, { kind, refId: channel.channel_ref_id });
-        if (isNew) {
-            logInfo(`New ${kind} channel: ${channel.channel_ref_id} (${channel.id})`);
-        }
-        return isNew;
-    }
-    // ── Message processing ─────────────────────────────────────────────────
-    /** Fire-and-forget a claim+process while tracking it for graceful drain. */
-    dispatch(channelId) {
-        const task = this.claimAndProcess(channelId);
-        this.inflight.add(task);
-        void task.finally(() => this.inflight.delete(task));
-    }
-    /** Claim and process pending human messages on a single known channel. */
-    async claimAndProcess(channelId) {
-        if (!this.running) {
-            return;
-        }
-        const meta = this.metaByChannel.get(channelId);
-        if (!meta) {
-            // Unknown channel — the chat_channels subscription / next refresh will
-            // seed it, and the following message event will pick it up.
-            return;
-        }
-        try {
-            const claimed = await this.deps.claimPendingMessages(channelId, this.workerId);
-            if (claimed.length === 0) {
-                return;
-            }
-            logInfo(`Claimed ${claimed.length} message(s) for ${meta.kind} ${meta.refId}`);
-            if (meta.kind === 'issue') {
-                await this.deps.processHumanMessages(claimed, meta.refId, this.config, this.verbose, this.resolveRepoPath(meta.refId));
-            }
-            else {
-                await this.deps.processProductHumanMessages(claimed, meta.refId, this.config, this.verbose);
-            }
-        }
-        catch (error) {
-            logError(`Error processing channel ${channelId}: ${describe(error)}`);
-        }
-    }
-    /**
-     * Locate the issue's cloned repo so the chat AI can read code. Derived from
-     * the workspace root with the same pure mapping the workflow uses; returns
-     * undefined when the clone isn't present (chat then runs without code).
-     */
-    resolveRepoPath(issueId) {
-        if (this.deps.issueRepoExists(this.workspaceRoot, issueId)) {
-            return this.deps.getIssueRepoPath(this.workspaceRoot, issueId);
-        }
-        if (this.verbose) {
-            logInfo(`No local clone for issue ${issueId} — chat runs without code context`);
-        }
-        return undefined;
-    }
-    // ── Realtime intake ────────────────────────────────────────────────────
-    startRealtime() {
-        if (this.realtimeChannel) {
-            return true;
-        }
-        if (!this.deps.hasSupabaseSession()) {
-            return false;
-        }
-        try {
-            this.realtimeChannel = this.deps
-                .getSupabase()
-                .channel('chat-serve', { config: { broadcast: { ack: false } } })
-                .on('postgres_changes', {
-                event: 'INSERT',
-                schema: 'public',
-                table: 'chat_messages',
-                filter: 'sender_type=eq.human',
-            }, (payload) => {
-                const row = payload.new;
-                if (!row.channel_id || row.is_processed) {
-                    return;
-                }
-                this.dispatch(row.channel_id);
-            })
-                .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'chat_channels' }, (payload) => {
-                const channel = payload.new;
-                this.registerChannel(channel);
-                if (channel.id) {
-                    this.dispatch(channel.id);
-                }
-            })
-                .subscribe((status) => {
-                if (status === 'SUBSCRIBED') {
-                    logInfo('Realtime subscription active (chat_messages, chat_channels)');
-                }
-                else if (status === 'CHANNEL_ERROR' ||
-                    status === 'TIMED_OUT' ||
-                    status === 'CLOSED') {
-                    logWarning(`Realtime channel status: ${status}`);
-                    // supabase-js auto-reconnects; the refresh timer covers the gap.
-                }
-            });
-            return true;
-        }
-        catch (error) {
-            logError(`Failed to start Realtime subscription: ${describe(error)}`);
-            return false;
-        }
-    }
-    stopRealtime() {
-        if (!this.realtimeChannel) {
-            return;
-        }
-        try {
-            void this.deps.getSupabase().removeChannel(this.realtimeChannel);
-        }
-        catch {
-            // Best-effort; supabase may already be torn down.
-        }
-        this.realtimeChannel = null;
-    }
-    // ── Polling fallback (no Supabase session) ─────────────────────────────
-    startPolling() {
-        if (this.pollTimer) {
-            return;
-        }
-        void this.pollOnce();
-        this.pollTimer = setInterval(() => void this.pollOnce(), POLL_INTERVAL_MS);
-        // Periodically re-discover channels in the polling path too.
-        this.refreshTimer = setInterval(() => {
-            void this.refreshChannels();
-        }, REFRESH_INTERVAL_MS);
-    }
-    async pollOnce() {
-        if (!this.running) {
-            return;
-        }
-        for (const channelId of this.metaByChannel.keys()) {
-            const task = this.claimAndProcess(channelId);
-            this.inflight.add(task);
-            try {
-                await task;
-            }
-            finally {
-                this.inflight.delete(task);
-            }
-        }
-    }
-}
-function describe(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function delay(ms) {
-    return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        // Don't keep the event loop alive solely for the drain timeout.
-        if (typeof timer.unref === 'function') {
-            timer.unref();
-        }
-    });
-}

package/dist/commands/chat-serve/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * `edsger chat-serve` — long-lived daemon that answers human messages on issue
- * and product group chat channels.
- *
- * This is the standalone replacement for the old `chat-worker` that
- * `AgentWorkflowProcessor` used to fork. Running it as its own top-level
- * process (spawned by the desktop app, sibling to `edsger --verbose` and
- * `edsger session-serve`) decouples chat from the autonomous workflow: chat
- * works whether or not the workflow is running, and the two never both claim
- * the same messages.
- *
- * Like the agent workflow, it requires `edsger login` first and exits promptly
- * if no auth is found. The actual chat-serving logic lives in {@link ChatServer}.
- */
-export interface ChatServeCliOptions {
-    verbose?: boolean;
-    /** Optional path to an edsger config file (forwarded to validateConfiguration). */
-    config?: string;
-}
-export declare function runChatServeCommand(options?: ChatServeCliOptions): Promise<void>;

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

@@ -1,58 +0,0 @@
-/**
- * `edsger chat-serve` — long-lived daemon that answers human messages on issue
- * and product group chat channels.
- *
- * This is the standalone replacement for the old `chat-worker` that
- * `AgentWorkflowProcessor` used to fork. Running it as its own top-level
- * process (spawned by the desktop app, sibling to `edsger --verbose` and
- * `edsger session-serve`) decouples chat from the autonomous workflow: chat
- * works whether or not the workflow is running, and the two never both claim
- * the same messages.
- *
- * Like the agent workflow, it requires `edsger login` first and exits promptly
- * if no auth is found. The actual chat-serving logic lives in {@link ChatServer}.
- */
-import { isLoggedIn } from '../../auth/auth-store.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
-import { ensureWorkspaceDir } from '../../workspace/workspace-manager.js';
-import { ChatServer } from './chat-server.js';
-export async function runChatServeCommand(options = {}) {
-    // Mirror the agent workflow: auth is required, and we exit fast when absent
-    // so the desktop supervisor can surface a "run `edsger login`" hint.
-    if (!isLoggedIn()) {
-        logError('Not authenticated. Please run `edsger login` first.');
-        process.exit(1);
-    }
-    const cliOptions = {
-        verbose: options.verbose,
-        config: options.config,
-    };
-    const config = validateConfiguration(cliOptions);
-    const workspaceRoot = ensureWorkspaceDir();
-    logInfo(`Workspace: ${workspaceRoot}`);
-    const server = new ChatServer({
-        config,
-        workspaceRoot,
-        verbose: options.verbose,
-    });
-    await server.start();
-    let shuttingDown = false;
-    const shutdown = async (signal) => {
-        if (shuttingDown) {
-            return;
-        }
-        shuttingDown = true;
-        logInfo(`Received ${signal} — shutting down chat server.`);
-        await server.stop();
-        process.exit(0);
-    };
-    process.on('SIGTERM', () => void shutdown('SIGTERM'));
-    process.on('SIGINT', () => void shutdown('SIGINT'));
-    process.on('uncaughtException', (error) => {
-        logError(`Uncaught exception: ${error instanceof Error ? error.message : String(error)}`);
-        void server.stop().finally(() => process.exit(1));
-    });
-    // The Realtime socket / poll timer keep the event loop alive; nothing else
-    // to do on the main path. The process lives until a signal arrives.
-}

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

@@ -1,16 +0,0 @@
-/**
- * Checklists command — uses Claude Agent SDK to analyse a local directory
- * and sync product checklists (create / update / delete) via MCP tools.
- */
-import { type CliOptions } from '../../types/index.js';
-/**
- * Run AI-powered checklist sync. Scope is either a product (analyse the
- * product's codebase) or a team (analyse team standards docs, generate
- * org-wide checklists).
- */
-export declare function runChecklists(options: CliOptions & {
-    checklistsProductId?: string;
-    checklistsTeamId?: string;
-    checklistsDir?: string;
-    checklistsPrompt?: string;
-}): Promise<void>;

package/dist/commands/checklists/index.js

@@ -1,187 +0,0 @@
-/**
- * Checklists command — uses Claude Agent SDK to analyse a local directory
- * and sync product checklists (create / update / delete) via MCP tools.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { isLoggedIn } from '../../auth/auth-store.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { deregisterSession, registerSession, } from '../../system/session-manager.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
-import { createChecklistsMcpServer } from './tools.js';
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function logAssistantContent(content) {
-    for (const item of content) {
-        if (item.type === 'text') {
-            logInfo(item.text);
-        }
-        else if (item.type === 'tool_use') {
-            logInfo(`[tool] ${item.name}: ${item.input?.description || item.input?.command || ''}`);
-        }
-    }
-}
-// Two SYSTEM_PROMPTs because team-level sync has a different mental model:
-// the directory is reference material (org standards / process docs / shared
-// templates), not necessarily a product's own codebase. Telling the LLM
-// "scan the code" when there's no code wastes turns.
-const PRODUCT_SYSTEM_PROMPT = `You are an expert software quality engineer. Your job is to analyse the code and documentation in the current working directory and manage quality checklists for the product.
-
-## Workflow
-
-1. **Explore** the directory — read key files (README, package.json, config files, source code, tests, docs) to understand the project's technology stack, architecture, patterns, and quality concerns.
-2. **Query existing checklists** using \`list_checklists\` so you know what already exists.
-3. **Decide what to change** — compare the codebase against existing checklists:
-   - **Create** new checklists for areas not yet covered (e.g., security, performance, accessibility, testing, deployment).
-   - **Update** checklists whose items are outdated or incomplete.
-   - **Delete** checklists that are no longer relevant.
-   - **Add / update / remove items** within checklists as needed.
-4. **Execute the changes** using the provided tools.
-5. **Summarise** what you did at the end.
-
-## Guidelines
-
-- Focus on actionable, verifiable checklist items — things a reviewer can check yes/no.
-- Assign the correct **role** to each checklist (developer, qa_engineer, technical_lead, etc.).
-- Assign relevant **phases** (code_implementation, code_review, technical_design, functional_testing, etc.).
-- Keep item titles concise (< 80 chars). Use the description for details.
-- Prefer boolean item_type for most items.
-- Do not create duplicate checklists — update existing ones instead.
-- If the codebase is small, a few focused checklists are better than many sparse ones.
-- When creating multiple checklists, assign incrementing sort_order values (0, 1, 2, …) so they display in a meaningful order.
-`;
-const TEAM_SYSTEM_PROMPT = `You are an expert software quality engineer. Your job is to analyse the reference material in the current working directory (team standards, engineering guidelines, process docs, compliance requirements, shared templates, etc.) and manage TEAM-LEVEL quality checklists.
-
-Team checklists apply to every product owned by the team, so they should capture **organisation-wide** quality bars — not the specifics of any single codebase.
-
-## Workflow
-
-1. **Explore** the directory — read every relevant doc to understand the team's engineering standards, review process, security baseline, release rules, and other shared expectations. The directory is reference material, not necessarily product source code.
-2. **Query existing team checklists** using \`list_checklists\` so you know what already exists.
-3. **Decide what to change** — compare the standards documented in the directory against existing checklists:
-   - **Create** team checklists for standards that are not yet enforced (e.g., security baseline, release readiness, accessibility minimums, code-review etiquette).
-   - **Update** checklists whose items have drifted from the documented standards.
-   - **Delete** checklists that no longer reflect team policy.
-   - **Add / update / remove items** within checklists as needed.
-4. **Execute the changes** using the provided tools.
-5. **Summarise** what you did at the end.
-
-## Guidelines
-
-- Stay generic across products — a team checklist will apply to every product in the team, so do NOT bake in product-specific tech-stack assumptions.
-- Focus on actionable, verifiable checklist items — things a reviewer can check yes/no.
-- Assign the correct **role** to each checklist (developer, qa_engineer, technical_lead, etc.).
-- Assign relevant **phases** (code_implementation, code_review, technical_design, functional_testing, etc.).
-- Keep item titles concise (< 80 chars). Use the description for details.
-- Prefer boolean item_type for most items.
-- Do not create duplicate checklists — update existing ones instead.
-- When creating multiple checklists, assign incrementing sort_order values (0, 1, 2, …) so they display in a meaningful order.
-`;
-/**
- * Run AI-powered checklist sync. Scope is either a product (analyse the
- * product's codebase) or a team (analyse team standards docs, generate
- * org-wide checklists).
- */
-export async function runChecklists(options) {
-    const productId = options.checklistsProductId;
-    const teamId = options.checklistsTeamId;
-    const directory = options.checklistsDir || process.cwd();
-    const userPrompt = options.checklistsPrompt;
-    if (!productId && !teamId) {
-        throw new Error('checklists sync requires either a product ID or a team ID.');
-    }
-    if (productId && teamId) {
-        throw new Error('checklists sync received both a product ID and a team ID; choose one.');
-    }
-    const isTeamScope = !productId;
-    if (!isLoggedIn()) {
-        throw new Error('You must be logged in to run checklists sync.\n' +
-            'Run `edsger login` first.');
-    }
-    // Validate configuration (ensures .edsgerrc and env are loaded)
-    validateConfiguration(options);
-    // Register CLI session for log persistence. We pass productId only when
-    // present so existing per-product session indexing still works.
-    await registerSession({ command: 'checklists', productId });
-    if (isTeamScope) {
-        logInfo(`Starting checklist sync for team: ${teamId}`);
-    }
-    else {
-        logInfo(`Starting checklist sync for product: ${productId}`);
-    }
-    logInfo(`Analysing directory: ${directory}`);
-    if (userPrompt) {
-        logInfo(`User instructions: ${userPrompt}`);
-    }
-    const mcpServer = isTeamScope
-        ? createChecklistsMcpServer({ kind: 'team', teamId: teamId })
-        : createChecklistsMcpServer({
-            kind: 'product',
-            productId,
-        });
-    const promptParts = isTeamScope
-        ? [
-            `Analyse the reference material in the current working directory and synchronise the TEAM-LEVEL quality checklists.`,
-            `Team ID: ${teamId}`,
-            `Directory: ${directory}`,
-            '',
-            'Start by exploring the directory and reading every relevant standards / process / guideline document, then query existing team checklists, and finally create/update/delete as needed. Remember: team checklists apply to every product in the team, so keep them generic.',
-        ]
-        : [
-            `Analyse the codebase in the current working directory and synchronise the product's quality checklists.`,
-            `Product ID: ${productId}`,
-            `Directory: ${directory}`,
-            '',
-            'Start by exploring the project structure and reading key files, then query existing checklists, and finally create/update/delete as needed.',
-        ];
-    if (userPrompt) {
-        promptParts.push('', '## Additional Instructions from User', '', userPrompt);
-    }
-    const prompt = promptParts.join('\n');
-    const SYSTEM_PROMPT = isTeamScope ? TEAM_SYSTEM_PROMPT : PRODUCT_SYSTEM_PROMPT;
-    try {
-        for await (const message of query({
-            prompt,
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: SYSTEM_PROMPT,
-                },
-                model: DEFAULT_MODEL,
-                permissionMode: 'bypassPermissions',
-                maxTurns: 40,
-                mcpServers: {
-                    'edsger-checklists': mcpServer,
-                },
-                cwd: directory,
-            },
-        })) {
-            if (message.type === 'assistant') {
-                logAssistantContent(message.message?.content ?? []);
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (message.subtype === 'success') {
-                logSuccess('Checklist sync completed successfully!');
-                if (message.result) {
-                    logInfo(message.result);
-                }
-            }
-            else {
-                logWarning(`Checklist sync incomplete: ${message.subtype}`);
-                if (message.subtype === 'error_max_turns') {
-                    logWarning('The agent reached the maximum number of turns.');
-                }
-            }
-        }
-    }
-    catch (error) {
-        logError(`Checklist sync failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exitCode = 1;
-    }
-    finally {
-        await deregisterSession();
-    }
-}

package/dist/commands/checklists/tools.d.ts

@@ -1,17 +0,0 @@
-/**
- * Checklists MCP server — CLI entry point.
- *
- * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
- * `callMcpEndpoint` transport into `ToolDeps` and threads the scope id
- * (productId or teamId) through `deps.context` so the CLI can run AI
- * sync against either a product or a team.
- */
-import type { McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
-export type ChecklistScope = {
-    kind: 'product';
-    productId: string;
-} | {
-    kind: 'team';
-    teamId: string;
-};
-export declare function createChecklistsMcpServer(scope: ChecklistScope | string): McpSdkServerConfigWithInstance;

package/dist/commands/checklists/tools.js

@@ -1,19 +0,0 @@
-/**
- * Checklists MCP server — CLI entry point.
- *
- * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
- * `callMcpEndpoint` transport into `ToolDeps` and threads the scope id
- * (productId or teamId) through `deps.context` so the CLI can run AI
- * sync against either a product or a team.
- */
-import { createChecklistsMcpServer as createChecklistsMcpServerCore } from 'edsger-tools';
-import { getToolDeps } from '../../tools/bootstrap.js';
-export function createChecklistsMcpServer(scope) {
-    // Backwards compat: if a bare string is passed, treat it as productId.
-    const ctx = typeof scope === 'string'
-        ? { productId: scope }
-        : scope.kind === 'product'
-            ? { productId: scope.productId }
-            : { teamId: scope.teamId };
-    return createChecklistsMcpServerCore(getToolDeps(false, ctx));
-}

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

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

@@ -1,9 +0,0 @@
-/**
- * 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);
-}