0agent 1.0.21 → 1.0.22

package/bin/0agent.js

@@ -512,10 +512,12 @@ async function streamSession(sessionId) {
 
   return new Promise((resolve) => {
     const ws = new WS(`ws://localhost:4200/ws`);
-    let streaming = false;  // true when mid-token-stream
+    let streaming = false;
+    const spinner = new Spinner('Thinking');
 
     ws.on('open', () => {
       ws.send(JSON.stringify({ type: 'subscribe', topics: ['sessions'] }));
+      spinner.start();  // show immediately on connect
     });
 
     ws.on('message', async (data) => {
@@ -525,28 +527,31 @@ async function streamSession(sessionId) {
 
         switch (event.type) {
           case 'session.step':
-            // Newline before step if we were mid-stream
+            spinner.stop();
             if (streaming) { process.stdout.write('\n'); streaming = false; }
             console.log(`  \x1b[2m›\x1b[0m ${event.step}`);
+            spinner.start(event.step.slice(0, 50));  // show next spinner with current step
             break;
           case 'session.token':
-            // Token-by-token streaming — print without newline
+            spinner.stop();  // stop spinner before first token
             if (!streaming) { process.stdout.write('\n  '); streaming = true; }
             process.stdout.write(event.token);
             break;
           case 'session.completed': {
+            spinner.stop();
             if (streaming) { process.stdout.write('\n'); streaming = false; }
             const r = event.result ?? {};
             if (r.files_written?.length) console.log(`\n  \x1b[32m✓\x1b[0m Files: ${r.files_written.join(', ')}`);
             if (r.commands_run?.length) console.log(`  \x1b[32m✓\x1b[0m Commands run: ${r.commands_run.length}`);
             if (r.tokens_used) console.log(`  \x1b[2m${r.tokens_used} tokens · ${r.model}\x1b[0m`);
             console.log('\n  \x1b[32m✓ Done\x1b[0m\n');
-            await showResultPreview(r);   // confirm server/file actually exists
+            await showResultPreview(r);
             ws.close();
             resolve();
             break;
           }
           case 'session.failed':
+            spinner.stop();
             if (streaming) { process.stdout.write('\n'); streaming = false; }
             console.log(`\n  \x1b[31m✗ Failed:\x1b[0m ${event.error}\n`);
             ws.close();
@@ -557,7 +562,7 @@ async function streamSession(sessionId) {
     });
 
     ws.on('error', () => {
-      // WS not available — fall back to polling
+      spinner.stop();
       ws.close();
       pollSession(sessionId).then(resolve);
     });
@@ -569,31 +574,39 @@ async function streamSession(sessionId) {
 
 async function pollSession(sessionId) {
   let lastStepCount = 0;
+  const spinner = new Spinner('Thinking');
+  spinner.start();
+
   for (let i = 0; i < 300; i++) {
     await sleep(600);
     const res = await fetch(`${BASE_URL}/api/sessions/${sessionId}`);
     const s = await res.json();
 
-    // Print any new steps since last poll
+    // Print new steps
     const steps = s.steps ?? [];
     for (let j = lastStepCount; j < steps.length; j++) {
-      console.log(`  › ${steps[j].description}`);
+      spinner.stop();
+      console.log(`  \x1b[2m›\x1b[0m ${steps[j].description}`);
+      spinner.start(steps[j].description.slice(0, 50));
     }
     lastStepCount = steps.length;
 
     if (s.status === 'completed') {
-      console.log('\n  ✓ Done\n');
+      spinner.stop();
+      console.log('\n  \x1b[32m✓ Done\x1b[0m\n');
       const out = s.result?.output ?? s.result;
       if (out && typeof out === 'string') console.log(`  ${out}\n`);
       await showResultPreview(s.result ?? {});
       return;
     }
     if (s.status === 'failed') {
-      console.log(`\n  ✗ Failed: ${s.error}\n`);
+      spinner.stop();
+      console.log(`\n  \x1b[31m✗ Failed:\x1b[0m ${s.error}\n`);
       return;
     }
   }
-  console.log('\n  Timed out waiting for session.\n');
+  spinner.stop();
+  console.log('\n  Timed out.\n');
 }
 
 // ─── Chat REPL ───────────────────────────────────────────────────────────
@@ -1311,19 +1324,20 @@ async function requireDaemon() {
     process.exit(1);
   }
 
-  process.stdout.write('  Starting daemon');
+  const startSpinner = new Spinner('Starting daemon');
+  startSpinner.start();
   await _startDaemonBackground();
 
   for (let i = 0; i < 24; i++) {
     await sleep(500);
-    process.stdout.write('.');
     if (await isDaemonRunning()) {
-      process.stdout.write(' ✓\n\n');
+      startSpinner.stop();
+      process.stdout.write('  \x1b[32m✓\x1b[0m Daemon ready\n\n');
       return;
     }
   }
-  process.stdout.write(' ✗\n');
-  console.log('  Daemon failed to start. Check: 0agent logs\n');
+  startSpinner.stop();
+  console.log('  \x1b[31m✗\x1b[0m Daemon failed to start. Check: 0agent logs\n');
   process.exit(1);
 }
 
@@ -1359,6 +1373,37 @@ function sleep(ms) {
   return new Promise(r => setTimeout(r, ms));
 }
 
+// ─── Spinner — shows when agent is thinking/loading ───────────────────────────
+class Spinner {
+  constructor(msg = 'Thinking') {
+    this._msg = msg;
+    this._frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+    this._i = 0;
+    this._timer = null;
+    this._active = false;
+  }
+  start(msg) {
+    if (this._active) return;
+    if (msg) this._msg = msg;
+    this._active = true;
+    process.stdout.write('\n');
+    this._timer = setInterval(() => {
+      process.stdout.write(`\r  \x1b[36m${this._frames[this._i++ % this._frames.length]}\x1b[0m \x1b[2m${this._msg}\x1b[0m  `);
+    }, 80);
+  }
+  update(msg) {
+    this._msg = msg;
+  }
+  stop(clearIt = true) {
+    if (!this._active) return;
+    clearInterval(this._timer);
+    this._timer = null;
+    this._active = false;
+    if (clearIt) process.stdout.write('\r\x1b[2K');
+  }
+  get active() { return this._active; }
+}
+
 function ask(question) {
   return new Promise(resolve => {
     const rl = createInterface({ input: process.stdin, output: process.stdout });

package/bin/chat.js

@@ -17,6 +17,30 @@ const AGENT_DIR   = resolve(homedir(), '.0agent');
 const CONFIG_PATH = resolve(AGENT_DIR, 'config.yaml');
 const BASE_URL    = process.env['ZEROAGENT_URL'] ?? 'http://localhost:4200';
 
+// ─── Spinner ──────────────────────────────────────────────────────────────────
+class Spinner {
+  constructor(msg = 'Thinking') {
+    this._msg = msg;
+    this._frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+    this._i = 0; this._timer = null; this._active = false;
+  }
+  start(msg) {
+    if (this._active) return;
+    if (msg) this._msg = msg;
+    this._active = true;
+    this._timer = setInterval(() => {
+      process.stdout.write(`\r  \x1b[36m${this._frames[this._i++ % this._frames.length]}\x1b[0m \x1b[2m${this._msg}\x1b[0m  `);
+    }, 80);
+  }
+  update(msg) { this._msg = msg; }
+  stop(clearIt = true) {
+    if (!this._active) return;
+    clearInterval(this._timer); this._timer = null; this._active = false;
+    if (clearIt) process.stdout.write('\r\x1b[2K');
+  }
+  get active() { return this._active; }
+}
+
 // ─── ANSI helpers ─────────────────────────────────────────────────────────────
 const C = {
   reset:   '\x1b[0m',
@@ -50,12 +74,13 @@ function getCurrentProvider(cfg) {
 
 // ─── State ────────────────────────────────────────────────────────────────────
 let cfg         = loadConfig();
-let sessionId   = null;  // current chat session
-let streaming   = false; // mid-token-stream
-let ws          = null;  // WebSocket
-let wsReady     = false;
+let sessionId      = null;
+let streaming      = false;
+let ws             = null;
+let wsReady        = false;
 let pendingResolve = null;
-let lineBuffer  = '';    // accumulated line for stream
+let lineBuffer     = '';
+const spinner      = new Spinner('Thinking');
 const history   = [];    // command history for arrow keys
 
 // ─── Header ──────────────────────────────────────────────────────────────────
@@ -102,17 +127,21 @@ function handleWsEvent(event) {
 
   switch (event.type) {
     case 'session.step': {
+      spinner.stop();
       if (streaming) { process.stdout.write('\n'); streaming = false; }
       console.log(`  ${fmt(C.dim, '›')} ${event.step}`);
+      spinner.start(event.step.slice(0, 50));  // resume with current step label
       break;
     }
     case 'session.token': {
+      spinner.stop();
       if (!streaming) { process.stdout.write('\n  '); streaming = true; }
       process.stdout.write(event.token);
       lineBuffer += event.token;
       break;
     }
     case 'session.completed': {
+      spinner.stop();
       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(', ')}`);
@@ -126,6 +155,7 @@ function handleWsEvent(event) {
       break;
     }
     case 'session.failed': {
+      spinner.stop();
       if (streaming) { process.stdout.write('\n'); streaming = false; }
       console.log(`\n  ${fmt(C.red, '✗')} ${event.error}\n`);
       lineBuffer = '';
@@ -189,6 +219,7 @@ async function runTask(input) {
     });
     const s = await res.json();
     sessionId = s.session_id ?? s.id;
+    spinner.start('Thinking');  // show immediately after session created
     return new Promise(resolve => { pendingResolve = resolve; });
   } catch (e) {
     console.log(`  ${fmt(C.red, '✗')} ${e.message}`);
@@ -377,12 +408,18 @@ 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
+// ── Startup: check daemon + LLM connection ──────────────────────────────────
+(async () => {
+  const startSpin = new Spinner('Starting daemon');
+
+  // Step 1: ensure daemon is running
+  let daemonOk = false;
+  try {
+    await fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(1500) });
+    daemonOk = true;
+  } catch {
+    // Auto-start
+    startSpin.start();
     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');
@@ -392,14 +429,60 @@ fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(1500) })
       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 {}
+        try { await fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(500) }); daemonOk = true; break; } catch {}
       }
-    } else {
-      console.log(`\n  ${fmt(C.dim, 'Run: 0agent start')}\n`);
     }
-    rl.prompt();
-  });
+    startSpin.stop();
+    if (daemonOk) process.stdout.write(`  ${fmt(C.green, '✓')} Daemon ready\n`);
+    else { console.log(`  ${fmt(C.red, '✗')} Daemon failed. Run: 0agent start`); rl.prompt(); return; }
+  }
+
+  // Step 2: verify LLM is reachable with a quick "hello" check
+  const provider = getCurrentProvider(cfg);
+  if (provider?.api_key?.trim() || provider?.provider === 'ollama') {
+    const llmSpin = new Spinner(`Connecting to ${provider.provider}/${provider.model}`);
+    llmSpin.start();
+    try {
+      // Ask the daemon to run a minimal LLM ping via the session API
+      const res = await fetch(`${BASE_URL}/api/sessions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ task: 'Reply with exactly: ready', options: { max_steps: 1 } }),
+      });
+      const s = await res.json();
+      const sid = s.session_id ?? s.id;
+      // Poll briefly for completion
+      for (let i = 0; i < 20; i++) {
+        await new Promise(r => setTimeout(r, 500));
+        const check = await fetch(`${BASE_URL}/api/sessions/${sid}`).then(r => r.json()).catch(() => null);
+        if (check?.status === 'completed') {
+          llmSpin.stop();
+          const model = check.result?.model ?? provider.model;
+          console.log(`  ${fmt(C.green, '✓')} LLM connected — ${fmt(C.cyan, model)}\n`);
+          break;
+        }
+        if (check?.status === 'failed') {
+          llmSpin.stop();
+          console.log(`  ${fmt(C.red, '✗')} LLM error: ${check.error}`);
+          console.log(`  ${fmt(C.dim, 'Check your API key with: /key ' + provider.provider)}\n`);
+          break;
+        }
+      }
+      if (llmSpin.active) {
+        llmSpin.stop();
+        console.log(`  ${fmt(C.yellow, '⚠')} LLM check timed out — it may still work\n`);
+      }
+    } catch {
+      llmSpin.stop();
+      console.log(`  ${fmt(C.yellow, '⚠')} Could not verify LLM connection\n`);
+    }
+  } else {
+    console.log(`  ${fmt(C.yellow, '⚠')} No API key set. Use: ${fmt(C.cyan, '/key ' + (provider?.provider ?? 'anthropic') + ' <your-key>')}\n`);
+  }
+
+  rl.prompt();
+})();
+
 
 rl.on('line', async (input) => {
   const line = input.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",