prior-cli 1.3.11 → 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) {
@@ -608,7 +623,7 @@ async function startChat(opts = {}) {
   const chatHistory = [];
   let currentModel            = opts.model || null;
   let _currentAbortController = null;
-  let _pendingImageBase64     = null; // set by alt+v clipboard paste
+  let _pendingImages          = [];   // set by alt+v clipboard paste (supports multiple)
 
   // ── Live slash-command suggestions ──────────────────────────
   let clearSuggestions = () => {};
@@ -652,8 +667,12 @@ async function startChat(opts = {}) {
       let rows = 0;
 
       // Image indicator — always first, persists across backspace/typing
-      if (_pendingImageBase64) {
-        process.stdout.write(`\x1b[B\r\x1b[2K  ${c.brand('◈')}  ${c.dim('[Image] attached  ·  alt+v to remove')}`);
+      if (_pendingImages.length > 0) {
+        const tags = _pendingImages.map((_, i) => c.brand(`[Image ${i + 1}]`)).join(' ');
+        const hint = _pendingImages.length > 0
+          ? c.dim('  ·  alt+v to add more  ·  alt+v (empty clipboard) to remove last')
+          : '';
+        process.stdout.write(`\x1b[B\r\x1b[2K  ${c.brand('◈')}  ${tags}${hint}`);
         rows++;
       }
 
@@ -690,24 +709,22 @@ async function startChat(opts = {}) {
         return;
       }
 
-      // Alt+V — grab image from clipboard, or remove if already attached
+      // Alt+V — add image from clipboard, or remove last if clipboard is empty
       if (key.meta && key.name === 'v') {
-        if (_pendingImageBase64) {
-          _pendingImageBase64 = null;
-          renderSubRows(rl.line || '');
-        } else {
-          try {
-            const ps = `Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img) { $ms = New-Object System.IO.MemoryStream; $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png); [Convert]::ToBase64String($ms.ToArray()) } else { '' }`;
-            const b64 = execSync(`powershell -NoProfile -Command "${ps}"`, { timeout: 5000 }).toString().trim();
-            if (b64) {
-              _pendingImageBase64 = b64;
-              renderSubRows(rl.line || '');
-            } else {
-              flashSubRow(c.muted('✗  No image found in clipboard'));
-            }
-          } catch {
-            flashSubRow(c.muted('✗  Could not read clipboard'));
+        try {
+          const ps = `Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img) { $ms = New-Object System.IO.MemoryStream; $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png); [Convert]::ToBase64String($ms.ToArray()) } else { '' }`;
+          const b64 = execSync(`powershell -NoProfile -Command "${ps}"`, { timeout: 5000 }).toString().trim();
+          if (b64) {
+            _pendingImages.push(b64);
+            renderSubRows(rl.line || '');
+          } else if (_pendingImages.length > 0) {
+            _pendingImages.pop();
+            renderSubRows(rl.line || '');
+          } else {
+            flashSubRow(c.muted('✗  No image found in clipboard'));
           }
+        } catch {
+          flashSubRow(c.muted('✗  Could not read clipboard'));
         }
         return;
       }
@@ -748,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 ──────────────────────────────────────
@@ -985,16 +1015,18 @@ Keep it under 350 words. Write prior.md now.`;
       console.log('');
 
       {
-        const imageForThisMsg = _pendingImageBase64;
-        _pendingImageBase64   = null;
+        const imagesForThisMsg = [..._pendingImages];
+        _pendingImages         = [];
 
-        if (imageForThisMsg) {
-          console.log(c.brand('  ◈') + c.dim('  image attached'));
+        if (imagesForThisMsg.length > 0) {
+          const label = imagesForThisMsg.length === 1 ? '1 image' : `${imagesForThisMsg.length} images`;
+          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…');
 
@@ -1017,7 +1049,7 @@ Keep it under 350 words. Write prior.md now.`;
             model:          currentModel,
             cwd:            process.cwd(),
             projectContext,
-            imageBase64:    imageForThisMsg,
+            images:         imagesForThisMsg,
             confirm,
             signal:         _currentAbortController.signal,
             send: ev => {
@@ -1027,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…');
@@ -1057,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':
@@ -1088,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,21 +8,59 @@ 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, imageBase64 } = {}, 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' },
-    body:    JSON.stringify({ messages, model, token, cwd, uncensored, projectContext, imageBase64 }),
+    body:    JSON.stringify({ messages, model, token, cwd, uncensored, projectContext, images }),
     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 ──────────────────────────────────────
@@ -200,41 +238,83 @@ function stripToolTags(text) {
 
 const CONFIRM_TOOLS = new Set(['run_command', 'file_delete', 'file_write']);
 
-async function runAgent({ messages, model, uncensored, cwd, projectContext, imageBase64, send, confirm, signal }) {
-  const token   = getToken();
+async function runAgent({ messages, model, uncensored, cwd, projectContext, images, send, confirm, signal }) {
+  const token = getToken();
   const history = [...messages];
 
   let totalPromptTokens     = 0;
   let totalCompletionTokens = 0;
-  let pendingImage          = imageBase64 || 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' });
 
+    // ── 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;
+
     let result;
-    const iterImage = pendingImage;
-    pendingImage = null; // clear after first use
     try {
-      result = await infer(history, model || 'qwen3.5:4b', token, { cwd, uncensored, projectContext, imageBase64: iterImage }, 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.11",
+  "version": "1.4.0",
   "description": "Prior Network AI — command-line interface",
   "bin": {
     "prior": "bin/prior.js"