0agent 1.0.18 → 1.0.20

package/bin/0agent.js

@@ -45,7 +45,22 @@ if (cmd.startsWith('/')) {
 
 // ─── Command dispatch ────────────────────────────────────────────────────
 switch (cmd) {
-  case '':
+  case '': {
+    // No args: if configured → open chat TUI; if not → run init wizard
+    if (existsSync(CONFIG_PATH)) {
+      const { spawn: spawnC } = await import('node:child_process');
+      const chatSc = resolve(dirname(new URL(import.meta.url).pathname), 'chat.js');
+      if (existsSync(chatSc)) {
+        const p = spawnC(process.execPath, [chatSc], { stdio: 'inherit' });
+        await new Promise(r => p.on('close', r));
+      } else {
+        await runChat();
+      }
+    } else {
+      await runInit();
+    }
+    break;
+  }
   case 'init':
     await runInit();
     break;
@@ -66,9 +81,18 @@ switch (cmd) {
     await runTask(args.slice(1));
     break;
 
-  case 'chat':
-    await runChat();
+  case 'chat': {
+    // Launch the persistent Claude Code-style TUI
+    const { spawn: spawnChat } = await import('node:child_process');
+    const chatScript = resolve(dirname(new URL(import.meta.url).pathname), 'chat.js');
+    if (existsSync(chatScript)) {
+      const p = spawnChat(process.execPath, [chatScript], { stdio: 'inherit' });
+      await new Promise(r => p.on('close', r));
+    } else {
+      await runChat(); // fallback to old simple REPL
+    }
     break;
+  }
 
   case 'skill':
     await runSkillCommand(args.slice(1));
@@ -112,20 +136,28 @@ switch (cmd) {
 // Arrow-key select using enquirer (falls back to number input if not available)
 async function arrowSelect(message, choices, initial = 0) {
   try {
-    const { Select } = await import('enquirer');
-    const prompt = new Select({ message, choices: choices.map((c, i) => ({ name: c, value: i })), initial });
+    const mod = await import('enquirer');
+    const Enquirer = mod.default ?? mod;
+    const prompt = new Enquirer.Select({
+      message,
+      choices: choices.map((c, i) => ({ name: c, value: String(i) })),
+      initial,
+    });
     const answer = await prompt.run();
-    return choices.indexOf(answer);
+    // answer is the name string — find its index
+    const idx = choices.indexOf(answer);
+    return idx >= 0 ? idx : initial;
   } catch {
-    // Fallback: number-based selection (no enquirer)
+    // Fallback: number-based selection if enquirer unavailable or non-TTY
     return choose(message, choices, initial);
   }
 }
 
 async function arrowInput(message, initial = '') {
   try {
-    const { Input } = await import('enquirer');
-    const prompt = new Input({ message, initial });
+    const mod = await import('enquirer');
+    const Enquirer = mod.default ?? mod;
+    const prompt = new Enquirer.Input({ message, initial });
     return await prompt.run();
   } catch {
     return ask(`  ${message}: `);
@@ -134,8 +166,9 @@ async function arrowInput(message, initial = '') {
 
 async function arrowPassword(message) {
   try {
-    const { Password } = await import('enquirer');
-    const prompt = new Password({ message });
+    const mod = await import('enquirer');
+    const Enquirer = mod.default ?? mod;
+    const prompt = new Enquirer.Password({ message });
     return await prompt.run();
   } catch {
     return ask(`  ${message}: `);

package/bin/chat.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+/**
+ * 0agent Chat — persistent, streaming TUI.
+ *
+ * Stays open like Claude Code. Commands start with /.
+ * Responses stream word-by-word. Subagents visible inline.
+ * /model to switch. /key to add provider keys. Never forgets previous keys.
+ */
+
+import { createInterface } from 'node:readline';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import YAML from 'yaml';
+
+const AGENT_DIR   = resolve(homedir(), '.0agent');
+const CONFIG_PATH = resolve(AGENT_DIR, 'config.yaml');
+const BASE_URL    = process.env['ZEROAGENT_URL'] ?? 'http://localhost:4200';
+
+// ─── ANSI helpers ─────────────────────────────────────────────────────────────
+const C = {
+  reset:   '\x1b[0m',
+  bold:    '\x1b[1m',
+  dim:     '\x1b[2m',
+  cyan:    '\x1b[36m',
+  green:   '\x1b[32m',
+  yellow:  '\x1b[33m',
+  red:     '\x1b[31m',
+  blue:    '\x1b[34m',
+  magenta: '\x1b[35m',
+  white:   '\x1b[37m',
+};
+const fmt = (color, text) => `${color}${text}${C.reset}`;
+const clearLine = () => process.stdout.write('\r\x1b[2K');
+
+// ─── Config management ────────────────────────────────────────────────────────
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  try { return YAML.parse(readFileSync(CONFIG_PATH, 'utf8')); } catch { return null; }
+}
+
+function saveConfig(cfg) {
+  writeFileSync(CONFIG_PATH, YAML.stringify(cfg), 'utf8');
+}
+
+function getCurrentProvider(cfg) {
+  const def = cfg?.llm_providers?.find(p => p.is_default) ?? cfg?.llm_providers?.[0];
+  return def ?? null;
+}
+
+// ─── State ────────────────────────────────────────────────────────────────────
+let cfg         = loadConfig();
+let sessionId   = null;  // current chat session
+let streaming   = false; // mid-token-stream
+let ws          = null;  // WebSocket
+let wsReady     = false;
+let pendingResolve = null;
+let lineBuffer  = '';    // accumulated line for stream
+const history   = [];    // command history for arrow keys
+
+// ─── Header ──────────────────────────────────────────────────────────────────
+function printHeader() {
+  const provider = getCurrentProvider(cfg);
+  const modelStr = provider ? `${provider.provider}/${provider.model}` : 'no model';
+  console.log();
+  console.log(fmt(C.bold, '  0agent') + fmt(C.dim, ` — ${modelStr}`));
+  console.log(fmt(C.dim, '  Type a task, or /help for commands. Ctrl+C to exit.\n'));
+}
+
+function printInsights() {
+  fetch(`${BASE_URL}/api/insights?seen=false`)
+    .then(r => r.json())
+    .then(insights => {
+      if (!Array.isArray(insights) || insights.length === 0) return;
+      console.log(fmt(C.yellow, `  ${insights.length} insight${insights.length > 1 ? 's' : ''} since last session:`));
+      for (const ins of insights.slice(0, 2)) {
+        console.log(`  ${fmt(C.dim, '›')} ${ins.summary}`);
+        if (ins.suggested_action) console.log(`    ${fmt(C.cyan, '→')} ${fmt(C.dim, ins.suggested_action)}`);
+      }
+      console.log();
+    })
+    .catch(() => {});
+}
+
+// ─── WebSocket ────────────────────────────────────────────────────────────────
+async function connectWS() {
+  try {
+    const { default: WS } = await import('ws').catch(() => ({ default: globalThis.WebSocket }));
+    ws = new WS(`ws://localhost:4200/ws`);
+    ws.on('open', () => {
+      wsReady = true;
+      ws.send(JSON.stringify({ type: 'subscribe', topics: ['sessions', 'graph', 'insights'] }));
+    });
+    ws.on('message', data => handleWsEvent(JSON.parse(data.toString())));
+    ws.on('close', () => { wsReady = false; setTimeout(connectWS, 2000); });
+    ws.on('error', () => { wsReady = false; });
+  } catch {}
+}
+
+function handleWsEvent(event) {
+  if (!sessionId || event.session_id !== sessionId) return;
+
+  switch (event.type) {
+    case 'session.step': {
+      if (streaming) { process.stdout.write('\n'); streaming = false; }
+      console.log(`  ${fmt(C.dim, '›')} ${event.step}`);
+      break;
+    }
+    case 'session.token': {
+      if (!streaming) { process.stdout.write('\n  '); streaming = true; }
+      process.stdout.write(event.token);
+      lineBuffer += event.token;
+      break;
+    }
+    case 'session.completed': {
+      if (streaming) { process.stdout.write('\n'); streaming = false; }
+      const r = event.result ?? {};
+      if (r.files_written?.length) console.log(`\n  ${fmt(C.green, '✓')} ${r.files_written.join(', ')}`);
+      if (r.tokens_used) process.stdout.write(fmt(C.dim, `\n  ${r.tokens_used} tokens · ${r.model ?? ''}\n`));
+
+      // Confirm server if port mentioned
+      confirmServer(r, lineBuffer);
+      lineBuffer = '';
+      if (pendingResolve) { pendingResolve(); pendingResolve = null; }
+      rl.prompt();
+      break;
+    }
+    case 'session.failed': {
+      if (streaming) { process.stdout.write('\n'); streaming = false; }
+      console.log(`\n  ${fmt(C.red, '✗')} ${event.error}\n`);
+      lineBuffer = '';
+      if (pendingResolve) { pendingResolve(); pendingResolve = null; }
+      rl.prompt();
+      break;
+    }
+    case 'agent.insight': {
+      // Show insight inline, non-interruptive
+      const ins = event.insight ?? {};
+      process.stdout.write(`\n  ${fmt(C.yellow, '◆')} ${ins.summary}\n`);
+      if (ins.suggested_action) process.stdout.write(`    ${fmt(C.dim, `→ ${ins.suggested_action}`)}\n`);
+      if (!streaming) rl.prompt(true);
+      break;
+    }
+    case 'graph.weight_updated': {
+      // Subtle dot — graph is learning
+      process.stdout.write(fmt(C.dim, '·'));
+      break;
+    }
+  }
+}
+
+async function confirmServer(result, output) {
+  const allText = [...(result.commands_run ?? []), output].join(' ');
+  const portMatch = allText.match(/(?:localhost:|port\s*[=:]?\s*)(\d{4,5})/i);
+  if (!portMatch) return;
+  const port = parseInt(portMatch[1], 10);
+  await new Promise(r => setTimeout(r, 1200));
+  try {
+    const res = await fetch(`http://localhost:${port}/`, { signal: AbortSignal.timeout(2000) });
+    console.log(`\n  ${fmt(C.green, '⬡')} Live at ${fmt(C.cyan, `http://localhost:${port}`)} (HTTP ${res.status})`);
+  } catch {}
+}
+
+// ─── Task submission ──────────────────────────────────────────────────────────
+async function runTask(input) {
+  let skillName, entityId;
+  let task = input;
+
+  // Parse inline flags: --skill /review, --entity sahil
+  const skillMatch = task.match(/--skill\s+([\w-]+)/);
+  if (skillMatch) { skillName = skillMatch[1]; task = task.replace(skillMatch[0], '').trim(); }
+  const entityMatch = task.match(/--entity\s+([\w-]+)/);
+  if (entityMatch) { entityId = entityMatch[1]; task = task.replace(entityMatch[0], '').trim(); }
+
+  // Slash-prefix → skill
+  if (task.startsWith('/') && !task.startsWith('/model') && !task.startsWith('/key')) {
+    const parts = task.split(/\s+/);
+    skillName = parts[0].slice(1);
+    task = parts.slice(1).join(' ') || `Run the /${skillName} skill`;
+  }
+
+  const body = { task, ...(skillName && { skill: skillName }), ...(entityId && { entity_id: entityId }) };
+
+  try {
+    const res = await fetch(`${BASE_URL}/api/sessions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const s = await res.json();
+    sessionId = s.session_id ?? s.id;
+    return new Promise(resolve => { pendingResolve = resolve; });
+  } catch (e) {
+    console.log(`  ${fmt(C.red, '✗')} ${e.message}`);
+  }
+}
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+async function handleCommand(input) {
+  const parts = input.trim().split(/\s+/);
+  const cmd = parts[0].toLowerCase();
+
+  switch (cmd) {
+    // /model — list or switch model
+    case '/model': {
+      if (!cfg) { console.log(fmt(C.red, '  No config found. Run: 0agent init')); break; }
+      const providers = cfg.llm_providers ?? [];
+      const current = getCurrentProvider(cfg);
+
+      if (parts.length === 1) {
+        // List current + available
+        console.log('\n  Current model:');
+        console.log(`    ${fmt(C.green, '●')} ${current?.provider}/${current?.model}\n`);
+        console.log('  All configured providers:');
+        for (const p of providers) {
+          const marker = p.is_default ? fmt(C.green, '●') : fmt(C.dim, '○');
+          console.log(`    ${marker} ${p.provider}/${p.model}`);
+        }
+        console.log('\n  ' + fmt(C.dim, 'Usage: /model anthropic claude-opus-4-6'));
+        console.log('  ' + fmt(C.dim, '       /model openai gpt-4o'));
+        console.log('  ' + fmt(C.dim, '       /model add anthropic sk-ant-...') + '\n');
+      } else if (parts[1] === 'add') {
+        // /model add <provider> <api-key>
+        const provider = parts[2];
+        const key = parts[3];
+        if (!provider || !key) { console.log(fmt(C.red, '  Usage: /model add <provider> <api-key>')); break; }
+        const defaultModels = { anthropic: 'claude-sonnet-4-6', openai: 'gpt-4o', xai: 'grok-3', gemini: 'gemini-2.0-flash', ollama: 'llama3.1' };
+        const existing = providers.findIndex(p => p.provider === provider);
+        if (existing >= 0) {
+          cfg.llm_providers[existing].api_key = key;
+          console.log(`  ${fmt(C.green, '✓')} Updated ${provider} API key`);
+        } else {
+          cfg.llm_providers.push({ provider, model: defaultModels[provider] ?? provider, api_key: key, is_default: false });
+          console.log(`  ${fmt(C.green, '✓')} Added ${provider}`);
+        }
+        saveConfig(cfg);
+        console.log(`  ${fmt(C.dim, 'Restart daemon for changes to take effect: 0agent stop && 0agent start')}\n`);
+      } else {
+        // /model <provider> <model>  OR  /model <provider>
+        const provider = parts[1];
+        const model    = parts[2];
+        // Set as default
+        for (const p of providers) p.is_default = false;
+        const match = providers.find(p => p.provider === provider);
+        if (match) {
+          match.is_default = true;
+          if (model) match.model = model;
+          saveConfig(cfg);
+          cfg = loadConfig();
+          console.log(`  ${fmt(C.green, '✓')} Switched to ${fmt(C.cyan, `${provider}/${match.model}`)}`);
+          console.log(`  ${fmt(C.dim, 'Restart daemon to apply: 0agent stop && 0agent start\n')}`);
+        } else {
+          console.log(`  ${fmt(C.red, '✗')} Provider "${provider}" not found. Add it first with:`);
+          console.log(`  ${fmt(C.dim, `/model add ${provider} <api-key>`)}\n`);
+        }
+      }
+      break;
+    }
+
+    // /key — add or list API keys
+    case '/key': {
+      if (!cfg) { console.log(fmt(C.red, '  No config found. Run: 0agent init')); break; }
+      if (parts.length === 1) {
+        // List masked keys
+        console.log('\n  Stored API keys:\n');
+        for (const p of cfg.llm_providers ?? []) {
+          const masked = p.api_key ? p.api_key.slice(0, 10) + '••••••' : fmt(C.dim, '(not set)');
+          console.log(`    ${p.provider.padEnd(12)} ${masked}`);
+        }
+        console.log('\n  ' + fmt(C.dim, 'Usage: /key <provider> <api-key>') + '\n');
+      } else {
+        const provider = parts[1];
+        const key      = parts[2];
+        if (!key) { console.log(fmt(C.red, `  Usage: /key ${provider} <api-key>`)); break; }
+        const match = cfg.llm_providers?.find(p => p.provider === provider);
+        if (match) {
+          match.api_key = key;
+          saveConfig(cfg);
+          cfg = loadConfig();
+          console.log(`  ${fmt(C.green, '✓')} ${provider} key updated (${key.slice(0, 8)}••••)\n`);
+        } else {
+          console.log(`  ${fmt(C.yellow, '⚠')} "${provider}" not configured. Use /model add ${provider} ${key}\n`);
+        }
+      }
+      break;
+    }
+
+    // /status
+    case '/status': {
+      try {
+        const h = await fetch(`${BASE_URL}/api/health`).then(r => r.json());
+        console.log(`\n  ${fmt(C.green, '✓')} Daemon running`);
+        console.log(`  Graph:    ${h.graph_nodes} nodes · ${h.graph_edges} edges`);
+        console.log(`  Sessions: ${h.active_sessions} active`);
+        console.log(`  Sandbox:  ${h.sandbox_backend}\n`);
+      } catch {
+        console.log(`  ${fmt(C.red, '✗')} Daemon not running. Run: 0agent start\n`);
+      }
+      break;
+    }
+
+    // /skills
+    case '/skills': {
+      try {
+        const skills = await fetch(`${BASE_URL}/api/skills`).then(r => r.json());
+        const list = Array.isArray(skills) ? skills : skills.skills ?? [];
+        console.log('\n  Available skills:\n');
+        for (const s of list.slice(0, 15)) {
+          console.log(`  ${fmt(C.cyan, `/${s.name.padEnd(20)}`)} ${fmt(C.dim, s.description?.slice(0, 55) ?? '')}`);
+        }
+        if (list.length > 15) console.log(fmt(C.dim, `  ... and ${list.length - 15} more\n`));
+        else console.log();
+      } catch { console.log(fmt(C.dim, '  Daemon not running\n')); }
+      break;
+    }
+
+    // /graph
+    case '/graph': {
+      console.log(`  ${fmt(C.cyan, 'Knowledge graph:')} ${fmt(C.dim, 'http://localhost:4200')}\n`);
+      try {
+        const { execSync } = await import('node:child_process');
+        execSync('open http://localhost:4200 2>/dev/null || xdg-open http://localhost:4200 2>/dev/null', { stdio: 'ignore' });
+      } catch {}
+      break;
+    }
+
+    // /clear
+    case '/clear':
+      process.stdout.write('\x1b[2J\x1b[H');
+      printHeader();
+      break;
+
+    // /help
+    case '/help':
+    default: {
+      console.log('\n  Commands:\n');
+      const cmds = [
+        ['/model',          'Show or switch model (/model openai gpt-4o)'],
+        ['/model add',      'Add provider key (/model add anthropic sk-ant-...)'],
+        ['/key <provider>', 'Update stored API key'],
+        ['/status',         'Daemon health + graph stats'],
+        ['/skills',         'List available skills'],
+        ['/graph',          'Open 3D knowledge graph in browser'],
+        ['/clear',          'Clear screen'],
+        ['/<skill>',        'Run a skill (/review, /build, /qa, /debug...)'],
+        ['Ctrl+C',          'Exit'],
+      ];
+      for (const [c, d] of cmds) {
+        console.log(`  ${fmt(C.cyan, c.padEnd(20))} ${fmt(C.dim, d)}`);
+      }
+      console.log();
+      break;
+    }
+  }
+}
+
+// ─── Main REPL ────────────────────────────────────────────────────────────────
+const rl = createInterface({
+  input:  process.stdin,
+  output: process.stdout,
+  prompt: `\n  ${fmt(C.cyan, '›')} `,
+  historySize: 100,
+  completer: (line) => {
+    const commands = ['/model', '/key', '/status', '/skills', '/graph', '/clear', '/help',
+      '/review', '/build', '/debug', '/qa', '/research', '/refactor', '/test-writer', '/retro'];
+    const hits = commands.filter(c => c.startsWith(line));
+    return [hits.length ? hits : commands, line];
+  },
+});
+
+// Restore history from conversations if possible
+rl.on('history', () => {});
+
+printHeader();
+printInsights();
+
+// Connect WebSocket for live events
+connectWS();
+
+// Check if daemon is running
+fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(1500) })
+  .then(() => { rl.prompt(); })
+  .catch(async () => {
+    process.stdout.write(fmt(C.dim, '  Starting daemon'));
+    // Trigger auto-start via requireDaemon-equivalent
+    const { resolve: res, existsSync: ef } = await import('node:path').then(m => m);
+    const pkgRoot = res(new URL(import.meta.url).pathname, '..', '..');
+    const bundled = res(pkgRoot, 'dist', 'daemon.mjs');
+    if (ef(bundled) && ef(CONFIG_PATH)) {
+      const { spawn } = await import('node:child_process');
+      const child = spawn(process.execPath, [bundled], { detached: true, stdio: 'ignore', env: { ...process.env, ZEROAGENT_CONFIG: CONFIG_PATH } });
+      child.unref();
+      for (let i = 0; i < 20; i++) {
+        await new Promise(r => setTimeout(r, 500));
+        process.stdout.write(fmt(C.dim, '.'));
+        try { await fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(500) }); process.stdout.write(fmt(C.green, ' ✓\n\n')); break; } catch {}
+      }
+    } else {
+      console.log(`\n  ${fmt(C.dim, 'Run: 0agent start')}\n`);
+    }
+    rl.prompt();
+  });
+
+rl.on('line', async (input) => {
+  const line = input.trim();
+  if (!line) { rl.prompt(); return; }
+
+  if (line.startsWith('/') || ['/model','/key','/status','/skills','/graph','/clear','/help'].some(c => line.startsWith(c))) {
+    await handleCommand(line);
+    rl.prompt();
+  } else {
+    await runTask(line);
+    // prompt() is called from WS handler after session.completed
+    // but fall back if WS not connected
+    if (!wsReady) rl.prompt();
+  }
+});
+
+rl.on('close', () => {
+  console.log(`\n  ${fmt(C.dim, 'Goodbye.')}\n`);
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log(`\n  ${fmt(C.dim, 'Ctrl+C — type /help for commands or Ctrl+C again to exit')}\n`);
+  rl.prompt();
+});

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "0agent",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
-    "0agent": "./bin/0agent.js"
+    "0agent": "./bin/0agent.js",
+    "0agent-chat": "./bin/chat.js"
   },
   "files": [
     "bin/",
     "dist/",
     "skills/",
-    "seeds/"
+    "seeds/",
+    "bin/chat.js"
   ],
   "scripts": {
     "build": "turbo run build",
@@ -24,6 +26,7 @@
   "dependencies": {
     "@hono/node-server": "^1.13.0",
     "better-sqlite3": "^11.6.0",
+    "enquirer": "^2.4.1",
     "hono": "^4.6.0",
     "ws": "^8.18.0",
     "yaml": "^2.6.0",