gekto 0.0.6 → 0.0.8

package/dist/agents/HeadlessAgent.js

@@ -1,12 +1,29 @@
 import { spawn } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
 import { CLAUDE_PATH } from '../claudePath.js';
 export class HeadlessAgent {
     sessionId = null;
     config;
     currentProc = null;
+    pendingFileChanges = new Map();
     constructor(config = {}) {
         this.config = config;
     }
+    // Read file content safely, returns null if file doesn't exist
+    readFileSafe(filePath) {
+        try {
+            // Resolve path relative to working directory
+            const fullPath = filePath.startsWith('/')
+                ? filePath
+                : `${this.config.workingDir || process.cwd()}/${filePath}`;
+            if (!existsSync(fullPath))
+                return null;
+            return readFileSync(fullPath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
     kill() {
         if (this.currentProc && !this.currentProc.killed) {
             this.currentProc.kill('SIGTERM');
@@ -116,6 +133,20 @@ export class HeadlessAgent {
                     if (block.type === 'tool_use' && block.name) {
                         setCurrentTool?.(block.name);
                         callbacks?.onToolStart?.(block.name, block.input);
+                        // Track file changes for Write/Edit tools
+                        if ((block.name === 'Write' || block.name === 'Edit') && block.id && block.input?.file_path) {
+                            const filePath = String(block.input.file_path);
+                            const before = this.readFileSafe(filePath);
+                            this.pendingFileChanges.set(block.id, {
+                                tool: block.name,
+                                filePath,
+                                before,
+                            });
+                        }
+                    }
+                    // Extract text content from assistant messages
+                    if (block.type === 'text' && block.text) {
+                        callbacks?.onText?.(block.text);
                     }
                 }
             }
@@ -126,20 +157,32 @@ export class HeadlessAgent {
                 for (const block of message.content) {
                     if (block.type === 'tool_result') {
                         clearCurrentTool?.();
+                        // Complete file change tracking
+                        if (block.tool_use_id && this.pendingFileChanges.has(block.tool_use_id)) {
+                            const pending = this.pendingFileChanges.get(block.tool_use_id);
+                            this.pendingFileChanges.delete(block.tool_use_id);
+                            const after = this.readFileSafe(pending.filePath);
+                            // Only emit if file actually changed (or was created)
+                            if (after !== null && after !== pending.before) {
+                                callbacks?.onFileChange?.({
+                                    tool: pending.tool,
+                                    filePath: pending.filePath,
+                                    before: pending.before,
+                                    after,
+                                });
+                            }
+                        }
                     }
                 }
             }
         }
-        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;
     }
+    setSessionId(id) {
+        this.sessionId = id;
+    }
     resetSession() {
         this.sessionId = null;
     }

package/dist/agents/agentPool.js

@@ -1,4 +1,6 @@
 import path from 'path';
+import { writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
 import { HeadlessAgent } from './HeadlessAgent.js';
 // Per-lizard sessions
 const sessions = new Map();
@@ -28,7 +30,16 @@ Your job is ONLY to:
 - 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.`;
+After making changes, simply report what you did. The user will handle building, testing, and running the code themselves.
+
+STATUS MARKER - At the END of EVERY response, you MUST include exactly one of these markers:
+- [STATUS:DONE] - Use when the task is complete and you have no questions for the user
+- [STATUS:PENDING] - Use when you need user input, confirmation, clarification, or approval to proceed
+
+Examples:
+- After completing a code change: "I've updated the function. [STATUS:DONE]"
+- When asking a question: "Which approach would you prefer? [STATUS:PENDING]"
+- After answering a simple question: "The file is located at src/utils.ts [STATUS:DONE]"`;
 // Tools that agents are not allowed to use
 const DISALLOWED_TOOLS = ['Bash', 'Task'];
 function getOrCreateSession(lizardId, ws) {
@@ -52,6 +63,31 @@ function getOrCreateSession(lizardId, ws) {
     }
     return session;
 }
+export function resumeSession(lizardId, sessionId, ws) {
+    let session = sessions.get(lizardId);
+    if (!session) {
+        const agent = new HeadlessAgent({
+            systemPrompt: DEFAULT_SYSTEM_PROMPT,
+            workingDir: getWorkingDir(),
+            disallowedTools: DISALLOWED_TOOLS,
+        });
+        // Restore Claude Code session ID so --resume works
+        if (sessionId) {
+            agent.setSessionId(sessionId);
+        }
+        session = {
+            agent,
+            isProcessing: false,
+            queue: [],
+            currentWs: ws ?? null,
+        };
+        sessions.set(lizardId, session);
+    }
+    else if (ws) {
+        session.currentWs = ws;
+    }
+    return session;
+}
 export function isProcessing(lizardId) {
     const session = sessions.get(lizardId);
     return session?.isProcessing ?? false;
@@ -89,6 +125,20 @@ export async function sendMessage(lizardId, message, ws) {
                 tool,
             });
         },
+        onText: (text) => {
+            safeSend(session, {
+                type: 'text',
+                lizardId,
+                text,
+            });
+        },
+        onFileChange: (change) => {
+            safeSend(session, {
+                type: 'file_change',
+                lizardId,
+                change,
+            });
+        },
     };
     // If already processing, queue the message
     if (session.isProcessing) {
@@ -194,10 +244,50 @@ export function killSession(lizardId) {
         const killed = session.agent.kill();
         session.isProcessing = false;
         session.queue = [];
+        // Remove from map so getActiveSessions() doesn't return dead agents
+        sessions.delete(lizardId);
         return killed;
     }
     return false;
 }
+// Revert files to their pre-agent state using the before content from FileChange objects
+export function revertFiles(filePaths, fileChanges) {
+    const reverted = [];
+    const failed = [];
+    const workingDir = getWorkingDir();
+    for (const filePath of filePaths) {
+        const change = fileChanges.find(fc => fc.filePath === filePath);
+        if (!change) {
+            failed.push(filePath);
+            continue;
+        }
+        try {
+            const fullPath = filePath.startsWith('/')
+                ? filePath
+                : path.resolve(workingDir, filePath);
+            if (change.before === null) {
+                // File was newly created by agent — delete it
+                if (existsSync(fullPath)) {
+                    unlinkSync(fullPath);
+                }
+            }
+            else {
+                // File existed before — restore original content
+                const dir = dirname(fullPath);
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+                writeFileSync(fullPath, change.before, 'utf-8');
+            }
+            reverted.push(filePath);
+        }
+        catch (err) {
+            console.error(`[AgentPool] Failed to revert ${filePath}:`, err);
+            failed.push(filePath);
+        }
+    }
+    return { reverted, failed };
+}
 export function killAllSessions() {
     let count = 0;
     for (const [, session] of sessions) {
@@ -207,5 +297,7 @@ export function killAllSessions() {
         session.isProcessing = false;
         session.queue = [];
     }
+    // Clear all sessions so getActiveSessions() returns empty
+    sessions.clear();
     return count;
 }

package/dist/agents/agentWebSocket.js

@@ -1,6 +1,6 @@
 import { WebSocketServer } from 'ws';
-import { sendMessage, resetSession, getWorkingDir, getActiveSessions, killSession, killAllSessions, attachWebSocket } from './agentPool.js';
-import { processWithTools } from './gektoTools.js';
+import { sendMessage, resumeSession, resetSession, getWorkingDir, getActiveSessions, killSession, killAllSessions, attachWebSocket, revertFiles } from './agentPool.js';
+import { processWithTools, generateTaskPrompts } from './gektoTools.js';
 import { initGekto, sendToGekto, getGektoState, abortGekto, setStateCallback } from './gektoPersistent.js';
 // Track connected clients to broadcast Gekto state
 const connectedClients = new Set();
@@ -151,8 +151,15 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                             tool,
                                         }));
                                     },
+                                    onText: (text) => {
+                                        ws.send(JSON.stringify({
+                                            type: 'gekto_text',
+                                            planId: msg.planId,
+                                            text,
+                                        }));
+                                    },
                                 };
-                                const planResult = await processWithTools(msg.prompt, msg.planId, getWorkingDir(), getActiveSessions(), planCallbacks);
+                                const planResult = await processWithTools(msg.prompt, msg.planId, getWorkingDir(), getActiveSessions(), planCallbacks, msg.existingPlan);
                                 if (planResult.type === 'build' && planResult.plan) {
                                     activePlans.set(msg.planId, planResult.plan);
                                     ws.send(JSON.stringify({
@@ -199,6 +206,59 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             ws.send(JSON.stringify({ type: 'state', lizardId: 'master', state: 'ready' }));
                         }
                         return;
+                    case 'generate_prompts': {
+                        const genPlan = activePlans.get(msg.planId);
+                        if (!genPlan) {
+                            ws.send(JSON.stringify({ type: 'error', message: 'Plan not found' }));
+                            return;
+                        }
+                        // Set master to working while generating
+                        ws.send(JSON.stringify({ type: 'state', lizardId: 'master', state: 'working' }));
+                        try {
+                            const genCallbacks = {
+                                onTaskPromptGenerated: (taskId, prompt) => {
+                                    // Update server-side plan
+                                    const task = genPlan.tasks.find(t => t.id === taskId);
+                                    if (task)
+                                        task.prompt = prompt;
+                                    // Notify client
+                                    ws.send(JSON.stringify({
+                                        type: 'prompt_generated',
+                                        planId: msg.planId,
+                                        taskId,
+                                        prompt,
+                                    }));
+                                },
+                                onAllPromptsReady: () => {
+                                    genPlan.status = 'prompts_ready';
+                                    ws.send(JSON.stringify({
+                                        type: 'prompts_ready',
+                                        planId: msg.planId,
+                                    }));
+                                },
+                                onError: (taskId, error) => {
+                                    ws.send(JSON.stringify({
+                                        type: 'prompt_generated',
+                                        planId: msg.planId,
+                                        taskId,
+                                        prompt: genPlan.tasks.find(t => t.id === taskId)?.description || 'Execute task',
+                                        error,
+                                    }));
+                                },
+                            };
+                            await generateTaskPrompts(genPlan, getWorkingDir(), genCallbacks);
+                        }
+                        catch (err) {
+                            console.error('[Agent] Prompt generation failed:', err);
+                            ws.send(JSON.stringify({
+                                type: 'gekto_chat',
+                                planId: msg.planId,
+                                message: `Error generating prompts: ${err instanceof Error ? err.message : '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);
@@ -217,6 +277,23 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             activePlans.delete(msg.planId);
                         }
                         return;
+                    case 'resume_agent': {
+                        const { lizardId: resumeId, sessionId: resumeSessionId, prompt: resumePrompt } = msg;
+                        if (!resumeId) {
+                            ws.send(JSON.stringify({ type: 'error', message: 'Missing lizardId for resume' }));
+                            return;
+                        }
+                        // Create session with restored sessionId
+                        resumeSession(resumeId, resumeSessionId, ws);
+                        // Send the original prompt to resume work
+                        try {
+                            await sendMessage(resumeId, resumePrompt || 'Continue where you left off.', ws);
+                        }
+                        catch (err) {
+                            console.error(`[Agent] Resume failed for ${resumeId}:`, err);
+                        }
+                        return;
+                    }
                 }
                 // Commands that require lizardId
                 const lizardId = msg.lizardId;
@@ -237,6 +314,16 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         resetSession(lizardId);
                         ws.send(JSON.stringify({ type: 'state', lizardId, state: 'ready' }));
                         break;
+                    case 'revert_files': {
+                        const revertResult = revertFiles(msg.filePaths || [], msg.fileChanges || []);
+                        ws.send(JSON.stringify({
+                            type: 'files_reverted',
+                            lizardId,
+                            reverted: revertResult.reverted,
+                            failed: revertResult.failed,
+                        }));
+                        break;
+                    }
                     case 'kill':
                         // For master, abort the persistent Gekto process instead of killing session
                         const killed = lizardId === 'master' ? abortGekto() : killSession(lizardId);

package/dist/agents/bashSafetyRules.js

@@ -0,0 +1,30 @@
+// Shared Bash safety rules for all agents (Gekto + workers)
+// Mirrors the restrictions in CLAUDE.md and .claude/settings.json
+export const BASH_SAFETY_RULES = `
+BASH SAFETY RULES — You MUST follow these when using Bash:
+
+ALLOWED commands:
+- git (status, add, commit, diff, log, branch, checkout, stash)
+- npm/yarn/pnpm/bun (run, test, install, build)
+- npx, node, tsc, python, pip install
+- cat, ls, find, grep, echo, mkdir, cp, mv, head, tail, wc, sort, diff, pwd, which
+
+STRICTLY FORBIDDEN — NEVER run these:
+- rm -rf (any path outside the current project)
+- sudo (any command)
+- chmod 777, chown, mkfs, dd
+- curl|bash, curl|sh, wget|bash, wget|sh (piped execution)
+- eval with untrusted input
+- shutdown, reboot, kill -9 1, killall, systemctl, service
+- Any command that modifies system files (/etc, /usr, /var, /bin, /sbin, /boot)
+- Any command that reads /etc/shadow, /etc/passwd
+- Any command that writes to /root, ~/.ssh, ~/.bashrc, ~/.zshrc
+- Fork bombs or disk-wiping commands
+- Reading or writing .env files (they contain secrets)
+
+GENERAL RULES:
+1. Only run commands within the current project directory
+2. Never run destructive commands without confirming the paths are project-local
+3. Prefer dedicated tools (Read, Write, Edit, Glob, Grep) over bash equivalents when available
+4. If a task requires operations outside the project, STOP and report it
+`;

package/dist/agents/gektoPersistent.js

@@ -46,7 +46,7 @@ function spawnOpus() {
         '--input-format', 'stream-json',
         '--output-format', 'stream-json',
         '--verbose',
-        '--model', 'claude-opus-4-5-20251101',
+        '--model', 'claude-sonnet-4-6',
         '--system-prompt', OPUS_SYSTEM_PROMPT,
         '--dangerously-skip-permissions',
         '--disallowed-tools', 'Bash', 'Task',
@@ -58,6 +58,8 @@ function spawnOpus() {
         env: process.env,
         stdio: ['pipe', 'pipe', 'pipe'],
     });
+    // Prevent EPIPE crash when writing to stdin of a dead process
+    opusProcess.stdin.on('error', () => { });
     opusProcess.on('error', (err) => {
         console.error(`[GektoPersistent] Spawn error:`, err);
     });
@@ -100,7 +102,7 @@ function spawnOpus() {
     });
     // Warm up: send a quick message to trigger ready state
     setTimeout(() => {
-        if (opusProcess && !opusReady) {
+        if (opusProcess && !opusProcess.killed && opusProcess.stdin.writable) {
             const warmup = { type: 'user', message: { role: 'user', content: 'hi' } };
             opusProcess.stdin.write(JSON.stringify(warmup) + '\n');
         }
@@ -139,12 +141,15 @@ function handleOpusEvent(event) {
             }
         }
     }
-    // Text streaming
+    // Text streaming (text_delta = response text, thinking_delta = extended thinking)
     if (event.type === 'content_block_delta') {
         const delta = event.delta;
         if (delta?.type === 'text_delta' && delta.text) {
             opusCallbacks?.onText?.(delta.text);
         }
+        else if (delta?.type === 'thinking_delta' && delta.thinking) {
+            opusCallbacks?.onText?.(delta.thinking);
+        }
     }
     // Final result
     if (event.type === 'result' && event.result) {
@@ -173,7 +178,13 @@ async function sendToOpus(prompt, callbacks) {
             type: 'user',
             message: { role: 'user', content: prompt },
         };
-        opusProcess.stdin.write(JSON.stringify(inputMessage) + '\n');
+        if (opusProcess && !opusProcess.killed && opusProcess.stdin.writable) {
+            opusProcess.stdin.write(JSON.stringify(inputMessage) + '\n');
+        }
+        else {
+            opusPendingResolve?.('Process is not available, please try again.');
+            opusPendingResolve = null;
+        }
         // Timeout after 5 min for complex tasks
         setTimeout(() => {
             if (opusPendingResolve) {
@@ -183,6 +194,10 @@ async function sendToOpus(prompt, callbacks) {
         }, 300000);
     });
 }
+// === Planning API (reuses warm persistent process) ===
+export async function sendPlanningPrompt(prompt, callbacks) {
+    return sendToOpus(prompt, callbacks || {});
+}
 // Mode is now passed as parameter - default is 'plan', UI can toggle to 'direct'
 export async function sendToGekto(prompt, mode = 'plan', callbacks) {
     const startTime = Date.now();

package/dist/agents/gektoSimple.js

@@ -93,8 +93,13 @@ function runHaiku(prompt, systemPrompt, workingDir) {
                             }
                         }
                     }
-                    else if (event.type === 'content_block_delta' && event.delta?.text) {
-                        resultText += event.delta.text;
+                    else if (event.type === 'content_block_delta') {
+                        if (event.delta?.text) {
+                            resultText += event.delta.text;
+                        }
+                        else if (event.delta?.thinking) {
+                            resultText += event.delta.thinking;
+                        }
                     }
                 }
                 catch {