@cmdctrl/aider 0.1.0

package/dist/adapter/agentapi.d.ts

@@ -0,0 +1,100 @@
+export interface QuestionOption {
+    label: string;
+    description?: string;
+}
+type EventCallback = (taskId: string, eventType: string, data: Record<string, unknown>) => void;
+export declare class AiderAdapter {
+    private running;
+    private sessionIdToTaskId;
+    private onEvent;
+    private nextPort;
+    constructor(onEvent: EventCallback);
+    /**
+     * Get next available port for AgentAPI
+     */
+    private getNextPort;
+    /**
+     * Start a new task by launching AgentAPI with Aider
+     */
+    startTask(taskId: string, instruction: string, projectPath?: string): Promise<void>;
+    /**
+     * Resume a task - for Aider, this just sends another message
+     */
+    resumeTask(taskId: string, sessionId: string, message: string, projectPath?: string): Promise<void>;
+    /**
+     * Cancel a running task
+     */
+    cancelTask(taskId: string): Promise<void>;
+    /**
+     * Stop all running tasks
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Get list of running task IDs
+     */
+    getRunningTasks(): string[];
+    /**
+     * Get messages for a session from AgentAPI
+     * Returns messages if the session's AgentAPI is running, null otherwise
+     * @param id - Either the canonical taskId or the generated sessionId
+     */
+    getMessages(id: string): Promise<{
+        id: number;
+        role: string;
+        content: string;
+        time: string;
+    }[] | null>;
+    /**
+     * Get the port for a running task's AgentAPI
+     */
+    getTaskPort(taskId: string): number | null;
+    /**
+     * Wait for AgentAPI server to be ready and agent to be stable
+     *
+     * AgentAPI requires the agent status to be "stable" before accepting messages.
+     * When first started, Aider may be "running" while it builds the repo map.
+     */
+    private waitForAgentApi;
+    /**
+     * Connect to AgentAPI SSE event stream
+     *
+     * AgentAPI sends named events: 'message_update' and 'status_change'
+     * We need to listen for these specifically (onmessage only handles unnamed events)
+     */
+    private connectEventStream;
+    /**
+     * Check if a message is a spinner/progress line that should be filtered
+     * These lines use \r to overwrite in terminal but create noise in our UI
+     */
+    private isSpinnerLine;
+    /**
+     * Handle message_update SSE event
+     */
+    private handleMessageUpdate;
+    /**
+     * Handle status_change SSE event
+     */
+    private handleStatusChange;
+    /**
+     * Handle an event from AgentAPI
+     */
+    private handleAgentApiEvent;
+    /**
+     * Check if content looks like a question/prompt
+     */
+    private looksLikeQuestion;
+    /**
+     * Extract the question from content
+     */
+    private extractQuestion;
+    /**
+     * Send a message to AgentAPI
+     */
+    private sendMessage;
+    /**
+     * Clean up a task
+     */
+    private cleanup;
+}
+export {};
+//# sourceMappingURL=agentapi.d.ts.map

package/dist/adapter/agentapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentapi.d.ts","sourceRoot":"","sources":["../../src/adapter/agentapi.ts"],"names":[],"mappings":"AAsFA,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,KAAK,aAAa,GAAG,CACnB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,IAAI,CAAC;AAEV,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,QAAQ,CAAiB;gBAErB,OAAO,EAAE,aAAa;IAIlC;;OAEG;IACH,OAAO,CAAC,WAAW;IAUnB;;OAEG;IACG,SAAS,CACb,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC;IAkGhB;;OAEG;IACG,UAAU,CACd,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC;IAkBhB;;OAEG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK/C;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM9B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;;;OAIG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,IAAI,CAAC;IAgC5G;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAK1C;;;;;OAKG;YACW,eAAe;IA8C7B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IA+C1B;;;OAGG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA+C3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAuD3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAmBzB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;YACW,WAAW;IAsBzB;;OAEG;IACH,OAAO,CAAC,OAAO;CAwBhB"}

package/dist/adapter/agentapi.js

@@ -0,0 +1,578 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiderAdapter = void 0;
+const pty = __importStar(require("node-pty"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const eventsource_1 = require("eventsource");
+const DEFAULT_TIMEOUT = 10 * 60 * 1000; // 10 minutes
+const AGENTAPI_PORT = 3284;
+const AGENTAPI_STARTUP_TIMEOUT = 60000; // 60 seconds to wait for agentapi to start (Aider needs time for repo map)
+// Find agentapi binary
+function findAgentApi() {
+    if (process.env.AGENTAPI_PATH) {
+        return process.env.AGENTAPI_PATH;
+    }
+    const home = os.homedir();
+    const commonPaths = [
+        path.join(home, '.local', 'bin', 'agentapi'),
+        '/usr/local/bin/agentapi',
+        '/opt/homebrew/bin/agentapi',
+        'agentapi' // Fall back to PATH
+    ];
+    for (const p of commonPaths) {
+        if (p === 'agentapi')
+            return p;
+        try {
+            if (fs.existsSync(p)) {
+                return p;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return 'agentapi';
+}
+// Find aider binary
+function findAider() {
+    if (process.env.AIDER_PATH) {
+        return process.env.AIDER_PATH;
+    }
+    const home = os.homedir();
+    const commonPaths = [
+        path.join(home, '.local', 'bin', 'aider'),
+        '/usr/local/bin/aider',
+        '/opt/homebrew/bin/aider',
+        'aider' // Fall back to PATH
+    ];
+    for (const p of commonPaths) {
+        if (p === 'aider')
+            return p;
+        try {
+            if (fs.existsSync(p)) {
+                return p;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return 'aider';
+}
+const AGENTAPI_PATH = findAgentApi();
+const AIDER_PATH = findAider();
+console.log(`[AiderAdapter] Using agentapi path: ${AGENTAPI_PATH}`);
+console.log(`[AiderAdapter] Using aider path: ${AIDER_PATH}`);
+class AiderAdapter {
+    running = new Map();
+    sessionIdToTaskId = new Map(); // Reverse mapping: sessionId -> taskId
+    onEvent;
+    nextPort = AGENTAPI_PORT;
+    constructor(onEvent) {
+        this.onEvent = onEvent;
+    }
+    /**
+     * Get next available port for AgentAPI
+     */
+    getNextPort() {
+        // Simple port allocation - in production you'd want to check if port is free
+        const port = this.nextPort;
+        this.nextPort++;
+        if (this.nextPort > AGENTAPI_PORT + 100) {
+            this.nextPort = AGENTAPI_PORT; // Wrap around
+        }
+        return port;
+    }
+    /**
+     * Start a new task by launching AgentAPI with Aider
+     */
+    async startTask(taskId, instruction, projectPath) {
+        console.log(`[${taskId}] Starting Aider task: ${instruction.substring(0, 50)}...`);
+        const port = this.getNextPort();
+        // Generate a real session ID to resolve PENDING placeholder in database
+        // This allows the backend to know the session is active and fetch messages
+        const sessionId = `aider-${crypto.randomUUID()}`;
+        const rt = {
+            taskId,
+            sessionId,
+            context: '',
+            agentApiProcess: null,
+            eventSource: null,
+            timeoutHandle: null,
+            port,
+            lastStatus: 'stable',
+            firstSpinnerEmitted: false
+        };
+        this.running.set(taskId, rt);
+        this.sessionIdToTaskId.set(sessionId, taskId); // Register reverse mapping
+        // Determine working directory
+        let cwd = os.homedir();
+        if (projectPath && fs.existsSync(projectPath)) {
+            cwd = projectPath;
+        }
+        else if (projectPath) {
+            console.log(`[${taskId}] Warning: project path does not exist: ${projectPath}`);
+            this.onEvent(taskId, 'WARNING', {
+                warning: `Project path "${projectPath}" does not exist. Running in home directory.`
+            });
+        }
+        // Build AgentAPI command
+        // agentapi server --port <port> -- aider [aider options]
+        const args = [
+            'server',
+            '--port', port.toString(),
+            '--type', 'aider',
+            '--',
+            AIDER_PATH,
+            '--yes-always' // Auto-accept changes for automation
+        ];
+        // Add model if specified in environment
+        if (process.env.AIDER_MODEL) {
+            args.push('--model', process.env.AIDER_MODEL);
+        }
+        console.log(`[${taskId}] Spawning: ${AGENTAPI_PATH} ${args.join(' ')} in ${cwd}`);
+        try {
+            // Use node-pty to spawn agentapi with a proper PTY
+            // This is required because agentapi uses terminal emulation internally
+            const proc = pty.spawn(AGENTAPI_PATH, args, {
+                name: 'xterm-color',
+                cols: 120,
+                rows: 40,
+                cwd,
+                env: process.env
+            });
+            rt.agentApiProcess = proc;
+            // Log output for debugging (PTY combines stdout/stderr)
+            proc.onData((data) => {
+                console.log(`[${taskId}] agentapi output: ${data.substring(0, 200)}`);
+            });
+            proc.onExit(({ exitCode }) => {
+                console.log(`[${taskId}] AgentAPI process exited with code ${exitCode}`);
+                this.cleanup(taskId);
+            });
+            // Wait for AgentAPI to be ready
+            await this.waitForAgentApi(taskId, port);
+            // Set up SSE event stream
+            this.connectEventStream(taskId, port, rt);
+            // Set timeout
+            rt.timeoutHandle = setTimeout(() => {
+                console.log(`[${taskId}] Task timed out`);
+                this.onEvent(taskId, 'ERROR', { error: 'execution timeout' });
+                this.cancelTask(taskId);
+            }, DEFAULT_TIMEOUT);
+            // Send the initial instruction
+            await this.sendMessage(taskId, port, instruction);
+        }
+        catch (err) {
+            console.error(`[${taskId}] Failed to start AgentAPI:`, err);
+            this.onEvent(taskId, 'ERROR', { error: err.message });
+            this.cleanup(taskId);
+        }
+    }
+    /**
+     * Resume a task - for Aider, this just sends another message
+     */
+    async resumeTask(taskId, sessionId, message, projectPath) {
+        console.log(`[${taskId}] Resuming Aider task with message`);
+        const rt = this.running.get(taskId);
+        if (!rt) {
+            // Task not running, need to restart
+            console.log(`[${taskId}] Task not found, starting fresh`);
+            return this.startTask(taskId, message, projectPath);
+        }
+        try {
+            await this.sendMessage(taskId, rt.port, message);
+        }
+        catch (err) {
+            console.error(`[${taskId}] Failed to send message:`, err);
+            this.onEvent(taskId, 'ERROR', { error: err.message });
+        }
+    }
+    /**
+     * Cancel a running task
+     */
+    async cancelTask(taskId) {
+        console.log(`[${taskId}] Cancelling task`);
+        this.cleanup(taskId);
+    }
+    /**
+     * Stop all running tasks
+     */
+    async stopAll() {
+        for (const taskId of this.running.keys()) {
+            await this.cancelTask(taskId);
+        }
+    }
+    /**
+     * Get list of running task IDs
+     */
+    getRunningTasks() {
+        return Array.from(this.running.keys());
+    }
+    /**
+     * Get messages for a session from AgentAPI
+     * Returns messages if the session's AgentAPI is running, null otherwise
+     * @param id - Either the canonical taskId or the generated sessionId
+     */
+    async getMessages(id) {
+        // First try as taskId (canonical ID)
+        let rt = this.running.get(id);
+        // If not found, try as sessionId using reverse mapping
+        if (!rt) {
+            const taskId = this.sessionIdToTaskId.get(id);
+            if (taskId) {
+                rt = this.running.get(taskId);
+            }
+        }
+        if (!rt) {
+            console.log(`[${id}] Cannot get messages - task not running (checked both taskId and sessionId)`);
+            return null;
+        }
+        try {
+            const response = await fetch(`http://localhost:${rt.port}/messages`);
+            if (!response.ok) {
+                console.log(`[${id}] Failed to fetch messages: ${response.status}`);
+                return null;
+            }
+            const data = await response.json();
+            return data.messages || [];
+        }
+        catch (err) {
+            console.error(`[${id}] Error fetching messages:`, err.message);
+            return null;
+        }
+    }
+    /**
+     * Get the port for a running task's AgentAPI
+     */
+    getTaskPort(taskId) {
+        const rt = this.running.get(taskId);
+        return rt ? rt.port : null;
+    }
+    /**
+     * Wait for AgentAPI server to be ready and agent to be stable
+     *
+     * AgentAPI requires the agent status to be "stable" before accepting messages.
+     * When first started, Aider may be "running" while it builds the repo map.
+     */
+    async waitForAgentApi(taskId, port) {
+        const startTime = Date.now();
+        const url = `http://localhost:${port}/status`;
+        // First, wait for the server to be up
+        let serverUp = false;
+        while (Date.now() - startTime < AGENTAPI_STARTUP_TIMEOUT) {
+            try {
+                const response = await fetch(url);
+                if (response.ok) {
+                    serverUp = true;
+                    break;
+                }
+            }
+            catch {
+                // Not ready yet
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        if (!serverUp) {
+            throw new Error(`AgentAPI failed to start within ${AGENTAPI_STARTUP_TIMEOUT}ms`);
+        }
+        console.log(`[${taskId}] AgentAPI server up on port ${port}, waiting for stable status...`);
+        // Now wait for the agent to be stable (not running/initializing)
+        while (Date.now() - startTime < AGENTAPI_STARTUP_TIMEOUT) {
+            try {
+                const response = await fetch(url);
+                if (response.ok) {
+                    const data = await response.json();
+                    if (data.status === 'stable') {
+                        console.log(`[${taskId}] AgentAPI ready and stable on port ${port}`);
+                        return;
+                    }
+                    console.log(`[${taskId}] AgentAPI status: ${data.status}, waiting for stable...`);
+                }
+            }
+            catch (err) {
+                console.log(`[${taskId}] Error checking status:`, err.message);
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        throw new Error(`Agent failed to reach stable status within ${AGENTAPI_STARTUP_TIMEOUT}ms`);
+    }
+    /**
+     * Connect to AgentAPI SSE event stream
+     *
+     * AgentAPI sends named events: 'message_update' and 'status_change'
+     * We need to listen for these specifically (onmessage only handles unnamed events)
+     */
+    connectEventStream(taskId, port, rt) {
+        const url = `http://localhost:${port}/events`;
+        console.log(`[${taskId}] Connecting to SSE stream: ${url}`);
+        const es = new eventsource_1.EventSource(url);
+        rt.eventSource = es;
+        // Handle message_update events (agent messages)
+        es.addEventListener('message_update', (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                console.log(`[${taskId}] SSE message_update:`, JSON.stringify(data).substring(0, 100));
+                this.handleMessageUpdate(taskId, data, rt);
+            }
+            catch (err) {
+                console.error(`[${taskId}] Failed to parse message_update:`, err);
+            }
+        });
+        // Handle status_change events
+        es.addEventListener('status_change', (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                console.log(`[${taskId}] SSE status_change:`, data.status);
+                this.handleStatusChange(taskId, data, rt);
+            }
+            catch (err) {
+                console.error(`[${taskId}] Failed to parse status_change:`, err);
+            }
+        });
+        // Fallback for any unnamed events
+        es.onmessage = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                console.log(`[${taskId}] SSE unnamed event:`, JSON.stringify(data).substring(0, 100));
+                this.handleAgentApiEvent(taskId, data, rt);
+            }
+            catch (err) {
+                console.error(`[${taskId}] Failed to parse SSE event:`, err);
+            }
+        };
+        es.onerror = (err) => {
+            const errorEvent = err;
+            console.error(`[${taskId}] SSE error:`, errorEvent.message || 'unknown error');
+            // Don't cleanup here - AgentAPI might still be running
+        };
+    }
+    /**
+     * Check if a message is a spinner/progress line that should be filtered
+     * These lines use \r to overwrite in terminal but create noise in our UI
+     */
+    isSpinnerLine(message) {
+        // Spinner characters
+        if (message.includes('░') || message.includes('█')) {
+            return true;
+        }
+        // Common progress patterns (partial lines without timestamps)
+        if (message.includes('Waiting for anthropic/') || message.includes('Updating repo map:')) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Handle message_update SSE event
+     */
+    handleMessageUpdate(taskId, event, rt) {
+        if (event.role === 'agent') {
+            // Skip empty/whitespace-only messages (often from spinner line clears)
+            if (!event.message.trim()) {
+                return;
+            }
+            // Skip spinner/progress lines - but let the first one through for progress indication
+            if (this.isSpinnerLine(event.message)) {
+                if (rt.firstSpinnerEmitted) {
+                    return; // Skip subsequent spinner lines
+                }
+                rt.firstSpinnerEmitted = true;
+                // Clean up the spinner message to just show the status text
+                const cleanMessage = event.message.replace(/[░█\s]+/g, '').trim();
+                if (cleanMessage) {
+                    this.onEvent(taskId, 'OUTPUT', { output: cleanMessage, session_id: rt.sessionId });
+                }
+                return;
+            }
+            // Accumulate context
+            if (rt.context) {
+                rt.context += '\n\n';
+            }
+            rt.context += event.message;
+            // Emit output for streaming display (include session_id to resolve PENDING)
+            this.onEvent(taskId, 'OUTPUT', { output: event.message, session_id: rt.sessionId });
+            // Check if aider is asking for input
+            if (this.looksLikeQuestion(event.message)) {
+                console.log(`[${taskId}] Detected question from Aider`);
+                this.onEvent(taskId, 'WAIT_FOR_USER', {
+                    session_id: rt.sessionId,
+                    prompt: this.extractQuestion(event.message),
+                    options: [],
+                    context: rt.context
+                });
+            }
+        }
+    }
+    /**
+     * Handle status_change SSE event
+     */
+    handleStatusChange(taskId, event, rt) {
+        const newStatus = event.status;
+        // Detect transition from running -> stable (task completed)
+        if (rt.lastStatus === 'running' && newStatus === 'stable') {
+            console.log(`[${taskId}] Task completed (running -> stable)`);
+            this.onEvent(taskId, 'TASK_COMPLETE', {
+                session_id: rt.sessionId,
+                result: rt.context
+            });
+        }
+        rt.lastStatus = newStatus;
+    }
+    /**
+     * Handle an event from AgentAPI
+     */
+    handleAgentApiEvent(taskId, event, rt) {
+        console.log(`[${taskId}] AgentAPI event:`, JSON.stringify(event).substring(0, 200));
+        if (event.type === 'status') {
+            const newStatus = event.status;
+            // Detect transition from running -> stable (task completed)
+            if (rt.lastStatus === 'running' && newStatus === 'stable') {
+                console.log(`[${taskId}] Task completed (running -> stable)`);
+                this.onEvent(taskId, 'TASK_COMPLETE', {
+                    session_id: rt.sessionId,
+                    result: rt.context
+                });
+            }
+            rt.lastStatus = newStatus;
+        }
+        else if (event.type === 'message') {
+            // Message from the agent
+            const content = event.content || '';
+            const role = event.role || 'assistant';
+            if (role === 'assistant') {
+                // Skip spinner/progress lines
+                if (this.isSpinnerLine(content)) {
+                    return;
+                }
+                // Accumulate context
+                if (rt.context) {
+                    rt.context += '\n\n';
+                }
+                rt.context += content;
+                // Emit output for streaming display (include session_id to resolve PENDING)
+                this.onEvent(taskId, 'OUTPUT', { output: content, session_id: rt.sessionId });
+                // Check if aider is asking for input
+                // Aider typically asks questions ending with ? or prompts for y/n
+                if (this.looksLikeQuestion(content)) {
+                    console.log(`[${taskId}] Detected question from Aider`);
+                    this.onEvent(taskId, 'WAIT_FOR_USER', {
+                        session_id: rt.sessionId,
+                        prompt: this.extractQuestion(content),
+                        options: [],
+                        context: rt.context
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Check if content looks like a question/prompt
+     */
+    looksLikeQuestion(content) {
+        const lower = content.toLowerCase().trim();
+        // Common Aider prompts
+        const questionPatterns = [
+            /\?\s*$/, // Ends with question mark
+            /\(y\/n\)/i, // Yes/no prompt
+            /\[y\/n\]/i,
+            /proceed\?/i,
+            /continue\?/i,
+            /confirm/i,
+            /would you like/i,
+            /do you want/i,
+            /should i/i
+        ];
+        return questionPatterns.some(pattern => pattern.test(lower));
+    }
+    /**
+     * Extract the question from content
+     */
+    extractQuestion(content) {
+        // Take the last few lines which typically contain the question
+        const lines = content.trim().split('\n');
+        const lastLines = lines.slice(-3).join('\n');
+        return lastLines.length > 200 ? lastLines.substring(0, 200) + '...' : lastLines;
+    }
+    /**
+     * Send a message to AgentAPI
+     */
+    async sendMessage(taskId, port, content) {
+        const url = `http://localhost:${port}/message`;
+        console.log(`[${taskId}] Sending message to AgentAPI`);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                content,
+                type: 'user'
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to send message: ${response.status} ${response.statusText}`);
+        }
+        console.log(`[${taskId}] Message sent successfully`);
+    }
+    /**
+     * Clean up a task
+     */
+    cleanup(taskId) {
+        const rt = this.running.get(taskId);
+        if (!rt)
+            return;
+        if (rt.timeoutHandle) {
+            clearTimeout(rt.timeoutHandle);
+        }
+        if (rt.eventSource) {
+            rt.eventSource.close();
+        }
+        if (rt.agentApiProcess) {
+            rt.agentApiProcess.kill();
+        }
+        // Clean up reverse mapping
+        if (rt.sessionId) {
+            this.sessionIdToTaskId.delete(rt.sessionId);
+        }
+        this.running.delete(taskId);
+        console.log(`[${taskId}] Task cleaned up`);
+    }
+}
+exports.AiderAdapter = AiderAdapter;
+//# sourceMappingURL=agentapi.js.map