edsger 0.76.0 → 0.78.0

package/dist/commands/agent-workflow/chat-worker.js

@@ -1,465 +0,0 @@
-/**
- * Chat Worker — Child process entry point for processing chat messages.
- *
- * Spawned by AgentWorkflowProcessor as a parallel subprocess alongside issue workers.
- * Runs continuously, polling for unprocessed human messages across all active issue channels.
- *
- * Communication with parent via IPC:
- * - Parent sends: { type: 'init', config }
- * - Parent sends: { type: 'event:phase_completed', issueId, phase, summary, phaseOutput }
- * - Parent sends: { type: 'event:phase_failed', issueId, phase, error }
- * - Parent sends: { type: 'event:issue_done', issueId }
- * - Worker sends: { type: 'log', level, message }
- * - Worker sends: { type: 'command:pause_issue', issueId }
- * - Worker sends: { type: 'command:resume_issue', issueId }
- */
-import { randomUUID } from 'node:crypto';
-import { claimPendingMessages, getIssueChannel, listChannels, sendSystemMessage, } from '../../api/chat.js';
-import { processHumanMessages, processPhaseCompletion, processProductHumanMessages, } from '../../phases/chat-processor/index.js';
-import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
-function sendMessage(msg) {
-    if (process.send) {
-        process.send(msg);
-    }
-}
-function log(level, message) {
-    sendMessage({ type: 'log', level, message });
-}
-// ============================================================
-// State
-// ============================================================
-let config = null;
-let verbose = false;
-let isRunning = false;
-let pollTimer = null;
-// Unique worker ID for this process instance — used for atomic message claiming
-const WORKER_ID = `chat-worker-${process.pid}-${randomUUID().slice(0, 8)}`;
-// Track active issue channels (issueId -> channelId)
-const activeChannels = new Map();
-// Track active product channels (productId -> channelId)
-const activeProductChannels = new Map();
-const channelMetaById = new Map();
-// Track issue repo paths (issueId -> repoPath) for setting cwd on AI agent
-const issueRepoPaths = new Map();
-// Active Realtime channel — set when the Supabase session is available.
-let realtimeChannel = null;
-// Fallback poll interval (legacy path when no Supabase session — desktop-app
-// not yet rolled out / standalone CLI). Realtime path needs no timer.
-const POLL_INTERVAL = 5000;
-// In the legacy poll path: refresh the channel list every N polls (~30s).
-// The Realtime path discovers new channels via the chat_channels
-// subscription, so this constant is unused there.
-const CHANNEL_REFRESH_INTERVAL = 6;
-let pollCount = 0;
-// ============================================================
-// Message Polling Loop
-// ============================================================
-async function pollForMessages() {
-    if (!config || !isRunning) {
-        return;
-    }
-    // Periodically refresh the channel list to pick up newly created channels
-    pollCount++;
-    if (pollCount % CHANNEL_REFRESH_INTERVAL === 0) {
-        await refreshChannels();
-    }
-    // Poll issue channels
-    for (const [issueId, channelId] of activeChannels) {
-        try {
-            const claimed = await claimPendingMessages(channelId, WORKER_ID);
-            if (claimed.length > 0) {
-                log('info', `Claimed ${claimed.length} message(s) for issue ${issueId} (worker: ${WORKER_ID})`);
-                const repoPath = issueRepoPaths.get(issueId);
-                await processHumanMessages(claimed, issueId, config, verbose, repoPath);
-            }
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            log('error', `Error polling issue channel ${channelId}: ${msg}`);
-        }
-    }
-    // Poll product channels
-    for (const [productId, channelId] of activeProductChannels) {
-        try {
-            const claimed = await claimPendingMessages(channelId, WORKER_ID);
-            if (claimed.length > 0) {
-                log('info', `Claimed ${claimed.length} message(s) for product ${productId} (worker: ${WORKER_ID})`);
-                await processProductHumanMessages(claimed, productId, config, verbose);
-            }
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            log('error', `Error polling product channel ${channelId}: ${msg}`);
-        }
-    }
-}
-function startPolling() {
-    if (pollTimer) {
-        return;
-    }
-    isRunning = true;
-    log('info', 'Chat worker started polling (MCP fallback path)');
-    // Initial poll
-    pollForMessages().catch((error) => {
-        log('error', `Initial poll error: ${error instanceof Error ? error.message : String(error)}`);
-    });
-    // Set up interval
-    pollTimer = setInterval(() => {
-        pollForMessages().catch((error) => {
-            log('error', `Poll error: ${error instanceof Error ? error.message : String(error)}`);
-        });
-    }, POLL_INTERVAL);
-}
-function stopPolling() {
-    isRunning = false;
-    if (pollTimer) {
-        clearInterval(pollTimer);
-        pollTimer = null;
-    }
-    stopRealtime();
-    log('info', 'Chat worker stopped');
-}
-// ============================================================
-// Event Handlers
-// ============================================================
-async function handleInit(msg) {
-    ;
-    ({ config } = msg);
-    verbose = msg.verbose ?? false;
-    log('info', `Chat worker initialized (id: ${WORKER_ID})`);
-    // Seed the channel cache before subscriptions/polling so dispatch knows
-    // which kind (issue vs product) a chat_messages event belongs to.
-    await refreshChannels();
-    // Drain any messages that landed while we were offline.
-    isRunning = true;
-    for (const channelId of channelMetaById.keys()) {
-        void claimAndProcess(channelId);
-    }
-    // Prefer Realtime over polling when the Supabase session is available —
-    // eliminates the 5s/N-channel polling load entirely.
-    if (startRealtime()) {
-        log('info', 'Chat worker running in Realtime mode');
-        return;
-    }
-    log('info', 'No Supabase session — chat worker falling back to MCP polling mode');
-    startPolling();
-}
-async function handlePhaseCompleted(msg) {
-    if (!config) {
-        return;
-    }
-    const { issueId, phase, summary, phaseOutput } = msg;
-    log('info', `Phase completed: ${phase} for issue ${issueId}`);
-    try {
-        // Ensure we have the channel registered
-        await ensureIssueChannel(issueId);
-        // Process with AI for next-step suggestions
-        const repoPath = issueRepoPaths.get(issueId);
-        await processPhaseCompletion({
-            issueId,
-            phase,
-            summary,
-            phaseOutput,
-            config,
-            verbose,
-            repoPath,
-        });
-    }
-    catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        log('error', `Failed to process phase completion: ${errorMsg}`);
-    }
-}
-async function handlePhaseFailed(msg) {
-    const { issueId, phase, error: errorStr } = msg;
-    log('warning', `Phase failed: ${phase} for issue ${issueId}`);
-    try {
-        await ensureIssueChannel(issueId);
-        const channelId = activeChannels.get(issueId);
-        if (channelId) {
-            await sendSystemMessage(channelId, `Phase "${phase}" failed: ${errorStr}`, { phase, status: 'failed', error: errorStr });
-        }
-    }
-    catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        log('error', `Failed to send phase failure message: ${errorMsg}`);
-    }
-}
-async function handleIssueDone(msg) {
-    const { issueId } = msg;
-    log('info', `Issue done: ${issueId}`);
-    try {
-        const channelId = activeChannels.get(issueId);
-        if (channelId) {
-            await sendSystemMessage(channelId, 'All workflow phases completed.', {
-                status: 'issue_done',
-            });
-        }
-    }
-    catch (_error) {
-        // Non-critical
-    }
-    // Keep the channel in activeChannels so we can still process messages
-}
-// ============================================================
-// Channel Management
-// ============================================================
-/**
- * Refresh the active channels list from the server.
- * Called on init (and, in the legacy poll path, periodically) to discover
- * newly created channels. In the Realtime path the chat_channels INSERT
- * subscription keeps the map fresh; refreshChannels is still called once at
- * startup to seed it.
- */
-async function refreshChannels() {
-    try {
-        // Fetch issue and product channels in parallel
-        const [issueChannels, productChannels] = await Promise.all([
-            listChannels('issue'),
-            listChannels('product'),
-        ]);
-        let added = 0;
-        for (const channel of issueChannels) {
-            if (channel.channel_ref_id) {
-                if (!activeChannels.has(channel.channel_ref_id)) {
-                    activeChannels.set(channel.channel_ref_id, channel.id);
-                    added++;
-                }
-                channelMetaById.set(channel.id, {
-                    kind: 'issue',
-                    refId: channel.channel_ref_id,
-                });
-            }
-        }
-        for (const channel of productChannels) {
-            if (channel.channel_ref_id) {
-                if (!activeProductChannels.has(channel.channel_ref_id)) {
-                    activeProductChannels.set(channel.channel_ref_id, channel.id);
-                    added++;
-                }
-                channelMetaById.set(channel.id, {
-                    kind: 'product',
-                    refId: channel.channel_ref_id,
-                });
-            }
-        }
-        if (added > 0) {
-            log('info', `Discovered ${added} new channel(s) (issues: ${activeChannels.size}, products: ${activeProductChannels.size})`);
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        log('error', `Failed to refresh channels: ${msg}`);
-    }
-}
-/** Register a newly-discovered channel (typically from a Realtime event). */
-function registerChannel(channel) {
-    if (!channel.channel_ref_id) {
-        return;
-    }
-    if (channel.channel_type === 'issue') {
-        if (!activeChannels.has(channel.channel_ref_id)) {
-            activeChannels.set(channel.channel_ref_id, channel.id);
-            log('info', `New issue channel discovered: ${channel.channel_ref_id} (${channel.id})`);
-        }
-        channelMetaById.set(channel.id, {
-            kind: 'issue',
-            refId: channel.channel_ref_id,
-        });
-    }
-    else if (channel.channel_type === 'product') {
-        if (!activeProductChannels.has(channel.channel_ref_id)) {
-            activeProductChannels.set(channel.channel_ref_id, channel.id);
-            log('info', `New product channel discovered: ${channel.channel_ref_id} (${channel.id})`);
-        }
-        channelMetaById.set(channel.id, {
-            kind: 'product',
-            refId: channel.channel_ref_id,
-        });
-    }
-}
-/**
- * Dispatch claim+process for a single channel. Called both from Realtime
- * INSERT events on chat_messages and (in the legacy path) from the poll loop.
- */
-async function claimAndProcess(channelId) {
-    if (!config) {
-        return;
-    }
-    const meta = channelMetaById.get(channelId);
-    if (!meta) {
-        // Unknown channel — could be a fresh channel we haven't seeded yet.
-        // Skip rather than fetch synchronously; the chat_channels INSERT
-        // subscription will populate it momentarily and the next message event
-        // will pick it up.
-        return;
-    }
-    try {
-        const claimed = await claimPendingMessages(channelId, WORKER_ID);
-        if (claimed.length === 0) {
-            return;
-        }
-        if (meta.kind === 'issue') {
-            log('info', `Claimed ${claimed.length} message(s) for issue ${meta.refId} (worker: ${WORKER_ID})`);
-            const repoPath = issueRepoPaths.get(meta.refId);
-            await processHumanMessages(claimed, meta.refId, config, verbose, repoPath);
-        }
-        else {
-            log('info', `Claimed ${claimed.length} message(s) for product ${meta.refId} (worker: ${WORKER_ID})`);
-            await processProductHumanMessages(claimed, meta.refId, config, verbose);
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        log('error', `Error processing channel ${channelId}: ${msg}`);
-    }
-}
-/**
- * Bring up the Realtime subscription. Listens for:
- *   - chat_messages INSERT (sender_type=human) → claim+process on that channel
- *   - chat_channels INSERT → register newly-created channels
- *
- * Returns true if the subscription was successfully started.
- */
-function startRealtime() {
-    if (realtimeChannel) {
-        return true;
-    }
-    if (!hasSupabaseSession()) {
-        return false;
-    }
-    try {
-        const supabase = getSupabase();
-        realtimeChannel = supabase
-            .channel('chat-worker', { config: { broadcast: { ack: false } } })
-            .on('postgres_changes', {
-            event: 'INSERT',
-            schema: 'public',
-            table: 'chat_messages',
-            filter: 'sender_type=eq.human',
-        }, (payload) => {
-            // RLS filters out events from channels the user isn't in, so any
-            // event reaching us belongs to a channel we have access to.
-            const row = payload.new;
-            if (!row.channel_id || row.is_processed) {
-                return;
-            }
-            void claimAndProcess(row.channel_id);
-        })
-            .on('postgres_changes', {
-            event: 'INSERT',
-            schema: 'public',
-            table: 'chat_channels',
-        }, (payload) => {
-            registerChannel(payload.new);
-            // A channel created with messages already in it (unlikely but
-            // possible if INSERTs race) deserves an immediate sweep.
-            const { id } = payload.new;
-            if (id) {
-                void claimAndProcess(id);
-            }
-        })
-            .subscribe((status) => {
-            if (status === 'SUBSCRIBED') {
-                log('info', 'Realtime subscription active (chat_messages, chat_channels)');
-            }
-            else if (status === 'CHANNEL_ERROR' ||
-                status === 'TIMED_OUT' ||
-                status === 'CLOSED') {
-                log('warning', `Realtime channel status: ${status}`);
-                // supabase-js auto-reconnects; no manual reschedule needed here.
-            }
-        });
-        return true;
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        log('error', `Failed to start Realtime subscription: ${msg}`);
-        return false;
-    }
-}
-function stopRealtime() {
-    if (!realtimeChannel) {
-        return;
-    }
-    try {
-        void getSupabase().removeChannel(realtimeChannel);
-    }
-    catch {
-        // Best-effort; supabase may already be torn down.
-    }
-    realtimeChannel = null;
-}
-async function ensureIssueChannel(issueId) {
-    const cachedChannel = activeChannels.get(issueId);
-    if (cachedChannel) {
-        return cachedChannel;
-    }
-    try {
-        const channel = await getIssueChannel(issueId);
-        activeChannels.set(issueId, channel.id);
-        channelMetaById.set(channel.id, { kind: 'issue', refId: issueId });
-        log('info', `Registered channel ${channel.id} for issue ${issueId}`);
-        return channel.id;
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        log('error', `Failed to get channel for issue ${issueId}: ${msg}`);
-        throw error;
-    }
-}
-// ============================================================
-// Main IPC Listener
-// ============================================================
-process.on('message', (msg) => {
-    switch (msg.type) {
-        case 'init':
-            handleInit(msg).catch((error) => {
-                log('error', `Init error: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            break;
-        case 'event:phase_completed':
-            handlePhaseCompleted(msg).catch((error) => {
-                log('error', `Phase event error: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            break;
-        case 'event:phase_failed':
-            handlePhaseFailed(msg).catch((error) => {
-                log('error', `Phase fail event error: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            break;
-        case 'event:issue_done':
-            handleIssueDone(msg).catch((error) => {
-                log('error', `Issue done event error: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            break;
-        // Register an issue channel for polling when a worker starts
-        case 'event:issue_started': {
-            const startMsg = msg;
-            if (startMsg.repoPath) {
-                issueRepoPaths.set(startMsg.issueId, startMsg.repoPath);
-            }
-            ensureIssueChannel(startMsg.issueId).catch((error) => {
-                log('error', `Channel registration error: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            break;
-        }
-        default:
-            log('warning', `Unknown message type: ${msg.type}`);
-    }
-});
-// Handle graceful shutdown
-process.on('SIGTERM', () => {
-    stopPolling();
-    process.exit(0);
-});
-process.on('SIGINT', () => {
-    stopPolling();
-    process.exit(0);
-});
-// Handle uncaught errors
-process.on('uncaughtException', (error) => {
-    log('error', `Uncaught exception: ${error.message}`);
-    stopPolling();
-    process.exit(1);
-});

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

@@ -1,13 +0,0 @@
-/**
- * Agent Workflow - New default workflow mode
- *
- * This is the new cross-product workflow that:
- * 1. Uses stored auth from `edsger login` (no per-repo env config needed)
- * 2. Fetches ready_for_ai issues across ALL products
- * 3. Clones repos using GitHub App installation tokens
- * 4. Manages workspace directories with issue ID naming
- * 5. Runs continuously with auto-update, sleep prevention, and session management
- * 6. Responds to web dashboard commands (pause/resume/stop)
- */
-import { type CliOptions } from '../../types/index.js';
-export declare function runAgentWorkflow(options: CliOptions): Promise<void>;

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

@@ -1,107 +0,0 @@
-/**
- * Agent Workflow - New default workflow mode
- *
- * This is the new cross-product workflow that:
- * 1. Uses stored auth from `edsger login` (no per-repo env config needed)
- * 2. Fetches ready_for_ai issues across ALL products
- * 3. Clones repos using GitHub App installation tokens
- * 4. Manages workspace directories with issue ID naming
- * 5. Runs continuously with auto-update, sleep prevention, and session management
- * 6. Responds to web dashboard commands (pause/resume/stop)
- */
-import { isLoggedIn } from '../../auth/auth-store.js';
-import { getVersion } from '../../constants.js';
-import { deregisterSession, registerSession, startHeartbeat, stopHeartbeat, } from '../../system/session-manager.js';
-import { startSleepMonitor, stopSleepMonitor, } from '../../system/sleep-notification.js';
-import { startSleepPrevention, stopSleepPrevention, } from '../../system/sleep-prevention.js';
-import { startAutoUpdateChecker, stopAutoUpdateChecker, } from '../../updater/auto-updater.js';
-import { logError, logInfo, logRaw, logSuccess, logWarning, } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
-import { ensureWorkspaceDir } from '../../workspace/workspace-manager.js';
-import { AgentWorkflowProcessor, MAX_CONCURRENCY } from './processor.js';
-export async function runAgentWorkflow(options) {
-    // Verify authentication
-    if (!isLoggedIn()) {
-        logError('Not authenticated. Please run `edsger login` first.');
-        process.exit(1);
-    }
-    const config = validateConfiguration(options);
-    const version = getVersion();
-    logRaw('');
-    logInfo(`Edsger Agent v${version}`);
-    logInfo('Cross-product workflow mode');
-    logRaw('');
-    // Set up workspace directory
-    const workspaceRoot = ensureWorkspaceDir();
-    logInfo(`Workspace: ${workspaceRoot}`);
-    // Register CLI session with server
-    const sessionId = await registerSession({ command: 'agent-workflow' });
-    logInfo(`Session: ${sessionId}`);
-    // Start auto-update checker
-    startAutoUpdateChecker();
-    // Start sleep prevention
-    startSleepPrevention();
-    startSleepMonitor();
-    // Start heartbeat
-    startHeartbeat();
-    logRaw('');
-    logSuccess('Agent started. Watching for issues...');
-    logRaw('');
-    // Create and start the processor
-    let maxConcurrent = 3;
-    if (options.concurrency && options.concurrency > 0) {
-        maxConcurrent = Math.min(options.concurrency, MAX_CONCURRENCY);
-        if (options.concurrency > MAX_CONCURRENCY) {
-            logWarning(`Concurrency capped at ${MAX_CONCURRENCY} (requested ${options.concurrency}). ` +
-                `Higher values risk API rate limits, memory exhaustion, and GitHub throttling.`);
-        }
-    }
-    const processor = new AgentWorkflowProcessor({
-        workspaceRoot,
-        pollInterval: 30_000,
-        maxConcurrent,
-        maxRetries: 3,
-        verbose: options.verbose,
-    }, config);
-    try {
-        await processor.start();
-        // Handle graceful shutdown
-        const cleanup = async () => {
-            logInfo('\nShutting down...');
-            processor.stop();
-            // Show stats
-            const stats = processor.getStats();
-            logRaw('');
-            logInfo('Session Statistics:');
-            logInfo(`  Total processed: ${stats.totalProcessed}`);
-            logInfo(`  Completed: ${stats.completed}`);
-            logInfo(`  Failed: ${stats.failed}`);
-            logInfo(`  Processing: ${stats.processing}`);
-            // Cleanup
-            stopAutoUpdateChecker();
-            stopSleepPrevention();
-            stopSleepMonitor();
-            stopHeartbeat();
-            await deregisterSession();
-            logSuccess('Agent stopped gracefully');
-            process.exit(0);
-        };
-        process.on('SIGINT', () => {
-            void cleanup();
-        });
-        process.on('SIGTERM', () => {
-            void cleanup();
-        });
-        // Keep the process running
-        process.stdin.resume();
-    }
-    catch (error) {
-        logError(`Agent workflow failed: ${error instanceof Error ? error.message : String(error)}`);
-        stopAutoUpdateChecker();
-        stopSleepPrevention();
-        stopSleepMonitor();
-        stopHeartbeat();
-        await deregisterSession();
-        process.exit(1);
-    }
-}

package/dist/commands/agent-workflow/issue-worker.d.ts

@@ -1,14 +0,0 @@
-/**
- * Issue Worker - Child process entry point for processing a single issue
- *
- * This file is spawned by the parent AgentWorkflowProcessor via child_process.fork().
- * Each worker runs in its own process with its own cwd, which:
- * 1. Allows concurrent issue processing (no shared process.chdir())
- * 2. After auto-update, new workers load the latest code from disk
- *
- * Communication with parent via IPC messages:
- * - Parent sends: { type: 'start', issueId, verbose, config }
- * - Worker sends: { type: 'result', success: boolean, issueId }
- * - Worker sends: { type: 'log', level, message } for logging
- */
-export {};

package/dist/commands/agent-workflow/issue-worker.js

@@ -1,65 +0,0 @@
-/**
- * Issue Worker - Child process entry point for processing a single issue
- *
- * This file is spawned by the parent AgentWorkflowProcessor via child_process.fork().
- * Each worker runs in its own process with its own cwd, which:
- * 1. Allows concurrent issue processing (no shared process.chdir())
- * 2. After auto-update, new workers load the latest code from disk
- *
- * Communication with parent via IPC messages:
- * - Parent sends: { type: 'start', issueId, verbose, config }
- * - Worker sends: { type: 'result', success: boolean, issueId }
- * - Worker sends: { type: 'log', level, message } for logging
- */
-import { evaluatePipelineResults } from '../workflow/core/pipeline-evaluator.js';
-import { runIssueWorkflow } from '../workflow/issue-coordinator.js';
-function sendMessage(msg) {
-    if (process.send) {
-        process.send(msg);
-    }
-}
-function log(level, message) {
-    sendMessage({ type: 'log', level, message });
-}
-async function handleStart(msg) {
-    const { issueId, verbose, config } = msg;
-    try {
-        log('info', `Worker started for issue: ${issueId}`);
-        const results = await runIssueWorkflow({ issueId, verbose }, config);
-        const allSuccessful = evaluatePipelineResults(results);
-        sendMessage({
-            type: 'result',
-            issueId,
-            success: allSuccessful,
-        });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log('error', `Worker error for issue ${issueId}: ${errorMessage}`);
-        sendMessage({
-            type: 'result',
-            issueId,
-            success: false,
-            error: errorMessage,
-        });
-    }
-}
-// Listen for messages from parent
-process.on('message', (msg) => {
-    if (msg.type === 'start') {
-        void handleStart(msg).finally(() => {
-            // Exit worker process after completion
-            process.exit(0);
-        });
-    }
-});
-// Handle uncaught errors
-process.on('uncaughtException', (error) => {
-    sendMessage({
-        type: 'result',
-        issueId: 'unknown',
-        success: false,
-        error: `Uncaught exception: ${error.message}`,
-    });
-    process.exit(1);
-});