gekto 0.0.1

package/dist/agents/gektoTools.js

@@ -0,0 +1,223 @@
+import { spawn } from 'child_process';
+// === Tool Definitions ===
+const TOOLS_DESCRIPTION = `
+Available tools:
+1. chat - For greetings, questions, conversations (not coding tasks)
+2. build - For coding tasks: features, bug fixes, refactoring, file changes
+3. remove - For removing/cleaning up worker agents
+`;
+const GEKTO_SYSTEM_PROMPT = `You are Gekto, a task orchestration assistant. You MUST respond with ONLY valid JSON - no other text.
+
+${TOOLS_DESCRIPTION}
+
+Analyze the user message and respond with the appropriate tool as JSON.
+
+JSON FORMAT (respond with ONLY this, no markdown, no explanation):
+{"tool":"chat"|"build"|"remove","params":{...}}
+
+Tool params:
+- chat: {"message":"your response"}
+- build: {"tasks":[{"id":"task_1","description":"Brief desc","prompt":"Detailed prompt for worker agent","files":["path/file.ts"],"dependencies":[]}]}
+- remove: {"target":"all"|"workers"|"completed"|["id1","id2"]}
+
+Examples (respond EXACTLY like this):
+"hey" -> {"tool":"chat","params":{"message":"Hey! How can I help?"}}
+"add dark mode" -> {"tool":"build","params":{"tasks":[{"id":"task_1","description":"Add dark mode toggle","prompt":"Implement dark mode toggle in the settings","files":[],"dependencies":[]}]}}
+"remove all agents" -> {"tool":"remove","params":{"target":"all"}}
+"spawn 3 agents" -> {"tool":"build","params":{"tasks":[{"id":"task_1","description":"Agent 1","prompt":"Task 1","files":[],"dependencies":[]},{"id":"task_2","description":"Agent 2","prompt":"Task 2","files":[],"dependencies":[]},{"id":"task_3","description":"Agent 3","prompt":"Task 3","files":[],"dependencies":[]}]}}
+
+CRITICAL: Output ONLY the JSON object. No markdown code blocks. No explanation. Just the raw JSON.`;
+// === Main Processing Function ===
+export async function processWithTools(prompt, planId, workingDir, activeAgents = [], callbacks) {
+    // Add context about active agents for remove decisions
+    const contextPrompt = activeAgents.length > 0
+        ? `${prompt}\n\n[Context: Active agents: ${activeAgents.map(a => a.lizardId).join(', ')}]`
+        : prompt;
+    const result = await runClaudeOnce(contextPrompt, GEKTO_SYSTEM_PROMPT, workingDir, callbacks);
+    // Parse the JSON response
+    try {
+        // Try to find JSON - handle markdown code blocks too
+        let jsonStr = result.trim();
+        // Strip markdown code blocks if present
+        if (jsonStr.startsWith('```json')) {
+            jsonStr = jsonStr.replace(/^```json\s*/, '').replace(/\s*```$/, '');
+        }
+        else if (jsonStr.startsWith('```')) {
+            jsonStr = jsonStr.replace(/^```\s*/, '').replace(/\s*```$/, '');
+        }
+        // Find JSON object
+        const jsonMatch = jsonStr.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return { type: 'chat', message: result.trim() || "I'm here to help! What would you like me to work on?" };
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        const tool = parsed.tool;
+        const params = parsed.params || {};
+        switch (tool) {
+            case 'chat':
+                return {
+                    type: 'chat',
+                    message: params.message || 'Hello!',
+                };
+            case 'build':
+                const plan = createPlanFromTasks(params.tasks || [], planId, prompt);
+                return {
+                    type: 'build',
+                    plan,
+                };
+            case 'remove':
+                return {
+                    type: 'remove',
+                    removedAgents: resolveRemoveTarget(params.target, activeAgents),
+                };
+            default:
+                return { type: 'chat', message: "I'm not sure how to help with that." };
+        }
+    }
+    catch {
+        // Use the raw response as a chat message instead of showing an error
+        return { type: 'chat', message: result.trim() || "I'm here to help! What would you like me to work on?" };
+    }
+}
+// === Helper Functions ===
+function createPlanFromTasks(tasks, planId, originalPrompt) {
+    // Extract taskId from planId (planId format: "plan_test_123456")
+    // taskId should be "test_123456" for task IDs like "test_123456_1"
+    const taskId = planId.replace(/^plan_/, '');
+    // Use same format as hardcoded Test button: test_X_1, test_X_2, etc.
+    const parsedTasks = tasks.map((t, i) => ({
+        id: `${taskId}_${i + 1}`,
+        description: t.description || 'Task',
+        prompt: t.prompt || originalPrompt,
+        files: t.files || [],
+        status: 'pending',
+        dependencies: t.dependencies || [],
+    }));
+    // Fallback to single task if empty
+    if (parsedTasks.length === 0) {
+        parsedTasks.push({
+            id: `${taskId}_1`,
+            description: 'Execute task',
+            prompt: originalPrompt,
+            files: [],
+            status: 'pending',
+            dependencies: [],
+        });
+    }
+    return {
+        id: planId,
+        status: 'ready',
+        originalPrompt,
+        tasks: parsedTasks,
+        createdAt: new Date().toISOString(),
+    };
+}
+function resolveRemoveTarget(target, activeAgents) {
+    if (Array.isArray(target)) {
+        // Specific agent IDs
+        return target;
+    }
+    switch (target) {
+        case 'all':
+            // All agents (including regular lizards, but not master)
+            return activeAgents.filter(a => a.lizardId !== 'master').map(a => a.lizardId);
+        case 'workers':
+            // Only worker agents (by flag or by ID prefix)
+            return activeAgents.filter(a => a.isWorker || a.lizardId.startsWith('worker_')).map(a => a.lizardId);
+        case 'completed':
+            // This would need status info - for now return workers
+            return activeAgents.filter(a => a.isWorker || a.lizardId.startsWith('worker_')).map(a => a.lizardId);
+        default:
+            return [];
+    }
+}
+// === Claude Helper ===
+function runClaudeOnce(prompt, systemPrompt, workingDir, callbacks) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-p', prompt,
+            '--output-format', 'stream-json',
+            '--verbose',
+            '--model', 'claude-opus-4-5-20251101',
+            '--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 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);
+                    // Stream tool events
+                    if (event.type === 'assistant' && event.message?.content) {
+                        for (const block of event.message.content) {
+                            if (block.type === 'tool_use' && block.name) {
+                                currentTool = block.name;
+                                callbacks?.onToolStart?.(block.name, block.input);
+                            }
+                        }
+                    }
+                    // Tool completed
+                    if (event.type === 'user' && event.message?.content) {
+                        for (const block of event.message.content) {
+                            if (block.type === 'tool_result' && currentTool) {
+                                callbacks?.onToolEnd?.(currentTool);
+                                currentTool = null;
+                            }
+                        }
+                    }
+                    // Text streaming
+                    if (event.type === 'content_block_delta') {
+                        const delta = event.delta;
+                        if (delta?.type === 'text_delta' && delta.text) {
+                            callbacks?.onText?.(delta.text);
+                        }
+                    }
+                    if (event.type === 'result' && event.result) {
+                        resultText = event.result;
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        });
+        let stderrOutput = '';
+        proc.stderr.on('data', (data) => {
+            stderrOutput += data.toString();
+        });
+        proc.on('close', (code) => {
+            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 {
+                const errorMsg = stderrOutput || `Process exited with code ${code}`;
+                reject(new Error(`No result from Gekto: ${errorMsg}`));
+            }
+        });
+        proc.on('error', reject);
+    });
+}

package/dist/proxy.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { parseArgs } from 'util';
+import { setupTerminalWebSocket } from './terminal.js';
+import { setupAgentWebSocket } from './agents/agentWebSocket.js';
+import { initStore, getData, setData } from './store.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Parse CLI arguments
+const { values: args } = parseArgs({
+    options: {
+        port: { type: 'string', short: 'p' },
+        target: { type: 'string', short: 't' },
+        help: { type: 'boolean', short: 'h' },
+    },
+    strict: false,
+});
+if (args.help) {
+    console.log(`
+  Gekto Proxy - Inject widget into any web app
+
+  Usage:
+    bun gekto.ts --target 3000
+    bun gekto.ts -t 3000 -p 8080
+
+  Options:
+    -t, --target  Target app port (required)
+    -p, --port    Proxy port (default: 3200)
+    -h, --help    Show this help
+  `);
+    process.exit(0);
+}
+// Only require --target for bundled version (not dev mode)
+if (!args.target && !process.env.TARGET_PORT && !process.env.GEKTO_DEV) {
+    console.error('Error: --target port is required\n');
+    console.error('Usage: bun gekto.ts --target 3000');
+    process.exit(1);
+}
+// Configuration
+const PROXY_PORT = parseInt(String(args.port ?? process.env.PORT ?? '3200'), 10);
+const TARGET_PORT = parseInt(String(args.target ?? process.env.TARGET_PORT ?? '5173'), 10);
+const WIDGET_PORT = parseInt(process.env.WIDGET_PORT ?? '5174', 10);
+const DEV_MODE = process.env.GEKTO_DEV === '1';
+// Initialize store
+initStore();
+// Widget paths - in dev mode use source, in production use bundled widget folder
+const WIDGET_DIST_PATH = DEV_MODE
+    ? path.resolve(__dirname, '../../widget/dist')
+    : path.resolve(__dirname, './widget');
+const WIDGET_JS_PATH = path.join(WIDGET_DIST_PATH, 'gekto-widget.iife.js');
+const WIDGET_CSS_PATH = path.join(WIDGET_DIST_PATH, 'style.css');
+// Load widget bundle
+function loadWidgetBundle() {
+    try {
+        const js = fs.readFileSync(WIDGET_JS_PATH, 'utf8');
+        const css = fs.existsSync(WIDGET_CSS_PATH)
+            ? fs.readFileSync(WIDGET_CSS_PATH, 'utf8')
+            : '';
+        return { js, css };
+    }
+    catch (err) {
+        console.error('❌ Could not load widget bundle:', err);
+        return { js: '// Widget bundle not found', css: '' };
+    }
+}
+// Generate injection script
+function getInjectionScript() {
+    if (DEV_MODE) {
+        // In dev mode, load as ES module from widget dev server
+        return `
+<!-- Gekto Widget (dev) -->
+<script type="module" id="gekto-widget" src="http://localhost:${WIDGET_PORT}/src/main.tsx"></script>
+`;
+    }
+    // In production, load IIFE bundle
+    return `
+<!-- Gekto Widget -->
+<script id="gekto-widget" src="/__gekto/widget.js"></script>
+`;
+}
+const server = http.createServer((req, res) => {
+    const url = req.url || '/';
+    // API: Get lizards (must be before widget handling)
+    if (url === '/__gekto/api/lizards' && req.method === 'GET') {
+        const lizards = getData('lizards') || [];
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(lizards));
+        return;
+    }
+    // API: Save lizards (must be before widget handling)
+    if (url === '/__gekto/api/lizards' && req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', () => {
+            try {
+                const lizards = JSON.parse(body);
+                setData('lizards', lizards);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true }));
+            }
+            catch (err) {
+                console.error('[Store] Failed to save lizards:', err);
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            }
+        });
+        return;
+    }
+    // API: Get chat history for a lizard
+    const chatGetMatch = url.match(/^\/__gekto\/api\/chats\/([^/]+)$/);
+    if (chatGetMatch && req.method === 'GET') {
+        const lizardId = chatGetMatch[1];
+        const allChats = getData('chats') || {};
+        const messages = allChats[lizardId] || [];
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(messages));
+        return;
+    }
+    // API: Save chat history for a lizard
+    const chatPostMatch = url.match(/^\/__gekto\/api\/chats\/([^/]+)$/);
+    if (chatPostMatch && req.method === 'POST') {
+        const lizardId = chatPostMatch[1];
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', () => {
+            try {
+                const messages = JSON.parse(body);
+                const allChats = getData('chats') || {};
+                allChats[lizardId] = messages;
+                setData('chats', allChats);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true }));
+            }
+            catch (err) {
+                console.error('[Store] Failed to save chat:', err);
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            }
+        });
+        return;
+    }
+    // Serve widget assets - proxy to widget dev server or serve from dist
+    if (url.startsWith('/__gekto/')) {
+        if (DEV_MODE) {
+            // In dev mode, if widget.js is requested, return a module loader script
+            // This handles cases where the non-module script tag is cached
+            if (url === '/__gekto/widget.js') {
+                res.writeHead(200, { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache' });
+                res.end(`
+          // Dev mode: dynamically load as ES module
+          const script = document.createElement('script');
+          script.type = 'module';
+          script.src = 'http://localhost:${WIDGET_PORT}/src/main.tsx';
+          document.head.appendChild(script);
+        `);
+                return;
+            }
+            // Proxy other widget assets to widget dev server for HMR
+            const widgetPath = url.replace('/__gekto/', '/@fs' + path.resolve(__dirname, '../../widget/') + '/');
+            const widgetReq = http.request({
+                hostname: 'localhost',
+                port: WIDGET_PORT,
+                path: widgetPath,
+                method: 'GET',
+                headers: { host: `localhost:${WIDGET_PORT}` }
+            }, (widgetRes) => {
+                const headers = {};
+                for (const [key, value] of Object.entries(widgetRes.headers)) {
+                    headers[key] = value;
+                }
+                res.writeHead(widgetRes.statusCode || 200, headers);
+                widgetRes.pipe(res);
+            });
+            widgetReq.on('error', () => {
+                // Fallback to dist if widget dev server not available
+                res.writeHead(200, { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache' });
+                const { js } = loadWidgetBundle();
+                res.end(js);
+            });
+            widgetReq.end();
+            return;
+        }
+        else {
+            // Production: serve from dist
+            if (url === '/__gekto/widget.js') {
+                res.writeHead(200, { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache' });
+                const { js } = loadWidgetBundle();
+                res.end(js);
+                return;
+            }
+            if (url === '/__gekto/widget.css') {
+                res.writeHead(200, { 'Content-Type': 'text/css', 'Cache-Control': 'no-cache' });
+                const { css } = loadWidgetBundle();
+                res.end(css);
+                return;
+            }
+        }
+    }
+    // Proxy request to target
+    // Strip headers that prevent HTML injection from working
+    const forwardHeaders = {
+        ...req.headers,
+        host: `localhost:${TARGET_PORT}`
+    };
+    delete forwardHeaders['accept-encoding']; // Disable compression so we can read HTML
+    delete forwardHeaders['if-none-match']; // Prevent 304 responses
+    delete forwardHeaders['if-modified-since'];
+    const proxyReq = http.request({
+        hostname: 'localhost',
+        port: TARGET_PORT,
+        path: url,
+        method: req.method,
+        headers: forwardHeaders
+    }, (proxyRes) => {
+        const contentType = proxyRes.headers['content-type'] || '';
+        const isHtml = contentType.includes('text/html');
+        if (isHtml) {
+            // Buffer HTML response and inject widget
+            const chunks = [];
+            proxyRes.on('data', (chunk) => chunks.push(chunk));
+            proxyRes.on('end', () => {
+                let html = Buffer.concat(chunks).toString('utf8');
+                const injection = getInjectionScript();
+                if (html.includes('</body>')) {
+                    html = html.replace('</body>', `${injection}</body>`);
+                }
+                else if (html.includes('</html>')) {
+                    html = html.replace('</html>', `${injection}</html>`);
+                }
+                else {
+                    html += injection;
+                }
+                // Copy headers but remove ones that break injection
+                const headers = {};
+                const skipHeaders = ['content-length', 'transfer-encoding', 'content-encoding', 'content-security-policy', 'content-security-policy-report-only'];
+                for (const [key, value] of Object.entries(proxyRes.headers)) {
+                    if (!skipHeaders.includes(key.toLowerCase())) {
+                        headers[key] = value;
+                    }
+                }
+                res.writeHead(proxyRes.statusCode || 200, headers);
+                res.end(html);
+            });
+        }
+        else {
+            // Stream non-HTML responses directly
+            const headers = {};
+            for (const [key, value] of Object.entries(proxyRes.headers)) {
+                headers[key] = value;
+            }
+            res.writeHead(proxyRes.statusCode || 200, headers);
+            proxyRes.pipe(res);
+        }
+    });
+    proxyReq.on('error', (err) => {
+        res.writeHead(502, { 'Content-Type': 'text/html' });
+        res.end(`
+      <html>
+        <body style="font-family: system-ui; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: linear-gradient(135deg, #ff6b6b, #ff8e53);">
+          <div style="text-align: center; color: white;">
+            <h1>🔥 Proxy Error</h1>
+            <p>Could not connect to localhost:${TARGET_PORT}</p>
+            <pre style="background: rgba(0,0,0,0.2); padding: 10px; border-radius: 5px;">${err.message}</pre>
+          </div>
+        </body>
+      </html>
+    `);
+    });
+    // Forward request body
+    req.pipe(proxyReq);
+});
+// Setup terminal WebSocket (handles /__gekto/terminal)
+setupTerminalWebSocket(server);
+// Setup agent WebSocket (handles /__gekto/agent)
+setupAgentWebSocket(server);
+// Handle WebSocket upgrades for Vite HMR (skip gekto paths)
+server.on('upgrade', (req, socket, _head) => {
+    const url = req.url || '';
+    // Terminal and Agent WebSockets are handled separately
+    if (url.startsWith('/__gekto/terminal') || url.startsWith('/__gekto/agent')) {
+        return;
+    }
+    const proxyReq = http.request({
+        hostname: 'localhost',
+        port: TARGET_PORT,
+        path: req.url,
+        method: req.method,
+        headers: {
+            ...req.headers,
+            host: `localhost:${TARGET_PORT}`
+        }
+    });
+    proxyReq.on('upgrade', (proxyRes, proxySocket, _proxyHead) => {
+        socket.write('HTTP/1.1 101 Switching Protocols\r\n' +
+            Object.entries(proxyRes.headers)
+                .map(([k, v]) => `${k}: ${v}`)
+                .join('\r\n') +
+            '\r\n\r\n');
+        proxySocket.pipe(socket);
+        socket.pipe(proxySocket);
+    });
+    proxyReq.on('error', () => {
+        socket.end();
+    });
+    proxyReq.end();
+});
+server.listen(PROXY_PORT, () => {
+    console.log(`
+  Gekto Proxy Server
+
+  Proxy:  http://localhost:${PROXY_PORT}
+  Target: http://localhost:${TARGET_PORT}
+  Mode:   ${DEV_MODE ? 'development' : 'production'}${DEV_MODE ? `
+  Widget: http://localhost:${WIDGET_PORT}` : ''}
+  `);
+});

package/dist/store.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+const STORE_FILENAME = 'gekto-store.json';
+function getStorePath() {
+    return path.join(process.cwd(), STORE_FILENAME);
+}
+function createEmptyStore() {
+    const now = new Date().toISOString();
+    return {
+        version: 1,
+        createdAt: now,
+        updatedAt: now,
+        data: {},
+    };
+}
+export function initStore() {
+    const storePath = getStorePath();
+    if (!fs.existsSync(storePath)) {
+        const emptyStore = createEmptyStore();
+        fs.writeFileSync(storePath, JSON.stringify(emptyStore, null, 2), 'utf8');
+    }
+}
+export function readStore() {
+    const storePath = getStorePath();
+    if (!fs.existsSync(storePath)) {
+        initStore();
+    }
+    const content = fs.readFileSync(storePath, 'utf8');
+    return JSON.parse(content);
+}
+export function writeStore(data) {
+    const storePath = getStorePath();
+    data.updatedAt = new Date().toISOString();
+    fs.writeFileSync(storePath, JSON.stringify(data, null, 2), 'utf8');
+}
+export function getData(key) {
+    const store = readStore();
+    return store.data[key];
+}
+export function setData(key, value) {
+    const store = readStore();
+    store.data[key] = value;
+    writeStore(store);
+}
+export function deleteData(key) {
+    const store = readStore();
+    if (key in store.data) {
+        delete store.data[key];
+        writeStore(store);
+        return true;
+    }
+    return false;
+}