gekto 0.0.1

package/dist/agents/gektoOrchestrator.js

@@ -0,0 +1,195 @@
+import { spawn } from 'child_process';
+// === Gekto System Prompt ===
+const GEKTO_SYSTEM_PROMPT = `You are Gekto, a friendly task orchestration assistant. You help users with coding tasks by delegating work to specialized agents.
+
+IMPORTANT: Analyze each message and decide how to respond:
+
+1. If the message is a GREETING, QUESTION, or CONVERSATION (not a coding task):
+   - Respond naturally and friendly
+   - Your response will be shown directly to the user
+
+2. If the message is a CODING TASK (feature request, bug fix, refactoring, file changes):
+   - Start your response with exactly: [PLAN_MODE]
+   - Then provide a JSON execution plan:
+   {
+     "tasks": [
+       {
+         "id": "task_1",
+         "description": "Brief description",
+         "prompt": "Detailed prompt for the worker agent",
+         "files": ["path/to/file.ts"],
+         "dependencies": []
+       }
+     ]
+   }
+
+Examples:
+- "hey" -> "Hey! How can I help you today?"
+- "what's up?" -> "Not much! Ready to help with any coding tasks you have."
+- "add dark mode" -> [PLAN_MODE]{"tasks":[...]}
+- "fix the login bug" -> [PLAN_MODE]{"tasks":[...]}`;
+// Process a message to Gekto - returns either a chat response or an execution plan
+export async function processGektoMessage(prompt, planId, workingDir) {
+    console.log('[Orchestrator] Processing message:', prompt.substring(0, 100));
+    const result = await runClaudeOnce(prompt, GEKTO_SYSTEM_PROMPT, workingDir);
+    console.log('[Orchestrator] Gekto response:', result.substring(0, 200));
+    // Check if response indicates plan mode
+    if (result.includes('[PLAN_MODE]')) {
+        // Extract the JSON plan after [PLAN_MODE]
+        const planPart = result.split('[PLAN_MODE]')[1]?.trim() || '';
+        return {
+            type: 'plan',
+            plan: parsePlanFromResponse(planPart, planId, prompt),
+        };
+    }
+    // Regular chat response
+    return {
+        type: 'chat',
+        message: result.trim(),
+    };
+}
+// Parse plan JSON from response
+function parsePlanFromResponse(result, planId, originalPrompt) {
+    let parsedTasks = [];
+    try {
+        const jsonMatch = result.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (parsed.tasks && Array.isArray(parsed.tasks)) {
+                parsedTasks = parsed.tasks.map((t, i) => ({
+                    id: t.id || `task_${i + 1}`,
+                    description: t.description || 'Task',
+                    prompt: t.prompt || originalPrompt,
+                    files: t.files || [],
+                    status: 'pending',
+                    dependencies: t.dependencies || [],
+                }));
+            }
+        }
+    }
+    catch (err) {
+        console.error('[Orchestrator] Failed to parse plan JSON:', err);
+    }
+    // Fallback to single task if parsing failed
+    if (parsedTasks.length === 0) {
+        parsedTasks = [{
+                id: 'task_1',
+                description: 'Execute task',
+                prompt: originalPrompt,
+                files: [],
+                status: 'pending',
+                dependencies: [],
+            }];
+    }
+    return {
+        id: planId,
+        status: 'ready',
+        originalPrompt,
+        tasks: parsedTasks,
+        createdAt: new Date().toISOString(),
+    };
+}
+// Legacy function for backwards compatibility
+export async function generatePlan(prompt, planId, workingDir) {
+    const response = await processGektoMessage(prompt, planId, workingDir);
+    if (response.type === 'plan') {
+        return response.plan;
+    }
+    // If it returned chat, wrap in a single task (shouldn't happen with proper prompts)
+    return {
+        id: planId,
+        status: 'ready',
+        originalPrompt: prompt,
+        tasks: [{
+                id: 'task_1',
+                description: 'Execute task',
+                prompt: prompt,
+                files: [],
+                status: 'pending',
+                dependencies: [],
+            }],
+        createdAt: new Date().toISOString(),
+    };
+}
+// === Helper: Run Claude once without session ===
+function runClaudeOnce(prompt, systemPrompt, workingDir) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-p', prompt,
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--model', 'claude-haiku-4-5-20251001',
+            '--system-prompt', systemPrompt,
+            '--dangerously-skip-permissions',
+        ];
+        console.log('[Orchestrator] Running claude (haiku) for orchestration');
+        const proc = spawn('claude', args, {
+            cwd: workingDir,
+            env: process.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        proc.stdin?.end();
+        let buffer = '';
+        let resultText = '';
+        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);
+                    if (event.type === 'result' && event.result) {
+                        resultText = event.result;
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            console.error('[Orchestrator] stderr:', data.toString());
+        });
+        proc.on('close', (code) => {
+            console.log('[Orchestrator] Plan generation complete, code:', code);
+            // Try to parse any remaining buffer
+            if (buffer.trim()) {
+                try {
+                    const event = JSON.parse(buffer);
+                    if (event.type === 'result' && event.result) {
+                        resultText = event.result;
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+            }
+            if (resultText) {
+                resolve(resultText);
+            }
+            else {
+                reject(new Error('No result from plan generation'));
+            }
+        });
+        proc.on('error', (err) => {
+            console.error('[Orchestrator] Spawn error:', err);
+            reject(err);
+        });
+    });
+}
+// === Delegation Helper ===
+export function shouldDelegateToTask(prompt, tasks) {
+    // Simple heuristic: check if prompt mentions any file from a task
+    const lowerPrompt = prompt.toLowerCase();
+    for (const task of tasks) {
+        for (const file of task.files) {
+            const fileName = file.split('/').pop()?.toLowerCase() || '';
+            if (fileName && lowerPrompt.includes(fileName)) {
+                return task;
+            }
+        }
+    }
+    return null;
+}

package/dist/agents/gektoPersistent.js

@@ -0,0 +1,239 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+// === Opus Worker (persistent, for direct mode) ===
+const OPUS_SYSTEM_PROMPT = `You are Gekto, a friendly and capable coding assistant. You help users with their coding tasks directly.
+
+Be concise and helpful. When you need to make changes, use the available tools. Explain what you're doing briefly.
+
+For greetings and questions, just respond naturally without using tools.
+
+IMPORTANT: You can ONLY use Read, Write, Edit, Glob, and Grep tools. You CANNOT use Bash or Task tools - they are disabled.`;
+let opusProcess = null;
+let opusReady = false;
+let opusLoading = false;
+let opusPendingResolve = null;
+let opusBuffer = '';
+let opusCallbacks = null;
+let opusCurrentTool = null;
+// Session ID for persistent history - generated once and shared across all Gekto calls
+// This allows both direct mode (persistent process) and plan mode (one-shot calls) to share history
+let gektoSessionId = randomUUID();
+let workingDir = process.cwd();
+let stateChangeCallback = null;
+// === Initialization ===
+export function initGekto(cwd, onStateChange) {
+    workingDir = cwd;
+    stateChangeCallback = onStateChange || null;
+    // Start Opus process
+    spawnOpus();
+}
+export function getGektoState() {
+    if (opusLoading)
+        return 'loading';
+    if (opusReady)
+        return 'ready';
+    return 'loading';
+}
+// === Opus Process ===
+function spawnOpus() {
+    if (opusProcess)
+        return;
+    opusLoading = true;
+    opusReady = false;
+    updateState();
+    const args = [
+        '--input-format', 'stream-json',
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--model', 'claude-opus-4-5-20251101',
+        '--system-prompt', OPUS_SYSTEM_PROMPT,
+        '--dangerously-skip-permissions',
+        '--disallowed-tools', 'Bash', 'Task',
+        '--session-id', gektoSessionId,
+    ];
+    opusProcess = spawn('claude', args, {
+        cwd: workingDir,
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    opusProcess.stdout.on('data', (data) => {
+        opusBuffer += data.toString();
+        const lines = opusBuffer.split('\n');
+        opusBuffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                handleOpusEvent(event);
+            }
+            catch {
+                // Ignore non-JSON lines
+            }
+        }
+    });
+    opusProcess.stderr.on('data', () => {
+        // Ignore stderr
+    });
+    opusProcess.on('close', () => {
+        opusProcess = null;
+        opusReady = false;
+        opusLoading = true;
+        updateState();
+        if (opusPendingResolve) {
+            opusPendingResolve('Process restarting, please try again.');
+            opusPendingResolve = null;
+        }
+        // Auto-restart
+        setTimeout(spawnOpus, 1000);
+    });
+    opusProcess.on('error', () => {
+        opusProcess = null;
+        opusReady = false;
+        opusLoading = true;
+        updateState();
+    });
+    // Warm up: send a quick message to trigger ready state
+    setTimeout(() => {
+        if (opusProcess && !opusReady) {
+            const warmup = { type: 'user', message: { role: 'user', content: 'hi' } };
+            opusProcess.stdin.write(JSON.stringify(warmup) + '\n');
+        }
+    }, 500);
+}
+function handleOpusEvent(event) {
+    // Result event means process is working
+    if (event.type === 'result') {
+        if (!opusReady) {
+            opusReady = true;
+            opusLoading = false;
+            updateState();
+        }
+    }
+    // Tool use detection from assistant message
+    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) {
+                    opusCurrentTool = block.name;
+                    opusCallbacks?.onToolStart?.(block.name, block.input);
+                }
+            }
+        }
+    }
+    // Tool result (tool completed)
+    if (event.type === 'user' && event.message) {
+        const message = event.message;
+        if (message.content) {
+            for (const block of message.content) {
+                if (block.type === 'tool_result' && opusCurrentTool) {
+                    opusCallbacks?.onToolEnd?.(opusCurrentTool);
+                    opusCurrentTool = null;
+                }
+            }
+        }
+    }
+    // Text streaming
+    if (event.type === 'content_block_delta') {
+        const delta = event.delta;
+        if (delta?.type === 'text_delta' && delta.text) {
+            opusCallbacks?.onText?.(delta.text);
+        }
+    }
+    // Final result
+    if (event.type === 'result' && event.result) {
+        if (opusPendingResolve) {
+            opusPendingResolve(event.result);
+            opusPendingResolve = null;
+        }
+    }
+}
+async function sendToOpus(prompt, callbacks) {
+    if (!opusProcess || !opusReady) {
+        spawnOpus();
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    if (!opusProcess) {
+        return 'Gekto is starting up, please try again.';
+    }
+    opusCallbacks = callbacks;
+    opusCurrentTool = null;
+    return new Promise((resolve) => {
+        opusPendingResolve = (result) => {
+            opusCallbacks = null;
+            resolve(result);
+        };
+        const inputMessage = {
+            type: 'user',
+            message: { role: 'user', content: prompt },
+        };
+        opusProcess.stdin.write(JSON.stringify(inputMessage) + '\n');
+        // Timeout after 5 min for complex tasks
+        setTimeout(() => {
+            if (opusPendingResolve) {
+                opusPendingResolve('Task timed out. Please try breaking it into smaller steps.');
+                opusPendingResolve = null;
+            }
+        }, 300000);
+    });
+}
+// 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();
+    // Plan mode - return immediately, caller will use gektoTools.ts for planning
+    if (mode === 'plan') {
+        return {
+            mode: 'plan',
+            message: 'Creating plan...',
+        };
+    }
+    // Direct mode - use Opus
+    const result = await sendToOpus(prompt, callbacks || {});
+    const workMs = Date.now() - startTime;
+    callbacks?.onResult?.(result);
+    return {
+        mode: 'direct',
+        message: result,
+        workMs,
+    };
+}
+// === State Management ===
+function updateState() {
+    const state = getGektoState();
+    stateChangeCallback?.(state);
+}
+export function isGektoReady() {
+    return opusReady;
+}
+// Set/update state change callback (for reconnections)
+export function setStateCallback(callback) {
+    stateChangeCallback = callback;
+}
+// Get current session ID (shared between direct and plan modes)
+export function getGektoSessionId() {
+    return gektoSessionId;
+}
+// Reset session to start fresh (clears history)
+export function resetGektoSession() {
+    gektoSessionId = randomUUID();
+    // Kill current process to force restart with new session
+    if (opusProcess) {
+        opusProcess.kill('SIGTERM');
+    }
+}
+// === Abort current task (like pressing ESC in CLI) ===
+export function abortGekto() {
+    let aborted = false;
+    // Send SIGINT to interrupt current Opus task (like Ctrl+C / ESC)
+    if (opusProcess && opusPendingResolve) {
+        opusProcess.kill('SIGINT');
+        // Resolve the pending promise so caller doesn't hang
+        opusPendingResolve('Task was stopped.');
+        opusPendingResolve = null;
+        opusCallbacks = null;
+        opusCurrentTool = null;
+        aborted = true;
+    }
+    return aborted;
+}

package/dist/agents/gektoSimple.js

@@ -0,0 +1,137 @@
+import { spawn } from 'child_process';
+// Simple Gekto - just chat with Haiku and return text response
+const GEKTO_SYSTEM_PROMPT = `You are Gekto, a friendly coding assistant. Decide what to do with the user's message.
+
+Options:
+1. answer - For greetings, questions, conversation. Just reply naturally.
+2. write_code - For coding tasks that need implementation.
+3. plan - For complex tasks that need breaking into steps.
+
+Respond with JSON: { "action": "answer|write_code|plan", "response": "your message" }
+
+Examples:
+- "yo" -> { "action": "answer", "response": "Hey! What can I help you with?" }
+- "add dark mode" -> { "action": "write_code", "response": "I'll spawn an agent to add dark mode." }
+- "refactor the auth system" -> { "action": "plan", "response": "Let me break this down into steps..." }
+
+Always respond with valid JSON.`;
+export async function processSimple(prompt, workingDir) {
+    const startTime = Date.now();
+    try {
+        const rawResponse = await runHaiku(prompt, GEKTO_SYSTEM_PROMPT, workingDir);
+        const durationMs = Date.now() - startTime;
+        // Parse JSON response
+        const jsonMatch = rawResponse.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                type: 'chat',
+                action: parsed.action || 'answer',
+                message: parsed.response || rawResponse,
+                durationMs,
+            };
+        }
+        // Fallback: use raw response as message
+        return {
+            type: 'chat',
+            action: 'answer',
+            message: rawResponse,
+            durationMs,
+        };
+    }
+    catch {
+        const durationMs = Date.now() - startTime;
+        // Always return a friendly message, never an error
+        return {
+            type: 'chat',
+            action: 'answer',
+            message: "Hey! Something went wrong on my end. Could you try again?",
+            durationMs,
+        };
+    }
+}
+function runHaiku(prompt, systemPrompt, workingDir) {
+    return new Promise((resolve) => {
+        const args = [
+            '-p', prompt,
+            '--output-format', 'stream-json',
+            '--model', 'claude-haiku-4-5-20251001',
+            '--system-prompt', systemPrompt,
+            '--dangerously-skip-permissions',
+        ];
+        const proc = spawn('claude', args, {
+            cwd: workingDir,
+            env: process.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        proc.stdin?.end();
+        let buffer = '';
+        let resultText = '';
+        let allOutput = '';
+        proc.stdout.on('data', (data) => {
+            const chunk = data.toString();
+            buffer += chunk;
+            allOutput += chunk;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    // Capture any text content
+                    if (event.type === 'result' && event.result) {
+                        resultText = event.result;
+                    }
+                    else if (event.type === 'assistant' && event.message?.content) {
+                        // Also check for assistant message format
+                        for (const block of event.message.content) {
+                            if (block.type === 'text') {
+                                resultText = block.text;
+                            }
+                        }
+                    }
+                    else if (event.type === 'content_block_delta' && event.delta?.text) {
+                        resultText += event.delta.text;
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            console.error('[GektoSimple] stderr:', data.toString());
+        });
+        proc.on('close', (code) => {
+            console.log('[GektoSimple] Exit code:', code);
+            // Try to parse remaining buffer
+            if (buffer.trim()) {
+                try {
+                    const event = JSON.parse(buffer);
+                    if (event.type === 'result' && event.result) {
+                        resultText = event.result;
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+            }
+            // Always resolve with something
+            if (resultText) {
+                console.log('[GektoSimple] Result:', resultText.substring(0, 100));
+                resolve(resultText);
+            }
+            else {
+                // Log all output for debugging
+                console.log('[GektoSimple] No result found. All output:', allOutput.substring(0, 500));
+                resolve('{ "action": "answer", "response": "Hey there! How can I help?" }');
+            }
+        });
+        proc.on('error', (err) => {
+            console.error('[GektoSimple] Spawn error:', err);
+            // Still resolve with a default response
+            resolve('{ "action": "answer", "response": "Hey! How can I help you today?" }');
+        });
+    });
+}