edsger 0.77.0 → 0.78.0

package/dist/commands/agent-workflow/processor.d.ts

@@ -1,95 +0,0 @@
-/**
- * Agent Workflow Processor - Cross-product issue processing
- *
- * Uses child_process.fork() to run each issue in an isolated worker process.
- * This enables:
- * - Concurrent processing of multiple issues (each worker has its own cwd)
- * - Auto-update takes effect on next issue (new workers load latest code)
- * - Crash isolation (one worker failing doesn't affect others)
- */
-import { type EdsgerConfig } from '../../types/index.js';
-import { type WorkflowStats } from '../workflow/core/state-manager.js';
-/**
- * Maximum allowed concurrency (hard cap).
- * Limits are due to:
- * - MCP API rate limits (per-minute/per-hour per token)
- * - AI API rate limits (Claude/OpenAI RPM/TPM)
- * - GitHub App installation token rate limit (5000 req/hour)
- * - Memory: each fork() creates ~50-80MB Node.js process
- */
-export declare const MAX_CONCURRENCY = 10;
-export interface AgentWorkflowOptions {
-    readonly workspaceRoot: string;
-    readonly pollInterval?: number;
-    readonly maxConcurrent?: number;
-    readonly maxRetries?: number;
-    readonly verbose?: boolean;
-}
-export declare class AgentWorkflowProcessor {
-    private readonly options;
-    private readonly config;
-    private isRunning;
-    private processedIssues;
-    private pollTimer?;
-    /** Currently active worker processes, keyed by issueId */
-    private activeWorkers;
-    /** Realtime subscription on `issues` — wakes processNextIssues when an
-     * issue flips to ready_for_ai, so the 30s poll can be relaxed. */
-    private issuesRealtimeChannel;
-    constructor(options: AgentWorkflowOptions, config: EdsgerConfig);
-    start(): Promise<void>;
-    /**
-     * Subscribe to `issues` UPDATE/INSERT events and trigger processNextIssues
-     * when a row arrives with `status='ready_for_ai'` assigned to this user.
-     *
-     * Returns true if the subscription was successfully started. RLS on `issues`
-     * already constrains delivery to products the user has access to.
-     */
-    private startIssuesRealtime;
-    /**
-     * Post a best-effort workflow status update into the issue's chat channel.
-     * Chat itself is served by the standalone `edsger chat-serve` daemon; the
-     * workflow only narrates lifecycle milestones here. Fire-and-forget — a chat
-     * failure must never affect issue processing.
-     */
-    private narrateToIssueChat;
-    stop(): void;
-    private processNextIssues;
-    /**
-     * Start a child process worker for a single issue.
-     * Handles: atomic claim, GitHub config lookup, repo cloning, then forks
-     * the worker.
-     *
-     * The candidate `issue` here comes from the listed ready_for_ai pool but is
-     * advisory — between list time and claim time another agent (or another
-     * process) may have grabbed it. We re-claim atomically per product. The
-     * RPC returns whichever ready issue is next in that product (most often
-     * the same one we listed, but not guaranteed); we operate on what claim
-     * actually returns. If claim returns null, someone else won the race —
-     * skip this slot for this cycle.
-     */
-    private startIssueWorker;
-    /**
-     * After a successful claim moved the issue ready_for_ai → assigned_to_ai,
-     * any post-claim setup failure (GitHub config, clone, fork) leaves the
-     * issue stuck at assigned_to_ai with no worker — an orphan that the user
-     * can't fix from the UI. Push it forward to 'failed' so it shows up in
-     * the failed bucket and can be inspected / re-set to ready_for_ai by a
-     * human.
-     *
-     * Status guard: only force-progress if the issue is still at
-     * assigned_to_ai or in_progress. A worker may have already advanced the
-     * status to shipped / failed via a separate code path before we got the
-     * non-success IPC signal; clobbering those would lose real outcome data.
-     * STATUS_PROGRESSION_ORDER classifies shipped→failed as a forward move
-     * (so updateIssueStatus wouldn't reject it), which is why this guard
-     * lives here rather than at the RPC layer.
-     *
-     * Errors are swallowed: if the status fetch or update fails the issue
-     * stays orphaned but logging is the most we can do here.
-     */
-    private releaseClaim;
-    private handleWorkerResult;
-    getStats(): WorkflowStats;
-    getActiveWorkerCount(): number;
-}

package/dist/commands/agent-workflow/processor.js

@@ -1,519 +0,0 @@
-/**
- * Agent Workflow Processor - Cross-product issue processing
- *
- * Uses child_process.fork() to run each issue in an isolated worker process.
- * This enables:
- * - Concurrent processing of multiple issues (each worker has its own cwd)
- * - Auto-update takes effect on next issue (new workers load latest code)
- * - Crash isolation (one worker failing doesn't affect others)
- */
-import { fork } from 'child_process';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { sendIssueSystemMessage } from '../../api/chat.js';
-import { listAllReadyIssues, } from '../../api/cross-product.js';
-import { getGitHubConfig } from '../../api/github.js';
-import { claimNextIssue, getIssue } from '../../api/issues/index.js';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { getUserId } from '../../auth/auth-store.js';
-import { WorkerTimeoutError } from '../../errors/index.js';
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-import { sendHeartbeat, shouldProcess } from '../../system/session-manager.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cleanupIssueRepo, cloneIssueRepo, getIssueRepoPath, } from '../../workspace/workspace-manager.js';
-import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateIssueState, } from '../workflow/core/state-manager.js';
-/**
- * Maximum allowed concurrency (hard cap).
- * Limits are due to:
- * - MCP API rate limits (per-minute/per-hour per token)
- * - AI API rate limits (Claude/OpenAI RPM/TPM)
- * - GitHub App installation token rate limit (5000 req/hour)
- * - Memory: each fork() creates ~50-80MB Node.js process
- */
-export const MAX_CONCURRENCY = 10;
-/** Path to the compiled worker entry points */
-// eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
-const __filename = fileURLToPath(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
-const __dirname = dirname(__filename);
-const WORKER_SCRIPT = join(__dirname, 'issue-worker.js');
-export class AgentWorkflowProcessor {
-    options;
-    config;
-    isRunning = false;
-    processedIssues = createInitialState();
-    pollTimer;
-    /** Currently active worker processes, keyed by issueId */
-    activeWorkers = new Map();
-    /** Realtime subscription on `issues` — wakes processNextIssues when an
-     * issue flips to ready_for_ai, so the 30s poll can be relaxed. */
-    issuesRealtimeChannel = null;
-    constructor(options, config) {
-        const wf = config.workflow;
-        this.options = {
-            pollInterval: options.pollInterval ?? wf.pollInterval,
-            maxConcurrent: Math.min(options.maxConcurrent ?? wf.maxConcurrency, MAX_CONCURRENCY),
-            maxRetries: options.maxRetries ?? wf.maxRetries,
-            verbose: false,
-            ...options,
-        };
-        this.config = config;
-    }
-    async start() {
-        if (this.isRunning) {
-            logInfo('Agent processor is already running');
-            return;
-        }
-        this.isRunning = true;
-        logInfo(`Concurrent processing: up to ${this.options.maxConcurrent} issue(s)`);
-        // Initial issue check
-        await this.processNextIssues();
-        // Set up Realtime subscription on `issues` so a status flip to
-        // 'ready_for_ai' triggers an immediate processing pass instead of
-        // waiting for the next poll tick. Falls back to the timer-only path
-        // when the Supabase session isn't available yet.
-        const realtimeOk = this.startIssuesRealtime();
-        // Keep the timer as a safety net (Realtime can drop events on
-        // reconnect / publication lag). When Realtime is active we stretch the
-        // interval substantially — the timer is purely a backstop now.
-        const safetyNetInterval = realtimeOk
-            ? Math.max(this.options.pollInterval, 5 * 60_000)
-            : this.options.pollInterval;
-        this.pollTimer = setInterval(() => {
-            this.processNextIssues().catch((error) => {
-                logError(`Polling error: ${error instanceof Error ? error.message : String(error)}`);
-            });
-        }, safetyNetInterval);
-    }
-    /**
-     * Subscribe to `issues` UPDATE/INSERT events and trigger processNextIssues
-     * when a row arrives with `status='ready_for_ai'` assigned to this user.
-     *
-     * Returns true if the subscription was successfully started. RLS on `issues`
-     * already constrains delivery to products the user has access to.
-     */
-    startIssuesRealtime() {
-        if (this.issuesRealtimeChannel) {
-            return true;
-        }
-        const userId = getUserId();
-        if (!hasSupabaseSession() || !userId) {
-            return false;
-        }
-        try {
-            const supabase = getSupabase();
-            const onChange = (payload) => {
-                const row = payload.new;
-                if (!row) {
-                    return;
-                }
-                // Realtime postgres_changes filter syntax only supports a single
-                // predicate, so filter the rest in-process.
-                if (row.status !== 'ready_for_ai' ||
-                    (row.developer_id && row.developer_id !== userId)) {
-                    return;
-                }
-                this.processNextIssues().catch((error) => {
-                    logError(`Realtime-triggered processNextIssues failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            };
-            this.issuesRealtimeChannel = supabase
-                .channel('agent-workflow-issues')
-                .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'issues' }, onChange)
-                .on('postgres_changes', { event: 'UPDATE', schema: 'public', table: 'issues' }, onChange)
-                .subscribe((status) => {
-                if (status === 'SUBSCRIBED') {
-                    logInfo('Realtime subscription on issues active');
-                }
-                else if (status === 'CHANNEL_ERROR' ||
-                    status === 'TIMED_OUT' ||
-                    status === 'CLOSED') {
-                    logWarning(`Issues Realtime channel status: ${status}`);
-                }
-            });
-            return true;
-        }
-        catch (error) {
-            logWarning(`Failed to start issues Realtime subscription: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
-        }
-    }
-    /**
-     * Post a best-effort workflow status update into the issue's chat channel.
-     * Chat itself is served by the standalone `edsger chat-serve` daemon; the
-     * workflow only narrates lifecycle milestones here. Fire-and-forget — a chat
-     * failure must never affect issue processing.
-     */
-    narrateToIssueChat(issueId, content, metadata) {
-        void sendIssueSystemMessage(issueId, content, metadata).catch((error) => {
-            logWarning(`Failed to post chat update for issue ${issueId}: ${error instanceof Error ? error.message : String(error)}`);
-        });
-    }
-    stop() {
-        if (!this.isRunning) {
-            return;
-        }
-        this.isRunning = false;
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = undefined;
-        }
-        // Tear down Realtime first so a late event doesn't kick off new work
-        // while we're shutting down workers.
-        if (this.issuesRealtimeChannel) {
-            try {
-                void getSupabase().removeChannel(this.issuesRealtimeChannel);
-            }
-            catch {
-                // Best-effort
-            }
-            this.issuesRealtimeChannel = null;
-        }
-        // Kill all active issue workers gracefully
-        for (const [issueId, worker] of this.activeWorkers) {
-            logInfo(`Stopping worker for issue: ${issueId}`);
-            if (worker.timeoutTimer) {
-                clearTimeout(worker.timeoutTimer);
-            }
-            try {
-                worker.process.kill('SIGTERM');
-            }
-            catch {
-                // Ignore kill errors
-            }
-        }
-    }
-    async processNextIssues() {
-        try {
-            // Check if we should be processing (not paused/stopped from web dashboard)
-            if (!shouldProcess()) {
-                if (this.options.verbose) {
-                    logInfo('Processing paused by remote control');
-                }
-                return;
-            }
-            // Calculate how many more issues we can take on
-            const availableSlots = this.options.maxConcurrent - this.activeWorkers.size;
-            if (availableSlots <= 0) {
-                if (this.options.verbose) {
-                    logInfo(`All ${this.options.maxConcurrent} slots occupied, waiting...`);
-                }
-                return;
-            }
-            // Fetch ready issues across all products
-            const issues = await listAllReadyIssues(this.options.verbose);
-            if (issues.length === 0) {
-                if (this.options.verbose) {
-                    logInfo('No issues available for processing');
-                }
-                return;
-            }
-            // Filter out issues already being processed or recently failed
-            const cooldownMs = this.config.workflow.retryCooldown;
-            const newIssues = issues.filter((f) => {
-                if (this.activeWorkers.has(f.id)) {
-                    return false;
-                }
-                const state = this.processedIssues.get(f.id);
-                if (state?.status === 'failed') {
-                    // Allow retry if issue was updated after our last attempt (user intervention)
-                    if (f.updated_at && new Date(f.updated_at) > state.lastAttempt) {
-                        return true;
-                    }
-                    // Skip if max retries exceeded
-                    if (state.retryCount >= this.options.maxRetries) {
-                        return false;
-                    }
-                    // Skip if within cooldown period
-                    if (Date.now() - state.lastAttempt.getTime() < cooldownMs) {
-                        return false;
-                    }
-                }
-                return true;
-            });
-            if (newIssues.length === 0) {
-                // Log skipped issues for debugging
-                const skippedCount = issues.filter((f) => {
-                    const state = this.processedIssues.get(f.id);
-                    return (state?.status === 'failed' &&
-                        state.retryCount >= this.options.maxRetries);
-                }).length;
-                if (skippedCount > 0) {
-                    logInfo(`${skippedCount} issue(s) skipped (max retries exceeded)`);
-                }
-                if (this.options.verbose) {
-                    logInfo('No issues available for processing');
-                }
-                return;
-            }
-            // Pick issues up to available slots
-            const toProcess = newIssues.slice(0, availableSlots);
-            // Start processing each issue concurrently
-            for (const issue of toProcess) {
-                this.startIssueWorker(issue).catch((error) => {
-                    logError(`Failed to start worker for ${issue.name}: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }
-        }
-        catch (error) {
-            logError(`Failed to process issues: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Start a child process worker for a single issue.
-     * Handles: atomic claim, GitHub config lookup, repo cloning, then forks
-     * the worker.
-     *
-     * The candidate `issue` here comes from the listed ready_for_ai pool but is
-     * advisory — between list time and claim time another agent (or another
-     * process) may have grabbed it. We re-claim atomically per product. The
-     * RPC returns whichever ready issue is next in that product (most often
-     * the same one we listed, but not guaranteed); we operate on what claim
-     * actually returns. If claim returns null, someone else won the race —
-     * skip this slot for this cycle.
-     */
-    async startIssueWorker(candidate) {
-        // In-process dedup runs BEFORE the claim. If we already have a worker
-        // for the listed candidate, skipping here avoids successfully claiming
-        // an issue we'd then refuse to start — which would leave it stuck at
-        // assigned_to_ai with no worker (an orphan, since the claim has no
-        // release path). Cross-process races are still handled by the DB.
-        if (this.activeWorkers.has(candidate.id)) {
-            return;
-        }
-        // Atomic claim transitions ready_for_ai → assigned_to_ai inside the RPC
-        // (FOR UPDATE SKIP LOCKED), so concurrent workers never share the same
-        // issue. Scoped to the candidate's product so a race within one product
-        // resolves locally instead of pulling work from elsewhere.
-        const claimResult = await claimNextIssue(candidate.product_id, this.options.verbose);
-        if (!claimResult) {
-            if (this.options.verbose) {
-                logInfo(`No claimable issue in product ${candidate.product_name ?? candidate.product_id} (raced or no longer ready)`);
-            }
-            return;
-        }
-        const issue = {
-            ...claimResult,
-            product_name: candidate.product_name,
-        };
-        const issueId = issue.id;
-        // Update state to processing
-        this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createProcessingState(issueId, currentState));
-        logInfo(`Processing issue: ${issue.name}`);
-        if (issue.product_name) {
-            logInfo(`  Product: ${issue.product_name}`);
-        }
-        // Send heartbeat with current issue info
-        await sendHeartbeat(issueId, issue.name);
-        try {
-            // Step 1: Get GitHub config for this issue
-            const githubConfig = await getGitHubConfig(issueId, this.options.verbose);
-            if (!githubConfig.configured ||
-                !githubConfig.token ||
-                !githubConfig.owner ||
-                !githubConfig.repo) {
-                logWarning(`GitHub not configured for issue: ${issue.name}. ${githubConfig.message || ''}`);
-                this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
-                await this.releaseClaim(issueId, issue.name);
-                return;
-            }
-            // Step 2: Clone or reuse repo
-            const { repoPath, freshClone } = cloneIssueRepo(this.options.workspaceRoot, issueId, githubConfig.owner, githubConfig.repo, githubConfig.token);
-            logInfo(`Repo: ${repoPath} (${freshClone ? 'fresh clone' : 'reused'})`);
-            // Step 3: Fork a worker process to run the issue workflow
-            // The worker runs with cwd set to the repo path, so each issue
-            // has its own isolated working directory.
-            const worker = fork(WORKER_SCRIPT, [], {
-                cwd: repoPath,
-                stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
-                env: {
-                    ...process.env,
-                    EDSGER_ISSUE_ID: issueId,
-                },
-            });
-            // Track the active worker
-            const activeWorker = {
-                process: worker,
-                issueId,
-                issueName: issue.name,
-                startedAt: new Date(),
-            };
-            this.activeWorkers.set(issueId, activeWorker);
-            logInfo(`Worker spawned for issue: ${issue.name} (pid: ${worker.pid})`);
-            // Forward worker stdout/stderr to parent logs
-            worker.stdout?.on('data', (data) => {
-                const lines = data.toString().trim().split('\n');
-                for (const line of lines) {
-                    if (line) {
-                        logInfo(`  [${issue.name}] ${line}`);
-                    }
-                }
-            });
-            worker.stderr?.on('data', (data) => {
-                const lines = data.toString().trim().split('\n');
-                for (const line of lines) {
-                    if (line) {
-                        logError(`  [${issue.name}] ${line}`);
-                    }
-                }
-            });
-            // Track whether we received a result message (to detect crashes)
-            let resultReceived = false;
-            // Handle worker IPC messages
-            worker.on('message', (msg) => {
-                if (msg.type === 'log') {
-                    const prefix = `[${issue.name}]`;
-                    switch (msg.level) {
-                        case 'info':
-                            logInfo(`  ${prefix} ${msg.message}`);
-                            break;
-                        case 'warning':
-                            logWarning(`  ${prefix} ${msg.message}`);
-                            break;
-                        case 'error':
-                            logError(`  ${prefix} ${msg.message}`);
-                            break;
-                        case 'success':
-                            logSuccess(`  ${prefix} ${msg.message}`);
-                            break;
-                        case undefined:
-                        default:
-                            break;
-                    }
-                }
-                else if (msg.type === 'result') {
-                    resultReceived = true;
-                    this.handleWorkerResult(issueId, issue.name, msg.success ?? false, msg.error);
-                }
-            });
-            // Handle worker exit (crash, killed, etc.)
-            worker.on('exit', (code) => {
-                // Clear timeout timer
-                const w = this.activeWorkers.get(issueId);
-                if (w?.timeoutTimer) {
-                    clearTimeout(w.timeoutTimer);
-                }
-                this.activeWorkers.delete(issueId);
-                // If the worker exited without sending a result message, treat as failure
-                if (!resultReceived) {
-                    if (code !== 0) {
-                        logError(`Worker for ${issue.name} exited with code ${code}`);
-                    }
-                    this.handleWorkerResult(issueId, issue.name, false, `Worker exited with code ${code}`);
-                }
-            });
-            // Set up worker timeout
-            const { workerTimeout } = this.config.workflow;
-            activeWorker.timeoutTimer = setTimeout(() => {
-                logError(`Worker for ${issue.name} timed out after ${Math.round(workerTimeout / 1000)}s, killing...`);
-                try {
-                    worker.kill('SIGTERM');
-                    // Force kill after 10s if SIGTERM didn't work
-                    setTimeout(() => {
-                        try {
-                            worker.kill('SIGKILL');
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                    }, 10_000);
-                }
-                catch {
-                    // Worker may already be dead
-                }
-                const err = new WorkerTimeoutError(issueId, workerTimeout);
-                this.handleWorkerResult(issueId, issue.name, false, err.message);
-            }, workerTimeout);
-            // Send start message to worker
-            worker.send({
-                type: 'start',
-                issueId,
-                verbose: this.options.verbose,
-                config: this.config,
-            });
-        }
-        catch (error) {
-            this.activeWorkers.delete(issueId);
-            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
-            logError(`Issue error: ${issue.name} - ${error instanceof Error ? error.message : String(error)}`);
-            await this.releaseClaim(issueId, issue.name);
-        }
-    }
-    /**
-     * After a successful claim moved the issue ready_for_ai → assigned_to_ai,
-     * any post-claim setup failure (GitHub config, clone, fork) leaves the
-     * issue stuck at assigned_to_ai with no worker — an orphan that the user
-     * can't fix from the UI. Push it forward to 'failed' so it shows up in
-     * the failed bucket and can be inspected / re-set to ready_for_ai by a
-     * human.
-     *
-     * Status guard: only force-progress if the issue is still at
-     * assigned_to_ai or in_progress. A worker may have already advanced the
-     * status to shipped / failed via a separate code path before we got the
-     * non-success IPC signal; clobbering those would lose real outcome data.
-     * STATUS_PROGRESSION_ORDER classifies shipped→failed as a forward move
-     * (so updateIssueStatus wouldn't reject it), which is why this guard
-     * lives here rather than at the RPC layer.
-     *
-     * Errors are swallowed: if the status fetch or update fails the issue
-     * stays orphaned but logging is the most we can do here.
-     */
-    async releaseClaim(issueId, issueName) {
-        try {
-            const current = await getIssue(issueId, false);
-            if (current.status !== 'assigned_to_ai' &&
-                current.status !== 'in_progress') {
-                return;
-            }
-            await callMcpEndpoint('issues/update', {
-                issue_id: issueId,
-                status: 'failed',
-            });
-        }
-        catch (releaseError) {
-            logWarning(`Failed to release claim on ${issueName} (${issueId}); issue may be orphaned at assigned_to_ai: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`);
-        }
-    }
-    handleWorkerResult(issueId, issueName, success, error) {
-        if (success) {
-            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createCompletedState(issueId, currentState));
-            logSuccess(`Issue completed: ${issueName}`);
-            // Narrate completion into the issue chat (served by `edsger chat-serve`).
-            this.narrateToIssueChat(issueId, 'All workflow phases completed.', {
-                status: 'issue_done',
-            });
-            // Clean up the per-issue clone now that the workflow is finished.
-            // Failures intentionally leave the workspace so the user (or a retry)
-            // can inspect the partial state.
-            cleanupIssueRepo(getIssueRepoPath(this.options.workspaceRoot, issueId));
-        }
-        else {
-            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
-            logError(`Issue failed: ${issueName}${error ? ` - ${error}` : ''}`);
-            // No releaseClaim here: this path runs after the worker reported a
-            // non-success result, but the worker may still have been mid-way
-            // through writing its own status (e.g. setting 'shipped' or 'failed'
-            // before exiting). A read-then-write release would race with the
-            // worker's final DB write. Worker code is responsible for advancing
-            // the lifecycle status before it exits; a worker that crashes
-            // without doing so leaves the issue at assigned_to_ai, which is a
-            // separate, pre-existing orphan class outside the scope of the
-            // pre-fork cleanup that releaseClaim handles.
-            // Only narrate on first failure to avoid flooding with duplicate messages.
-            const failedState = this.processedIssues.get(issueId);
-            if (failedState && failedState.retryCount <= 1) {
-                this.narrateToIssueChat(issueId, `Phase "workflow" failed: ${error || 'Unknown error'}`, { phase: 'workflow', status: 'failed', error: error || 'Unknown error' });
-            }
-        }
-        // Clear heartbeat issue info
-        sendHeartbeat().catch(() => {
-            /* noop */
-        });
-    }
-    getStats() {
-        return calculateStats(this.processedIssues, this.isRunning);
-    }
-    getActiveWorkerCount() {
-        return this.activeWorkers.size;
-    }
-}

package/dist/commands/analyze-logs/index.d.ts

@@ -1,7 +0,0 @@
-import { type CliOptions } from '../../types/index.js';
-/**
- * Run AI-powered log analysis for a product.
- * Analyzes pending user logs (inactive >1 hour) and creates
- * product feedback for any issues or improvements found.
- */
-export declare const runAnalyzeLogs: (options: CliOptions) => Promise<void>;

package/dist/commands/analyze-logs/index.js

@@ -1,34 +0,0 @@
-import { analyzeLogs } from '../../phases/analyze-logs/index.js';
-import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-/**
- * Run AI-powered log analysis for a product.
- * Analyzes pending user logs (inactive >1 hour) and creates
- * product feedback for any issues or improvements found.
- */
-export const runAnalyzeLogs = async (options) => {
-    const productId = options.analyzeLogs;
-    if (!productId) {
-        throw new Error('Product ID is required for log analysis');
-    }
-    logInfo(`Starting log analysis for product: ${productId}`);
-    try {
-        const result = await analyzeLogs({
-            productId,
-            verbose: options.verbose,
-        });
-        if (result.status === 'success') {
-            logSuccess('Log analysis completed!');
-            logInfo(`  Groups processed: ${result.groupsProcessed}`);
-            logInfo(`  Feedbacks created: ${result.feedbacksCreated}`);
-            logInfo(`  Logs analyzed: ${result.logsAnalyzed}`);
-        }
-        else {
-            logError(`Log analysis failed: ${result.summary}`);
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        logError(`Log analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
-    }
-};

package/dist/commands/api-docs/index.d.ts

@@ -1,18 +0,0 @@
-/**
- * CLI command: edsger api-docs <productId> --run-id <id>
- *               edsger api-docs --repo-id <id> --run-id <id>
- *
- * Clones the repository, asks Claude to determine its API surface, and persists
- * a generated API reference (Markdown + optional OpenAPI document) onto the
- * pending api_doc_runs row. The desktop UI creates the pending row first then
- * invokes the CLI with --run-id; the CLI flips status running →
- * success/failed and writes the artifact via the api-docs MCP toolkit.
- */
-export interface ApiDocsCliOptions {
-    runId: string;
-    /** Repo-only mode: generate for a single repositories row, no product. */
-    repoId?: string;
-    guidance?: string;
-    verbose?: boolean;
-}
-export declare function runApiDocs(productId: string | undefined, options: ApiDocsCliOptions): Promise<void>;