prior-cli 1.3.12 → 1.4.0

package/bin/prior.js

@@ -388,7 +388,9 @@ function hyperlink(text, url) {
   return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
 }
 
-function renderToolDone(name, summary) {
+const PREVIEW_TOOLS = new Set(['file_read', 'run_command', 'web_search', 'url_fetch']);
+
+function renderToolDone(name, summary, preview) {
   const took  = _toolStartTime ? c.dim(` · ${elapsed(Date.now() - _toolStartTime)}`) : '';
   let display = summary || '';
   if (/^[a-zA-Z]:[/\\]/.test(display) || display.startsWith('/')) {
@@ -398,6 +400,19 @@ function renderToolDone(name, summary) {
     display = c.dim(display);
   }
   process.stdout.write(`  ${c.ok('✓')}  ${c.muted(name)}  ${display}${took}\n`);
+
+  // Rich preview for certain tools
+  if (preview && PREVIEW_TOOLS.has(name)) {
+    const lines   = String(preview).split('\n').filter(l => l.trim());
+    const toShow  = lines.slice(0, 5);
+    const more    = lines.length - toShow.length;
+    if (toShow.length > 0) {
+      drawBox([
+        ...toShow.map(l => ({ text: l.slice(0, 80), dim: true })),
+        ...(more > 0 ? [{ text: `… ${more} more line${more !== 1 ? 's' : ''}`, dim: true }] : []),
+      ]);
+    }
+  }
 }
 
 function renderToolError(name, error) {
@@ -750,12 +765,25 @@ async function startChat(opts = {}) {
     process.exit(0);
   });
 
-  const PROMPT = () => c.brand('  ❯ ');
+  const PROMPT    = () => c.brand('  ❯ ');
+  const ML_PROMPT = () => c.brand('  … ');
+
+  let _mlBuf = []; // multiline accumulation (\ continuation)
 
   const loop = () => {
-    rl.question(PROMPT(), async raw => {
+    const isML = _mlBuf.length > 0;
+    rl.question(isML ? ML_PROMPT() : PROMPT(), async raw => {
       clearSuggestions();
-      const input = raw.trim();
+
+      // Backslash continuation — collect lines until one doesn't end with \
+      if (raw.endsWith('\\')) {
+        _mlBuf.push(raw.slice(0, -1));
+        return loop();
+      }
+      _mlBuf.push(raw);
+      const input = _mlBuf.join('\n').trim();
+      _mlBuf = [];
+
       if (!input) return loop();
 
       // ── Slash commands ──────────────────────────────────────
@@ -995,9 +1023,10 @@ Keep it under 350 words. Write prior.md now.`;
           console.log(c.brand('  ◈') + c.dim(`  ${label} attached`));
         }
 
-        let responseText     = '';
-        let _progressStarted = false;
-        const _thinkStart    = Date.now();
+        let responseText      = '';
+        let _progressStarted  = false;
+        let _streamStarted    = false; // true after first text_chunk
+        const _thinkStart     = Date.now();
 
         spinStart('thinking…');
 
@@ -1030,14 +1059,42 @@ Keep it under 350 words. Write prior.md now.`;
                   spinStart('thinking…');
                   break;
 
+                case 'waiting':
+                  spinStart(`waiting for Ollama… (${ev.attempt}/${ev.max})`);
+                  break;
+
                 case 'cancelled':
                   spinStop();
-                  process.stdout.write('\n');
+                  if (_streamStarted) process.stdout.write('\n');
                   console.log(c.muted('  ✗ Cancelled'));
                   break;
 
+                // ── Streaming text events ──────────────────────
+                case 'stream_start': {
+                  spinStop();
+                  const thinkTime = elapsed(Date.now() - _thinkStart);
+                  console.log(c.brand('  Prior  ') + c.muted(`·  ${timeNow()}  ·  ${thinkTime}`));
+                  console.log('');
+                  process.stdout.write('  ');
+                  _streamStarted = true;
+                  break;
+                }
+
+                case 'text_chunk':
+                  if (ev.content) {
+                    process.stdout.write(ev.content);
+                    responseText += ev.content;
+                  }
+                  break;
+
+                case 'stream_end':
+                  process.stdout.write('\n');
+                  _streamStarted = false;
+                  break;
+
                 case 'tool_start':
                   spinStop();
+                  if (_streamStarted) { process.stdout.write('\n'); _streamStarted = false; }
                   _progressStarted = false;
                   renderToolStart(ev.name, ev.args);
                   if (!CONFIRM_TOOLS.has(ev.name)) spinStart('working…');
@@ -1060,7 +1117,7 @@ Keep it under 350 words. Write prior.md now.`;
 
                 case 'tool_done':
                   spinStop();
-                  renderToolDone(ev.name, ev.summary);
+                  renderToolDone(ev.name, ev.summary, ev.preview);
                   break;
 
                 case 'tool_skip':
@@ -1091,7 +1148,7 @@ Keep it under 350 words. Write prior.md now.`;
 
                 case 'error':
                   spinStop();
-                  process.stdout.write('\n');
+                  if (_streamStarted) process.stdout.write('\n');
                   console.error(c.err(`  ✗ ${ev.message}`));
                   break;
               }

package/lib/agent.js

@@ -8,9 +8,9 @@ const CLI_BASE  = 'https://prior.ngrok.app/cli-backend';
 const PRIOR_BASE = 'https://prior.ngrok.app';
 const MAX_ITER   = 14;
 
-// ── Single inference call (server just runs Ollama + returns) ─
+// ── Single inference call — reads NDJSON stream from backend ──
 
-async function infer(messages, model, token, { cwd, uncensored, projectContext, images } = {}, signal) {
+async function infer(messages, model, token, { cwd, uncensored, projectContext, images } = {}, signal, onChunk) {
   const res = await fetch(`${CLI_BASE}/api/infer`, {
     method:  'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -18,11 +18,49 @@ async function infer(messages, model, token, { cwd, uncensored, projectContext,
     timeout: 120000,
     signal,
   });
+
   if (!res.ok) {
     const err = await res.json().catch(() => ({}));
     throw new Error(err.error || `Server error: HTTP ${res.status}`);
   }
-  return await res.json(); // { content, promptTokens, completionTokens }
+
+  let content          = '';
+  let promptTokens     = 0;
+  let completionTokens = 0;
+
+  await new Promise((resolve, reject) => {
+    let buf = '';
+    res.body.on('data', rawChunk => {
+      if (signal?.aborted) {
+        res.body.destroy();
+        return reject(Object.assign(new Error('AbortError'), { name: 'AbortError' }));
+      }
+      buf += rawChunk.toString();
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const data = JSON.parse(line);
+          if (data.type === 'chunk') {
+            if (onChunk) onChunk(data.content);
+          } else if (data.type === 'done') {
+            content          = data.content || '';
+            promptTokens     = data.promptTokens     || 0;
+            completionTokens = data.completionTokens || 0;
+          } else if (data.type === 'waiting') {
+            if (onChunk) onChunk(null, { type: 'waiting', attempt: data.attempt, max: data.max });
+          } else if (data.type === 'error') {
+            reject(new Error(data.message));
+          }
+        } catch { /* skip malformed line */ }
+      }
+    });
+    res.body.on('end', resolve);
+    res.body.on('error', reject);
+  });
+
+  return { content, promptTokens, completionTokens };
 }
 
 // ── Token usage tracking ──────────────────────────────────────
@@ -201,40 +239,82 @@ function stripToolTags(text) {
 const CONFIRM_TOOLS = new Set(['run_command', 'file_delete', 'file_write']);
 
 async function runAgent({ messages, model, uncensored, cwd, projectContext, images, send, confirm, signal }) {
-  const token   = getToken();
+  const token = getToken();
   const history = [...messages];
 
   let totalPromptTokens     = 0;
   let totalCompletionTokens = 0;
-  let pendingImages         = (images && images.length) ? images : null; // only sent on first iteration
+  let pendingImages         = (images && images.length) ? images : null;
 
   for (let iter = 0; iter < MAX_ITER; iter++) {
 
-    if (signal?.aborted) {
-      send({ type: 'cancelled' });
-      send({ type: 'done' });
-      return;
-    }
+    if (signal?.aborted) { send({ type: 'cancelled' }); send({ type: 'done' }); return; }
 
     send({ type: 'thinking' });
 
-    let result;
+    // ── Per-iteration streaming state ─────────────────────────
+    // After </think> we buffer LOOK_SIZE chars to detect tool calls before
+    // deciding whether to stream text live or stay in buffered mode.
+    let thinkBuf  = '';    // chunks buffered while inside <think>…</think>
+    let thinkDone = false;
+    let lookBuf   = '';    // first N chars of actual response (after think)
+    let streaming = false; // true once we've committed to live-streaming text
+    const LOOK_SIZE = 60;
+
+    function tryStartStreaming() {
+      if (streaming) return;
+      const trimmed = lookBuf.replace(/^[\s\n]+/, '');
+      // If the response starts with a tool tag, keep buffered (no live text)
+      if (/^<(?:tool|write|append|docx)[\s>{"[]/.test(trimmed)) return;
+      streaming = true;
+      send({ type: 'stream_start' });
+      if (trimmed) send({ type: 'text_chunk', content: trimmed });
+      lookBuf = '';
+    }
+
+    const onChunk = (raw, meta) => {
+      if (meta?.type === 'waiting') { send({ type: 'waiting', attempt: meta.attempt, max: meta.max }); return; }
+      if (!raw) return;
+
+      if (!thinkDone) {
+        thinkBuf += raw;
+        const idx = thinkBuf.indexOf('</think>');
+        if (idx !== -1) {
+          thinkDone = true;
+          lookBuf   = thinkBuf.slice(idx + 8).replace(/^[\s\n]+/, '');
+          thinkBuf  = '';
+          if (lookBuf.length >= LOOK_SIZE) tryStartStreaming();
+        }
+        return;
+      }
+
+      if (!streaming) {
+        lookBuf += raw;
+        if (lookBuf.length >= LOOK_SIZE) tryStartStreaming();
+        return;
+      }
+
+      send({ type: 'text_chunk', content: raw });
+    };
+
     const iterImages = pendingImages;
-    pendingImages = null; // clear after first use
+    pendingImages = null;
+
+    let result;
     try {
-      result = await infer(history, model || 'qwen3.5:4b', token, { cwd, uncensored, projectContext, images: iterImages }, signal);
+      result = await infer(history, model || 'qwen3.5:4b', token, { cwd, uncensored, projectContext, images: iterImages }, signal, onChunk);
     } catch (err) {
       await trackTokenUsage(token, totalPromptTokens, totalCompletionTokens);
-      if (err.name === 'AbortError' || signal?.aborted) {
-        send({ type: 'cancelled' });
-        send({ type: 'done' });
-        return;
-      }
+      if (err.name === 'AbortError' || signal?.aborted) { send({ type: 'cancelled' }); send({ type: 'done' }); return; }
       send({ type: 'error', message: err.message });
       send({ type: 'done' });
       return;
     }
 
+    // Flush look-ahead if stream ended before LOOK_SIZE was reached
+    if (thinkDone && !streaming && lookBuf) tryStartStreaming();
+    if (streaming) send({ type: 'stream_end' });
+
     totalPromptTokens     += result.promptTokens     || 0;
     totalCompletionTokens += result.completionTokens || 0;
 
@@ -252,20 +332,21 @@ async function runAgent({ messages, model, uncensored, cwd, projectContext, imag
     if (calls.length === 0) {
       const finalText = stripToolTags(cleaned);
       if (!finalText && iter < MAX_ITER - 1) {
-        // Model returned blank (all think tags, no actual output) — nudge once
         history.push({ role: 'assistant', content: raw });
         history.push({ role: 'user', content: '(Your response was empty. Please write your reply.)' });
         continue;
       }
       await trackTokenUsage(token, totalPromptTokens, totalCompletionTokens);
-      send({ type: 'text', content: finalText });
+      if (!streaming) send({ type: 'text', content: finalText }); // already shown if streaming
       send({ type: 'done' });
       return;
     }
 
     // ── Text before first tool call ───────────────────────────
-    const textBefore = stripToolTags(cleaned.slice(0, calls[0].offset)).trim();
-    if (textBefore) send({ type: 'text', content: textBefore });
+    if (!streaming) {
+      const textBefore = stripToolTags(cleaned.slice(0, calls[0].offset)).trim();
+      if (textBefore) send({ type: 'text', content: textBefore });
+    }
 
     history.push({ role: 'assistant', content: raw });
 
@@ -274,7 +355,6 @@ async function runAgent({ messages, model, uncensored, cwd, projectContext, imag
     for (const call of calls) {
       send({ type: 'tool_start', name: call.name, args: call.args });
 
-      // Confirmation gate for destructive / side-effect tools
       if (confirm && CONFIRM_TOOLS.has(call.name)) {
         const approved = await confirm({ name: call.name, args: call.args });
         if (!approved) {
@@ -286,7 +366,8 @@ async function runAgent({ messages, model, uncensored, cwd, projectContext, imag
 
       try {
         const toolResult = await executeTool(call.name, call.args, { cwd, token, send });
-        send({ type: 'tool_done', name: call.name, summary: toolResult.summary });
+        // Pass output snippet so the CLI can show a rich preview
+        send({ type: 'tool_done', name: call.name, summary: toolResult.summary, preview: toolResult.output });
         resultParts.push(`<tool_result name="${call.name}">\n${toolResult.output}\n</tool_result>`);
       } catch (err) {
         send({ type: 'tool_error', name: call.name, error: err.message });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prior-cli",
-  "version": "1.3.12",
+  "version": "1.4.0",
   "description": "Prior Network AI — command-line interface",
   "bin": {
     "prior": "bin/prior.js"