gekto 0.0.13 → 0.0.15

package/dist/agents/agentWebSocket.js

@@ -6,6 +6,7 @@ import { getState, mutate, mutateBatch, addClient, removeClient, sendSnapshot, g
 import { persistEntity } from '../entityStore.js';
 import fs from 'fs';
 import nodePath from 'path';
+import { getPostHog, getDistinctId } from '../posthog.js';
 let gektoInitialized = false;
 function broadcastGektoState(state) {
     const message = JSON.stringify({ type: 'gekto_state', state });
@@ -160,6 +161,11 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             type: 'kill_all_result',
                             killed: killedCount,
                         }));
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'all agents killed',
+                            properties: { killed_count: killedCount },
+                        });
                         // Notify about state changes
                         for (const session of getActiveSessions()) {
                             ws.send(JSON.stringify({ type: 'state', lizardId: session.lizardId, state: 'ready' }));
@@ -193,6 +199,11 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         mutate('activePlanId', null);
                         broadcastActivePlans();
                         broadcastActivePlanId();
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'all agents cleared',
+                            properties: { agent_count: agentIds.length },
+                        });
                         return;
                     }
                     case 'set_active_plan': {
@@ -299,6 +310,14 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                 planId: msg.planId,
                                 prompt: msg.prompt,
                             }));
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'gekto message sent',
+                                properties: {
+                                    plan_id: msg.planId,
+                                    has_images: Boolean(planImagePaths?.length),
+                                },
+                            });
                             const planResult = await processWithTools(msg.prompt, msg.planId, getWorkingDir(), getActiveSessions(), planCallbacks, msg.existingPlan, planImagePaths);
                             // Replace streamed JSON with clean message (always send to overwrite raw JSON)
                             // For delegate, the system message handles display — clear the streaming text
@@ -348,6 +367,15 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                     planId: msg.planId,
                                     plan: planResult.plan,
                                 }));
+                                getPostHog().capture({
+                                    distinctId: getDistinctId(),
+                                    event: 'plan created',
+                                    properties: {
+                                        plan_id: planResult.plan.id,
+                                        plan_title: planResult.plan.title,
+                                        action: planExistedBefore ? 'update_plan' : 'create_plan',
+                                    },
+                                });
                             }
                             else if (planResult.type === 'remove' && planResult.removedAgents) {
                                 // Remove agents from server state
@@ -412,6 +440,62 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                     }));
                                 }
                             }
+                            else if (planResult.type === 'spawn_agent' && planResult.spawn) {
+                                // Restore plan state — only delete if it was a temporary entry
+                                if (msg.planId && getState().activePlans[msg.planId]?.status === 'planning') {
+                                    if (planExistedBefore && previousStatus) {
+                                        mutate(`activePlans.${msg.planId}.status`, previousStatus);
+                                        broadcastSinglePlan(msg.planId);
+                                    }
+                                    else {
+                                        mutate(`activePlans.${msg.planId}`, undefined);
+                                        broadcastSinglePlan(msg.planId);
+                                    }
+                                }
+                                // Spin up a brand-new free agent (no plan) and hand the prompt to it.
+                                // Uses the `agent_` prefix so it shows up in the floating LizardsList swarm UI
+                                // (the `worker_` prefix is filtered out — those agents only render on the whiteboard).
+                                const { agentName, taskDescription, prompt: workerPrompt } = planResult.spawn;
+                                const suffix = `${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+                                const newAgentId = `agent_${suffix}`;
+                                const newTaskId = `task_${suffix}`;
+                                const newTask = {
+                                    id: newTaskId,
+                                    name: agentName,
+                                    description: taskDescription,
+                                    prompt: workerPrompt,
+                                    status: 'in_progress',
+                                    dependencies: [],
+                                    files: [],
+                                    assignedAgentId: newAgentId,
+                                };
+                                const newAgent = {
+                                    id: newAgentId,
+                                    taskId: newTaskId,
+                                    personaId: 'plain',
+                                    status: 'working',
+                                    name: agentName,
+                                    createdAt: new Date().toISOString(),
+                                };
+                                mutateBatch([
+                                    { path: `tasks.${newTaskId}`, value: newTask },
+                                    { path: `agents.${newAgentId}`, value: newAgent },
+                                ]);
+                                broadcastTask(newTaskId);
+                                broadcastAgent(newAgentId);
+                                // Notify the master chat so the "Delegated to <name>" badge renders.
+                                // Intentionally omit planId — this worker is a free agent, not part of any plan.
+                                ws.send(JSON.stringify({
+                                    type: 'gekto_delegate',
+                                    agentId: newAgentId,
+                                    agentName,
+                                    message: planResult.message || `Delegated to ${agentName}.`,
+                                }));
+                                // Fire-and-forget: send the prompt to the new worker's session.
+                                sendMessage(newAgentId, workerPrompt, ws).catch(err => {
+                                    console.error(`[Agent] Spawn delegate to ${newAgentId} failed:`, err);
+                                });
+                            }
                             else if (planResult.type === 'chat') {
                                 // Restore plan state — only delete if it was a temporary entry
                                 if (msg.planId && getState().activePlans[msg.planId]?.status === 'planning') {
@@ -441,6 +525,7 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         }
                         catch (err) {
                             console.error('[Agent] Gekto processing failed:', err);
+                            getPostHog().captureException(err, getDistinctId(), { plan_id: msg.planId });
                             ws.send(JSON.stringify({
                                 type: 'gekto_chat',
                                 planId: msg.planId,
@@ -531,6 +616,14 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                         planId: msg.planId,
                                         taskCount: tasks.length,
                                     }));
+                                    getPostHog().capture({
+                                        distinctId: getDistinctId(),
+                                        event: 'plan tasks generated',
+                                        properties: {
+                                            plan_id: msg.planId,
+                                            task_count: tasks.length,
+                                        },
+                                    });
                                 },
                                 onError: (error) => {
                                     ws.send(JSON.stringify({
@@ -547,6 +640,7 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         }
                         catch (err) {
                             console.error('[Agent] Task generation failed:', err);
+                            getPostHog().captureException(err, getDistinctId(), { plan_id: msg.planId });
                             ws.send(JSON.stringify({
                                 type: 'gekto_chat',
                                 planId: msg.planId,
@@ -570,9 +664,22 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             mutate(`activePlans.${msg.planId}.status`, 'executing');
                             broadcastSinglePlan(msg.planId);
                         }
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'plan executed',
+                            properties: {
+                                plan_id: msg.planId,
+                                task_count: currentState.activePlans[msg.planId]?.taskIds?.length ?? 0,
+                            },
+                        });
                         return;
                     }
                     case 'cancel_plan': {
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'plan canceled',
+                            properties: { plan_id: msg.planId },
+                        });
                         const currentState = getState();
                         const cancelPlan = currentState.activePlans[msg.planId];
                         if (cancelPlan) {
@@ -625,6 +732,15 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         ]);
                         broadcastTask(task.id);
                         broadcastAgent(agent.id);
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'worker agent spawned',
+                            properties: {
+                                agent_id: agent.id,
+                                task_id: task.id,
+                                plan_id: task.planId,
+                            },
+                        });
                         return;
                     }
                     // Client updates a chat message list — store on agent
@@ -695,6 +811,16 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             broadcastTask(msg.taskId);
                             if (agentId)
                                 broadcastAgent(agentId);
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'task completed',
+                                properties: {
+                                    task_id: msg.taskId,
+                                    task_name: taskState?.name,
+                                    plan_id: taskState?.planId,
+                                    agent_id: agentId,
+                                },
+                            });
                         }
                         return;
                     }
@@ -713,16 +839,38 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             broadcastTask(msg.taskId);
                             if (agentId)
                                 broadcastAgent(agentId);
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'task failed',
+                                properties: {
+                                    task_id: msg.taskId,
+                                    task_name: taskState?.name,
+                                    plan_id: taskState?.planId,
+                                    agent_id: agentId,
+                                    error: msg.error,
+                                },
+                            });
                         }
                         return;
                     }
                     case 'task_started': {
                         if (msg.taskId) {
+                            const taskState = getState().tasks[msg.taskId];
                             mutateBatch([
                                 { path: `tasks.${msg.taskId}.status`, value: 'in_progress' },
                                 { path: `tasks.${msg.taskId}.assignedAgentId`, value: msg.lizardId },
                             ]);
                             broadcastTask(msg.taskId);
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'task started',
+                                properties: {
+                                    task_id: msg.taskId,
+                                    task_name: taskState?.name,
+                                    plan_id: taskState?.planId,
+                                    agent_id: msg.lizardId,
+                                },
+                            });
                         }
                         return;
                     }
@@ -930,6 +1078,14 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                                 broadcastAgent(lizardId);
                             }
                             const images = msg.images;
+                            getPostHog().capture({
+                                distinctId: getDistinctId(),
+                                event: 'agent message sent',
+                                properties: {
+                                    agent_id: lizardId,
+                                    has_images: Boolean(images?.length),
+                                },
+                            });
                             await sendMessage(lizardId, msg.content, ws, images);
                         }
                         catch (err) {
@@ -943,6 +1099,11 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                         else {
                             resetSession(lizardId);
                         }
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'agent reset',
+                            properties: { agent_id: lizardId },
+                        });
                         ws.send(JSON.stringify({ type: 'state', lizardId, state: 'ready' }));
                         break;
                     case 'revert_files': {
@@ -953,6 +1114,15 @@ export function setupAgentWebSocket(server, path = '/__gekto/agent') {
                             reverted: revertResult.reverted,
                             failed: revertResult.failed,
                         }));
+                        getPostHog().capture({
+                            distinctId: getDistinctId(),
+                            event: 'files reverted',
+                            properties: {
+                                agent_id: lizardId,
+                                reverted_count: revertResult.reverted.length,
+                                failed_count: revertResult.failed.length,
+                            },
+                        });
                         // Remove reverted file changes from agent state
                         const agentState = getState().agents[lizardId];
                         if (agentState?.fileChanges) {

package/dist/agents/gektoPersistent.js

@@ -8,7 +8,7 @@ export const GEKTO_OUTPUT_SCHEMA = JSON.stringify({
     properties: {
         action: {
             type: 'string',
-            enum: ['create_plan', 'reply', 'clarify', 'remove_agents', 'update_plan', 'delegate', 'add_task'],
+            enum: ['create_plan', 'reply', 'clarify', 'remove_agents', 'update_plan', 'delegate', 'add_task', 'spawn_agent'],
         },
         message: { type: 'string' },
         title: { type: 'string' },
@@ -16,6 +16,7 @@ export const GEKTO_OUTPUT_SCHEMA = JSON.stringify({
         buildPrompt: { type: 'string' },
         target: { type: 'string' },
         agentId: { type: 'string' },
+        agentName: { type: 'string' },
         taskName: { type: 'string' },
         taskDescription: { type: 'string' },
         taskFiles: { type: 'array', items: { type: 'string' } },
@@ -40,6 +41,7 @@ How you act:
 - If the user wants to modify the active plan (marked [ACTIVE] in CURRENT STATE), use "update_plan" with the updated abstract. "update_plan" ALWAYS applies to the active plan. You MUST also include a short "message" for the chat confirming what changed.
 - If the user wants to remove agents, use "remove_agents" with a target.
 - If there is an existing agent that has context about the relevant files or task, use "delegate" with "agentId" (the agent's ID from CURRENT STATE) and "message" (a clear instruction). The agent already has session context — delegating is faster than creating a new plan. Always include a short "message" for the chat confirming what you delegated.
+- If the user wants a single piece of work handed off and no existing agent fits (e.g. they invoked "/delegate" and none of the active agents match), use "spawn_agent" — it creates one new worker without a multi-step plan. Provide: "agentName" (2-3 word descriptive name, e.g. "AuthRefactor" or "ApiDocs"), "taskDescription" (1 sentence describing what the worker will do), and "message" (the full self-contained, actionable prompt that will be sent to the new worker). Use "spawn_agent" instead of "create_plan" when the work is a single agent's job, not a multi-step plan.
 - ALWAYS research the codebase first (Read, Glob, Grep) before creating plans. Understand the project structure, frameworks, and conventions.
 
 Conflict awareness:

package/dist/agents/gektoTools.js

@@ -219,6 +219,20 @@ If the user wants to change this plan, respond with "update_plan" and the FULL u
                 delegateMessage: parsed.message,
                 message: parsed.message,
             };
+        case 'spawn_agent': {
+            const agentName = (parsed.agentName || parsed.taskName || 'Worker').trim();
+            const taskDescription = (parsed.taskDescription || parsed.message || 'Handle delegated task').trim();
+            const workerPrompt = (parsed.message || prompt).trim();
+            return {
+                type: 'spawn_agent',
+                spawn: {
+                    agentName,
+                    taskDescription,
+                    prompt: workerPrompt,
+                },
+                message: `Delegated to ${agentName}.`,
+            };
+        }
         default:
             return { type: 'chat', message: parsed.message || "I'm not sure how to help with that." };
     }

package/dist/detectClaude.js

@@ -0,0 +1,14 @@
+import { execFile } from 'node:child_process';
+import { CLAUDE_PATH } from './claudePath.js';
+export function detectClaude() {
+    return new Promise(resolve => {
+        const opts = { timeout: 3000, shell: process.platform === 'win32' };
+        execFile(CLAUDE_PATH, ['--version'], opts, (err, stdout) => {
+            if (err)
+                return resolve({ available: false });
+            const out = stdout.trim();
+            const version = (out.match(/\d+\.\d+\.\d+[^\s)]*/) || [out])[0];
+            resolve({ available: true, version, path: CLAUDE_PATH });
+        });
+    });
+}

package/dist/inspectRepo.js

@@ -0,0 +1,185 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { CLAUDE_PATH } from './claudePath.js';
+export const DEV_TEST_APP_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../test-app');
+const INSPECT_PROMPT = `You are inspecting a software project to auto-configure a dev tool called Gekto.
+
+Use Glob, Grep, and Read (read-only) to look at the project's manifest and config files. Likely candidates:
+- package.json, pyproject.toml, requirements.txt, Cargo.toml, go.mod, Gemfile, composer.json, pom.xml, build.gradle(.kts), mix.exs, *.csproj
+- vite.config.*, next.config.*, astro.config.*, nuxt.config.*, angular.json, webpack.config.*, rollup.config.*
+- .env, .env.local, .env.development
+- Dockerfile, docker-compose.yml, Procfile
+
+Return ONLY a single JSON object — no prose, no markdown fences — with exactly this shape:
+
+{
+  "language": "<primary language, lowercase: typescript, javascript, python, go, ruby, rust, java, kotlin, csharp, php, elixir, swift, etc.>",
+  "framework": "<main UI / meta-framework / app framework, lowercase — see rules below>",
+  "bundler": "<build tool, lowercase: vite, webpack, turbopack, esbuild, rollup, parcel, rspack — or null>",
+  "runtime": "<runtime, e.g. node, bun, deno, python, ruby, go, jvm, dotnet, php — or null>",
+  "packageManager": "<e.g. npm, pnpm, yarn, bun, pip, poetry, uv, cargo, gem, composer, maven, gradle — or null>",
+  "hasWebUI": true | false,
+  "port": <integer dev-server port, or null>,
+  "devCommand": "<shell command to start the dev server, e.g. 'npm run dev', 'pnpm dev', 'bun dev', 'python manage.py runserver', 'flask run', 'uvicorn app:app --reload', 'rails server' — or null if uncertain>"
+}
+
+Framework field rules (read carefully — this is the most common mistake):
+- "framework" is the **UI library or app framework**, NOT the bundler. Vite, Webpack, Turbopack, esbuild, Rollup, Parcel, Rspack are **bundlers** — they go in the "bundler" field, never in "framework".
+- For frontend projects, prefer the UI library: "react", "vue", "svelte", "solid", "preact", "lit". Detect this from package.json dependencies (e.g. presence of "react", "vue", "svelte", "solid-js").
+- If the project uses a meta-framework (which implies its own UI library), use the meta-framework name instead: "next", "nuxt", "sveltekit", "remix", "astro", "gatsby", "qwik", "angular".
+- For backend projects, use the server framework: "express", "nestjs", "fastify", "koa", "hono", "django", "flask", "fastapi", "rails", "sinatra", "laravel", "symfony", "spring-boot", "phoenix", "actix", "axum", "gin", "echo".
+- If nothing identifiable, set framework to null.
+
+Other rules:
+- "hasWebUI" is true if the project serves a web frontend that runs on a dev server. Backend-only servers, CLI tools, mobile apps, and libraries: false.
+- "port" must be an integer when hasWebUI is true. Use the explicit port from config if found; otherwise the framework/bundler default (Vite 5173, Next 3000, CRA 3000, Astro 4321, Nuxt 3000, Angular 4200, SvelteKit 5173, Webpack-dev-server 8080).
+- "port" must be null when hasWebUI is false.
+- "devCommand" should be the canonical way to start the dev server based on the package manager (check the lockfile) and the framework. For JS projects: read package.json "scripts" — prefer "dev", then "start", then "serve". Use the right package manager (pnpm/yarn/bun/npm) based on the lockfile. Set null if you can't determine it.
+- Output JSON only, nothing else.`;
+function summarizeTool(name, input) {
+    if (!input)
+        return name;
+    switch (name) {
+        case 'Read':
+            return `Reading ${String(input.file_path ?? '').split('/').pop() || input.file_path}`;
+        case 'Glob':
+            return `Searching for ${input.pattern}`;
+        case 'Grep':
+            return `Grep "${input.pattern}"${input.path ? ` in ${input.path}` : ''}`;
+        default:
+            return name;
+    }
+}
+function parseStack(text) {
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        return null;
+    try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (!parsed.language || typeof parsed.hasWebUI !== 'boolean')
+            return null;
+        const port = typeof parsed.port === 'number' ? parsed.port : undefined;
+        return {
+            language: String(parsed.language).toLowerCase(),
+            framework: parsed.framework ? String(parsed.framework).toLowerCase() : undefined,
+            bundler: parsed.bundler ? String(parsed.bundler).toLowerCase() : undefined,
+            runtime: parsed.runtime ? String(parsed.runtime).toLowerCase() : undefined,
+            packageManager: parsed.packageManager ? String(parsed.packageManager).toLowerCase() : undefined,
+            hasWebUI: parsed.hasWebUI,
+            port: parsed.hasWebUI ? port : undefined,
+            devCommand: typeof parsed.devCommand === 'string' && parsed.devCommand.trim() ? parsed.devCommand.trim() : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function inspectRepo(opts = {}) {
+    const prompt = opts.correction
+        ? `${INSPECT_PROMPT}\n\nIMPORTANT: A previous inspection was incorrect. The user said:\n"${opts.correction}"\n\nRe-inspect the project, taking this correction into account. Verify against the actual files before answering.`
+        : INSPECT_PROMPT;
+    if (opts.dry) {
+        console.log('--- inspectRepo prompt ---');
+        console.log(prompt);
+        return null;
+    }
+    const args = [
+        '-p', prompt,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--model', 'claude-opus-4-6',
+        '--dangerously-skip-permissions',
+        '--allowed-tools', 'Read,Glob,Grep',
+    ];
+    return new Promise(resolve => {
+        const proc = spawn(CLAUDE_PATH, args, {
+            cwd: opts.cwd || process.cwd(),
+            env: process.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        proc.stdin?.end();
+        const timeout = setTimeout(() => {
+            proc.kill('SIGTERM');
+        }, opts.timeoutMs ?? 60_000);
+        let buffer = '';
+        let resultText = '';
+        const handleLine = (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const event = JSON.parse(line);
+                if (event.type === 'assistant' && event.message?.content) {
+                    for (const block of event.message.content) {
+                        if (block.type === 'tool_use' && block.name) {
+                            opts.onEvent?.({
+                                type: 'tool',
+                                name: block.name,
+                                summary: summarizeTool(block.name, block.input),
+                            });
+                        }
+                        else if (block.type === 'text' && block.text) {
+                            opts.onEvent?.({ type: 'text', text: block.text });
+                        }
+                        else if (block.type === 'thinking' && block.thinking) {
+                            opts.onEvent?.({ type: 'thinking', text: block.thinking });
+                        }
+                    }
+                }
+                else if (event.type === 'result' && typeof event.result === 'string') {
+                    resultText = event.result;
+                }
+            }
+            catch {
+                // ignore parse errors on partial / non-JSON lines
+            }
+        };
+        proc.stdout.on('data', chunk => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines)
+                handleLine(line);
+        });
+        proc.stderr.on('data', () => { });
+        proc.on('close', () => {
+            clearTimeout(timeout);
+            if (buffer.trim())
+                handleLine(buffer);
+            resolve(parseStack(resultText));
+        });
+        proc.on('error', () => {
+            clearTimeout(timeout);
+            resolve(null);
+        });
+    });
+}
+export function describeStack(stack) {
+    const parts = [
+        stack.framework,
+        stack.language,
+        stack.bundler && stack.bundler !== stack.framework ? `bundler:${stack.bundler}` : null,
+        stack.runtime,
+        stack.packageManager,
+        stack.hasWebUI ? `port:${stack.port ?? '?'}` : 'no-ui',
+    ].filter(Boolean);
+    return parts.join(' · ');
+}
+// CLI entry — `bun run src/inspectRepo.ts [--dry] [--dev]`
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const dry = process.argv.includes('--dry');
+    const dev = process.argv.includes('--dev');
+    const cwd = dev ? DEV_TEST_APP_DIR : process.cwd();
+    if (dev)
+        console.log(`[inspectRepo] dev mode — inspecting ${cwd}`);
+    const result = await inspectRepo({
+        dry,
+        cwd,
+        onEvent: event => {
+            if (event.type === 'tool')
+                console.log(`  · ${event.summary}`);
+        },
+    });
+    console.log('\nInspection:', result);
+    process.exit(0);
+}