gekto 0.0.1

package/dist/agents/ClaudeAgent.js

@@ -0,0 +1,72 @@
+import * as pty from 'node-pty';
+export class ClaudeAgent {
+    pty;
+    buffer = '';
+    state = 'loading';
+    config;
+    readyPromise;
+    resolveReady;
+    constructor(config) {
+        this.config = config;
+        this.readyPromise = new Promise((resolve) => {
+            this.resolveReady = resolve;
+        });
+        this.pty = pty.spawn('claude', [], {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 40,
+            cwd: config.workingDir,
+            env: process.env,
+        });
+        this.pty.onData((data) => {
+            this.buffer += data;
+            this.config.onOutput(data);
+            this.detectState(data);
+        });
+        this.pty.onExit(({ exitCode }) => {
+            console.log(`[ClaudeAgent] Exited with code ${exitCode}`);
+            this.setState('error');
+        });
+    }
+    setState(state) {
+        if (this.state !== state) {
+            this.state = state;
+            this.config.onStateChange(state);
+        }
+    }
+    detectState(data) {
+        // Strip ANSI codes for analysis
+        const clean = data.replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+        // Check for ready prompt (Claude Code shows > or ❯ when ready for input)
+        // This indicates Claude has finished and is waiting for next input
+        if ((clean.includes('>') || clean.includes('❯')) && (this.state === 'loading' || this.state === 'working')) {
+            if (this.state === 'loading') {
+                this.config.onReady();
+                this.resolveReady();
+            }
+            this.setState('ready');
+        }
+        // Check for permission prompts
+        if (/Do you want to|Allow|Proceed\?|\[y\/N\]|\[Y\/n\]/i.test(clean)) {
+            this.setState('waiting_input');
+        }
+    }
+    async waitUntilReady() {
+        return this.readyPromise;
+    }
+    sendMessage(message) {
+        this.setState('working');
+        this.buffer = '';
+        this.pty.write(message + '\r');
+    }
+    respond(input) {
+        this.setState('working');
+        this.pty.write(input + '\r');
+    }
+    getState() {
+        return this.state;
+    }
+    kill() {
+        this.pty.kill();
+    }
+}

package/dist/agents/HeadlessAgent.js

@@ -0,0 +1,141 @@
+import { spawn } from 'child_process';
+export class HeadlessAgent {
+    sessionId = null;
+    config;
+    currentProc = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    kill() {
+        if (this.currentProc && !this.currentProc.killed) {
+            this.currentProc.kill('SIGTERM');
+            this.currentProc = null;
+            return true;
+        }
+        return false;
+    }
+    isRunning() {
+        return this.currentProc !== null && !this.currentProc.killed;
+    }
+    async send(message, callbacks) {
+        const args = [
+            '-p', message,
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--model', 'claude-opus-4-5-20251101',
+            '--dangerously-skip-permissions',
+        ];
+        if (this.config.systemPrompt) {
+            args.push('--system-prompt', this.config.systemPrompt);
+        }
+        if (this.config.disallowedTools && this.config.disallowedTools.length > 0) {
+            args.push('--disallowed-tools', this.config.disallowedTools.join(','));
+        }
+        if (this.sessionId) {
+            args.push('--resume', this.sessionId);
+        }
+        return this.runClaudeStreaming(args, callbacks);
+    }
+    runClaudeStreaming(args, callbacks) {
+        return new Promise((resolve, reject) => {
+            const proc = spawn('claude', args, {
+                cwd: this.config.workingDir || process.cwd(),
+                env: process.env,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.currentProc = proc;
+            // Close stdin immediately - we pass everything via args
+            proc.stdin?.end();
+            let buffer = '';
+            let lastResult = null;
+            let currentTool = null;
+            proc.stdout.on('data', (data) => {
+                buffer += data.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const event = JSON.parse(line);
+                        this.processStreamEvent(event, callbacks, (tool) => {
+                            currentTool = tool;
+                        }, () => {
+                            currentTool = null;
+                        });
+                        if (event.type === 'result') {
+                            lastResult = event;
+                            this.sessionId = event.session_id;
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+            });
+            proc.stderr.on('data', () => {
+                // Ignore stderr
+            });
+            proc.on('close', () => {
+                this.currentProc = null;
+                if (buffer.trim()) {
+                    try {
+                        const event = JSON.parse(buffer);
+                        if (event.type === 'result') {
+                            lastResult = event;
+                            this.sessionId = event.session_id;
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+                if (currentTool && callbacks?.onToolEnd) {
+                    callbacks.onToolEnd(currentTool);
+                }
+                if (lastResult) {
+                    resolve(lastResult);
+                }
+                else {
+                    reject(new Error('No result received from Claude'));
+                }
+            });
+            proc.on('error', reject);
+        });
+    }
+    processStreamEvent(event, callbacks, setCurrentTool, clearCurrentTool) {
+        if (event.type === 'assistant' && event.message) {
+            const message = event.message;
+            if (message.content) {
+                for (const block of message.content) {
+                    if (block.type === 'tool_use' && block.name) {
+                        setCurrentTool?.(block.name);
+                        callbacks?.onToolStart?.(block.name, block.input);
+                    }
+                }
+            }
+        }
+        if (event.type === 'user' && event.message) {
+            const message = event.message;
+            if (message.content) {
+                for (const block of message.content) {
+                    if (block.type === 'tool_result') {
+                        clearCurrentTool?.();
+                    }
+                }
+            }
+        }
+        if (event.type === 'content_block_delta') {
+            const delta = event.delta;
+            if (delta?.type === 'text_delta' && delta.text) {
+                callbacks?.onText?.(delta.text);
+            }
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    resetSession() {
+        this.sessionId = null;
+    }
+}

package/dist/agents/agentPool.js

@@ -0,0 +1,211 @@
+import path from 'path';
+import { HeadlessAgent } from './HeadlessAgent.js';
+// Per-lizard sessions
+const sessions = new Map();
+// Summarize tool input for display
+function summarizeInput(input) {
+    if (input.file_path)
+        return String(input.file_path);
+    if (input.pattern)
+        return String(input.pattern);
+    if (input.command)
+        return String(input.command).substring(0, 50);
+    if (input.path)
+        return String(input.path);
+    return '';
+}
+const DEFAULT_SYSTEM_PROMPT = `You are a helpful coding assistant. Be concise and direct in your responses.
+
+IMPORTANT RESTRICTIONS - You MUST follow these rules:
+1. DO NOT use Bash or shell commands - you cannot run terminal commands
+2. DO NOT try to build, compile, or bundle the project
+3. DO NOT try to start, restart, or run any servers or dev environments
+4. DO NOT run tests, linters, or any CLI tools
+5. DO NOT install packages or run npm/yarn/pnpm commands
+
+Your job is ONLY to:
+- Read and understand code using Read, Glob, Grep tools
+- Write and edit code using Write and Edit tools
+- Make the requested code changes
+
+After making changes, simply report what you did. The user will handle building, testing, and running the code themselves.`;
+// Tools that agents are not allowed to use
+const DISALLOWED_TOOLS = ['Bash', 'Task'];
+function getOrCreateSession(lizardId, ws) {
+    let session = sessions.get(lizardId);
+    if (!session) {
+        session = {
+            agent: new HeadlessAgent({
+                systemPrompt: DEFAULT_SYSTEM_PROMPT,
+                workingDir: getWorkingDir(),
+                disallowedTools: DISALLOWED_TOOLS,
+            }),
+            isProcessing: false,
+            queue: [],
+            currentWs: ws ?? null,
+        };
+        sessions.set(lizardId, session);
+    }
+    else if (ws) {
+        // Update WebSocket reference for existing session
+        session.currentWs = ws;
+    }
+    return session;
+}
+export function isProcessing(lizardId) {
+    const session = sessions.get(lizardId);
+    return session?.isProcessing ?? false;
+}
+export function getQueueLength(lizardId) {
+    const session = sessions.get(lizardId);
+    return session?.queue.length ?? 0;
+}
+// Helper to safely send to current WebSocket
+function safeSend(session, data) {
+    const ws = session.currentWs;
+    if (ws && ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify(data));
+    }
+}
+export async function sendMessage(lizardId, message, ws) {
+    const session = getOrCreateSession(lizardId, ws);
+    // Create streaming callbacks that use session's current WebSocket
+    const callbacks = {
+        onToolStart: (tool, input) => {
+            safeSend(session, {
+                type: 'tool',
+                lizardId,
+                status: 'running',
+                tool,
+                input: input ? summarizeInput(input) : undefined,
+                fullInput: input, // Send full input for expandable view
+            });
+        },
+        onToolEnd: (tool) => {
+            safeSend(session, {
+                type: 'tool',
+                lizardId,
+                status: 'completed',
+                tool,
+            });
+        },
+    };
+    // If already processing, queue the message
+    if (session.isProcessing) {
+        return new Promise((resolve, reject) => {
+            session.queue.push({ message, ws, callbacks, resolve, reject });
+            const position = session.queue.length;
+            ws.send(JSON.stringify({
+                type: 'queued',
+                lizardId,
+                position,
+            }));
+        });
+    }
+    // Process immediately
+    return processMessage(lizardId, session, message, ws, callbacks);
+}
+async function processMessage(lizardId, session, message, _ws, // Kept for queue compatibility, but we use session.currentWs
+callbacks) {
+    session.isProcessing = true;
+    safeSend(session, { type: 'state', lizardId, state: 'working' });
+    try {
+        const response = await session.agent.send(message, callbacks);
+        safeSend(session, {
+            type: 'response',
+            lizardId,
+            text: response.result,
+            sessionId: response.session_id,
+            cost: response.total_cost_usd,
+            duration: response.duration_ms,
+        });
+        return response;
+    }
+    catch (err) {
+        safeSend(session, {
+            type: 'error',
+            lizardId,
+            message: String(err),
+        });
+        throw err;
+    }
+    finally {
+        session.isProcessing = false;
+        safeSend(session, { type: 'state', lizardId, state: 'ready' });
+        // Process next queued message if any
+        if (session.queue.length > 0) {
+            const next = session.queue.shift();
+            processMessage(lizardId, session, next.message, next.ws, next.callbacks)
+                .then(next.resolve)
+                .catch(next.reject);
+        }
+    }
+}
+export function resetSession(lizardId) {
+    const session = sessions.get(lizardId);
+    if (session) {
+        session.agent.resetSession();
+        session.queue = [];
+    }
+}
+export function deleteSession(lizardId) {
+    sessions.delete(lizardId);
+}
+export function getWorkingDir() {
+    // In development, use test-app as the working directory
+    if (process.env.NODE_ENV !== 'production') {
+        return path.resolve(process.cwd(), '../test-app');
+    }
+    return process.cwd();
+}
+// Update WebSocket for all sessions (called when new client connects)
+export function attachWebSocket(ws) {
+    for (const session of sessions.values()) {
+        session.currentWs = ws;
+    }
+}
+export function getActiveSessions() {
+    const result = [];
+    for (const [lizardId, session] of sessions) {
+        // Determine state
+        let state = 'ready';
+        let queuePosition = 0;
+        if (session.isProcessing) {
+            state = 'working';
+        }
+        else if (session.queue.length > 0) {
+            state = 'queued';
+            queuePosition = session.queue.length;
+        }
+        result.push({
+            lizardId,
+            isProcessing: session.isProcessing,
+            isRunning: session.agent.isRunning(),
+            queueLength: session.queue.length,
+            state,
+            queuePosition,
+        });
+    }
+    return result;
+}
+export function killSession(lizardId) {
+    const session = sessions.get(lizardId);
+    if (session) {
+        const killed = session.agent.kill();
+        session.isProcessing = false;
+        session.queue = [];
+        return killed;
+    }
+    return false;
+}
+export function killAllSessions() {
+    let count = 0;
+    for (const [, session] of sessions) {
+        if (session.agent.kill()) {
+            count++;
+        }
+        session.isProcessing = false;
+        session.queue = [];
+    }
+    return count;
+}

package/dist/agents/agentWebSocket.js

@@ -0,0 +1,264 @@
+import { WebSocketServer } from 'ws';
+import { sendMessage, resetSession, getWorkingDir, getActiveSessions, killSession, killAllSessions, attachWebSocket } from './agentPool.js';
+import { processWithTools } from './gektoTools.js';
+import { initGekto, sendToGekto, getGektoState, abortGekto, setStateCallback } from './gektoPersistent.js';
+// Track connected clients to broadcast Gekto state
+const connectedClients = new Set();
+let gektoInitialized = false;
+function broadcastGektoState(state) {
+    const message = JSON.stringify({ type: 'gekto_state', state });
+    for (const client of connectedClients) {
+        if (client.readyState === 1) { // WebSocket.OPEN
+            client.send(message);
+        }
+    }
+}
+// Summarize tool input for display
+function summarizeToolInput(input) {
+    if (!input)
+        return '';
+    if (input.file_path)
+        return String(input.file_path);
+    if (input.pattern)
+        return String(input.pattern);
+    if (input.command)
+        return String(input.command).substring(0, 50);
+    if (input.path)
+        return String(input.path);
+    if (input.query)
+        return String(input.query).substring(0, 50);
+    return '';
+}
+// Store active plans
+const activePlans = new Map();
+export function setupAgentWebSocket(server, path = '/__gekto/agent') {
+    const wss = new WebSocketServer({ noServer: true });
+    server.on('upgrade', (request, socket, head) => {
+        const url = request.url || '';
+        if (url === path || url.startsWith(path + '?')) {
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                wss.emit('connection', ws, request);
+            });
+        }
+    });
+    wss.on('connection', (ws) => {
+        // Track connected clients for Gekto state broadcasts
+        connectedClients.add(ws);
+        // Always ensure Gekto is initialized and callback is set
+        setStateCallback(broadcastGektoState);
+        if (!gektoInitialized) {
+            initGekto(getWorkingDir(), broadcastGektoState);
+            gektoInitialized = true;
+        }
+        // Attach this WebSocket to all existing sessions (for reconnection)
+        attachWebSocket(ws);
+        // Send working directory info
+        ws.send(JSON.stringify({ type: 'info', workingDir: getWorkingDir() }));
+        // Send current Gekto state
+        ws.send(JSON.stringify({ type: 'gekto_state', state: getGektoState() }));
+        // Send current state for all active sessions
+        const activeSessions = getActiveSessions();
+        for (const session of activeSessions) {
+            ws.send(JSON.stringify({
+                type: 'state',
+                lizardId: session.lizardId,
+                state: session.state,
+            }));
+        }
+        ws.on('message', async (message) => {
+            try {
+                const msg = JSON.parse(message.toString());
+                // Commands that don't require lizardId
+                switch (msg.type) {
+                    case 'list_agents':
+                        ws.send(JSON.stringify({
+                            type: 'agents_list',
+                            agents: getActiveSessions(),
+                        }));
+                        return;
+                    case 'debug_pool':
+                        const sessions = getActiveSessions();
+                        ws.send(JSON.stringify({
+                            type: 'debug_pool_result',
+                            sessions,
+                        }));
+                        return;
+                    case 'kill_all':
+                        const killedCount = killAllSessions();
+                        ws.send(JSON.stringify({
+                            type: 'kill_all_result',
+                            killed: killedCount,
+                        }));
+                        // Notify about state changes
+                        for (const session of getActiveSessions()) {
+                            ws.send(JSON.stringify({ type: 'state', lizardId: session.lizardId, state: 'ready' }));
+                        }
+                        return;
+                    case 'create_plan':
+                        // Mode is passed from client (default: 'plan', can toggle to 'direct')
+                        const mode = msg.mode || 'plan';
+                        // Set master lizard to working state
+                        ws.send(JSON.stringify({ type: 'state', lizardId: 'master', state: 'working' }));
+                        try {
+                            // Create callbacks for streaming events to client
+                            const callbacks = {
+                                onToolStart: (tool, input) => {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool',
+                                        lizardId: 'master',
+                                        status: 'running',
+                                        tool,
+                                        input: summarizeToolInput(input),
+                                        fullInput: input,
+                                    }));
+                                },
+                                onToolEnd: (tool) => {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool',
+                                        lizardId: 'master',
+                                        status: 'completed',
+                                        tool,
+                                    }));
+                                },
+                                onText: (text) => {
+                                    ws.send(JSON.stringify({
+                                        type: 'gekto_text',
+                                        planId: msg.planId,
+                                        text,
+                                    }));
+                                },
+                            };
+                            const response = await sendToGekto(msg.prompt, mode, callbacks);
+                            if (response.mode === 'plan') {
+                                // Plan mode - use gektoTools for task breakdown
+                                // Create callbacks for plan tool streaming
+                                const planCallbacks = {
+                                    onToolStart: (tool, input) => {
+                                        ws.send(JSON.stringify({
+                                            type: 'tool',
+                                            lizardId: 'master',
+                                            status: 'running',
+                                            tool,
+                                            input: summarizeToolInput(input),
+                                            fullInput: input,
+                                        }));
+                                    },
+                                    onToolEnd: (tool) => {
+                                        ws.send(JSON.stringify({
+                                            type: 'tool',
+                                            lizardId: 'master',
+                                            status: 'completed',
+                                            tool,
+                                        }));
+                                    },
+                                };
+                                const planResult = await processWithTools(msg.prompt, msg.planId, getWorkingDir(), getActiveSessions(), planCallbacks);
+                                if (planResult.type === 'build' && planResult.plan) {
+                                    activePlans.set(msg.planId, planResult.plan);
+                                    ws.send(JSON.stringify({
+                                        type: 'plan_created',
+                                        planId: msg.planId,
+                                        plan: planResult.plan,
+                                    }));
+                                }
+                                else if (planResult.type === 'remove' && planResult.removedAgents) {
+                                    ws.send(JSON.stringify({
+                                        type: 'gekto_remove',
+                                        planId: msg.planId,
+                                        agents: planResult.removedAgents,
+                                    }));
+                                }
+                                else {
+                                    ws.send(JSON.stringify({
+                                        type: 'gekto_chat',
+                                        planId: msg.planId,
+                                        message: planResult.message || 'Plan created.',
+                                    }));
+                                }
+                            }
+                            else {
+                                // Direct mode - response already sent via callbacks
+                                ws.send(JSON.stringify({
+                                    type: 'gekto_chat',
+                                    planId: msg.planId,
+                                    message: response.message,
+                                    timing: {
+                                        workMs: response.workMs,
+                                    },
+                                }));
+                            }
+                            ws.send(JSON.stringify({ type: 'state', lizardId: 'master', state: 'ready' }));
+                        }
+                        catch (err) {
+                            console.error('[Agent] Gekto processing failed:', err);
+                            ws.send(JSON.stringify({
+                                type: 'gekto_chat',
+                                planId: msg.planId,
+                                message: `Error: ${err instanceof Error ? err.message : 'Processing failed'}`,
+                            }));
+                            ws.send(JSON.stringify({ type: 'state', lizardId: 'master', state: 'ready' }));
+                        }
+                        return;
+                    case 'execute_plan':
+                        // Execute an existing plan
+                        const plan = activePlans.get(msg.planId);
+                        if (!plan) {
+                            ws.send(JSON.stringify({ type: 'error', message: 'Plan not found' }));
+                            return;
+                        }
+                        // Client handles execution locally (spawns workers, assigns tasks)
+                        // Don't send plan_updated here - it would overwrite client's assignedLizardId
+                        plan.status = 'executing';
+                        return;
+                    case 'cancel_plan':
+                        const cancelPlan = activePlans.get(msg.planId);
+                        if (cancelPlan) {
+                            cancelPlan.status = 'failed';
+                            activePlans.delete(msg.planId);
+                        }
+                        return;
+                }
+                // Commands that require lizardId
+                const lizardId = msg.lizardId;
+                if (!lizardId) {
+                    ws.send(JSON.stringify({ type: 'error', message: 'Missing lizardId' }));
+                    return;
+                }
+                switch (msg.type) {
+                    case 'chat':
+                        try {
+                            await sendMessage(lizardId, msg.content, ws);
+                        }
+                        catch (err) {
+                            console.error(`[Agent] [${lizardId}] Error:`, err);
+                        }
+                        break;
+                    case 'reset':
+                        resetSession(lizardId);
+                        ws.send(JSON.stringify({ type: 'state', lizardId, state: 'ready' }));
+                        break;
+                    case 'kill':
+                        // For master, abort the persistent Gekto process instead of killing session
+                        const killed = lizardId === 'master' ? abortGekto() : killSession(lizardId);
+                        ws.send(JSON.stringify({
+                            type: 'kill_result',
+                            lizardId,
+                            killed,
+                        }));
+                        ws.send(JSON.stringify({ type: 'state', lizardId, state: 'ready' }));
+                        break;
+                }
+            }
+            catch (err) {
+                console.error('[Agent] Failed to parse message:', err);
+            }
+        });
+        ws.on('close', () => {
+            connectedClients.delete(ws);
+        });
+        ws.on('error', (err) => {
+            console.error('[Agent] WebSocket error:', err);
+        });
+    });
+    return wss;
+}