@synqa/cli 1.1.1 → 1.2.1

package/dist/ui.js

@@ -9,6 +9,7 @@ import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { formatUsd } from "./account.js";
                                                            
+                                             
 import { sanitize, visibleEscapes } from "./sanitize.js";
 import { groupDigits } from "./statusbar.js";
 import { CONTEXT_TOKENS } from "./tiers.js";
@@ -203,6 +204,8 @@ export function balanceLine(b         )         {
                      
                    
                                                                                           
+                                                                                                      
+                                                                           
   
 
 // "Synqa." on one line: the name bold in the terminal's own text colour, the period terracotta.
@@ -238,8 +241,9 @@ export function renderBanner(info            , ui    )           {
   const effort = `${info.effort ?? "default"} effort`;
   const where = oneLine(shortenHome(info.cwd, info.home));
   const notes                                         = [];
-  notes.push([info.notesChars > 0 ? `AGENTS.md loaded (${groupDigits(info.notesChars)} chars)` : "no AGENTS.md yet: /init writes one", (t) => dim(s, t)]);
-  if (info.balance.kind === "ok") notes.push([balanceLine(info.balance).replace(" · ", sep), (t) => sage(s, t)]);
+  if (info.locked) notes.push(["Sign in to Synqa Cloud to unlock chat and other providers", (t) => dim(s, t)]);
+  else notes.push([info.notesChars > 0 ? `AGENTS.md loaded (${groupDigits(info.notesChars)} chars)` : "no AGENTS.md yet: /init writes one", (t) => dim(s, t)]);
+  if (info.locked) { /* no balance before sign-in */ } else if (info.balance.kind === "ok") notes.push([balanceLine(info.balance).replace(" · ", sep), (t) => sage(s, t)]);
   else notes.push([balanceLine(info.balance), (t) => dim(s, t)]);
   for (const w of info.warnings ?? []) notes.push([oneLine(w), (t) => dim(s, t)]);
   const lead = "  ";
@@ -247,7 +251,7 @@ export function renderBanner(info            , ui    )           {
   const noteLines = notes.map(([t, p]) => dim(s, lead + hook) + p(fit(t, room - lead.length - hook.length, ui)));
   const w = room - lead.length;
   const meta = [
-    lead + dim(s, fit(`${version}${sep}${info.tier.display}${sep}${effort}`, w, ui)),
+    lead + dim(s, fit(`${version}${sep}${info.provider ? [info.provider.name, info.provider.model].filter(Boolean).map((x) => oneLine(x          )).join(sep) : info.tier.display}${sep}${effort}`, w, ui)),
     lead + dim(s, fitPath(where, w, ui)),
   ];
   if (!ui.unicode || ui.columns < 60) {
@@ -281,6 +285,9 @@ export const PLACEHOLDER = 'Try "explain this project", or type / for commands';
                       
                                                                           
                     
+                                                                                        
+                                                                   
+                                                      
   
 
 // The two lines under the input: what is known about the session, then key hints. Unknown values
@@ -294,27 +301,30 @@ export function renderStatusLines(p            , ui    )           {
   const ws = home === "~" ? "~" : oneLine(home.split(/[\\/]/).filter(Boolean).pop() ?? home);
                                                                      
   const st = (t        ) => stone(s, t);
-  const parts         = [{ k: "tier", t: p.tier.display, paint: (t) => terracottaBold(s, t) }];
+  const head = p.provider ? [p.provider.name, p.provider.model].filter(Boolean).map((x) => oneLine(x          )).join(sep) : p.tier.display;
+  const parts         = [{ k: "tier", t: head, paint: (t) => terracottaBold(s, t) }];
+  if (p.mode) parts.push({ k: "mode", t: oneLine(p.mode), paint: st });
   if (p.effort !== "default") parts.push({ k: "effort", t: `${p.effort} effort`, paint: st });
   parts.push({ k: "ws", t: Array.from(ws).slice(0, 32).join(""), paint: st });
   const ctxMax = p.contextMax ?? CONTEXT_TOKENS;
   if (p.contextTokens) parts.push({ k: "ctx", t: `ctx ${Math.min(100, Math.round((100 * p.contextTokens) / ctxMax))}%`, paint: st });
   if (p.routing && p.routing !== "?") parts.push({ k: "routing", t: Array.from(oneLine(p.routing)).slice(0, 12).join(""), paint: st });
   parts.push({ k: "tokens", t: `${groupDigits(p.tokens)} tokens`, paint: st });
+  if (p.updateHint) parts.push({ k: "update", t: oneLine(p.updateHint), paint: (t) => sage(s, t) });
   const right = p.balance && p.balance.kind === "ok" ? `${formatUsd(p.balance.account.creditRemaining)} credit` : "";
   const kept = parts.slice();
   let showRight = right !== "";
   const leftW = () => kept.reduce((w, x, i) => w + textWidth(x.t) + (i ? sep.length : 0), 0);
   const fits = () => leftW() + (showRight ? 2 + textWidth(right) : 0) <= room;
   // Dropped first to last: routing, ctx, workspace, effort, the balance, then tokens.
-  for (const k of ["routing", "ctx", "ws", "effort", "right", "tokens"]) {
+  for (const k of ["update", "routing", "ctx", "ws", "effort", "mode", "right", "tokens"]) {
     if (fits()) break;
     if (k === "right") { showRight = false; continue; }
     const i = kept.findIndex((x) => x.k === k);
     if (i > 0) kept.splice(i, 1);
   }
   let line = kept.map((x) => x.paint(x.t)).join(dim(s, sep));
-  if (!fits()) line = terracottaBold(s, fit(p.tier.display, room, ui));
+  if (!fits()) line = terracottaBold(s, fit(head, room, ui));
   else if (showRight) line += " ".repeat(Math.max(2, room - leftW() - textWidth(right))) + sage(s, right);
   return [line, keyHints(ui)];
 }
@@ -342,10 +352,22 @@ export function keyHints(ui    )         {
                                                      
                                     
                       
+                                                                                 
   
 
 const CR_ERASE = "\r\x1b[2K";
 
+// The thinking mark: [S] with the dot bobbing . then middle dot, ring-less dot, middle dot. Every frame
+// is exactly four cells wide and one line, so nothing around it ever shifts.
+const BOB_UNI = [".", "\u00b7", "\u02d9", "\u00b7"];
+const BOB_ASCII = [".", ",", "\x27", ","];
+export const THINKING_FPS = 8;
+export const THINKING_INTERVAL_MS = 125; // 8 frames per second, only while waiting for the first token
+export function thinkingFrame(i        , ui    )         {
+  const bob = ui.unicode ? BOB_UNI : BOB_ASCII;
+  return `[S${bob[((i % bob.length) + bob.length) % bob.length]          }]`;
+}
+
 export class Spinner {
           out            ;
           o                ;
@@ -374,7 +396,7 @@ export class Spinner {
       (h                          ).unref?.();
       return h;
     });
-    this.timer = set(() => this.draw(), this.o.intervalMs ?? 80);
+    this.timer = set(() => this.draw(), this.o.intervalMs ?? THINKING_INTERVAL_MS);
   }
 
   elapsedText()         {
@@ -383,8 +405,7 @@ export class Spinner {
   }
 
           draw()       {
-    const g = glyphs(this.o.ui);
-    const f = g.spin[this.frame++ % g.spin.length]          ;
+    const f = (this.o.frameFn ?? ((i        ) => thinkingFrame(i, this.o.ui)))(this.frame++);
     const st = styleOf(this.o.ui);
     const text = fit(`${f} waiting ${this.elapsedText()}`, this.o.ui.columns - 1, this.o.ui);
     // The frame is terracotta, the rest stone. fit() keeps the frame first, so the split is safe.
@@ -405,6 +426,94 @@ export class Spinner {
   }
 }
 
+// ---------------------------------------------------------------- tool-call progress
+
+export function formatBytes(n        )         {
+  return n < 1024 ? `${n} B` : `${(n / 1024).toFixed(1)} KB`;
+}
+
+export const PROGRESS_INTERVAL_MS = 120; // the line is redrawn at most this often, however fast chunks arrive
+
+// A live line for a tool call that is still streaming in, for example
+//   ⠋ write_file index.html · streaming 18.4 KB...
+// The frame is the terracotta dot-mark of the spinner family, the rest stone. It is one line,
+// always shorter than the terminal, redrawn in place by a throttled timer. With `enabled` false
+// (a pipe, TERM=dumb, a one-shot run) nothing is ever written: no animation, no control codes.
+export class ToolProgressLine {
+          out            ;
+          o                ;
+          timer          = undefined;
+          frame = 0;
+          drawn = false;
+          last                          ;
+
+  constructor(out            , o                ) {
+    this.out = out;
+    this.o = o;
+  }
+
+  get active()          {
+    return this.timer !== undefined;
+  }
+
+  // The newest state of the call being received. The first update draws at once; later ones only
+  // change what the next timed redraw shows.
+  update(p              )       {
+    if (!this.o.enabled) return;
+    this.last = p;
+    if (this.timer !== undefined) return;
+    this.draw();
+    const set = this.o.setTimer ?? ((fn            , ms        ) => {
+      const h = setInterval(fn, ms);
+      (h                          ).unref?.();
+      return h;
+    });
+    this.timer = set(() => this.draw(), this.o.intervalMs ?? PROGRESS_INTERVAL_MS);
+  }
+
+  // The plain line for the current state, cut to the terminal width.
+  line()         {
+    const p = this.last;
+    if (!p) return "";
+    const ui = this.o.ui;
+    const g = glyphs(ui);
+    const frames = g.spin;
+    const f = frames[this.frame % frames.length]          ;
+    const room = ui.columns - 1;
+    const tail = ` ${g.dot} streaming ${formatBytes(p.bytes)}${g.ell}`;
+    const lead = f + " ";
+    const avail = room - textWidth(lead) - textWidth(tail);
+    if (avail < 6) return fit(lead + oneLine(p.name) + tail, room, ui);
+    const name = fit(Array.from(oneLine(p.name)).slice(0, 40).join("") || "tool", avail, ui);
+    const pathRoom = avail - textWidth(name) - 1;
+    const path = p.path && pathRoom >= 4 ? " " + fitPath(oneLine(p.path), pathRoom, ui) : "";
+    return lead + name + path + tail;
+  }
+
+          draw()       {
+    const st = styleOf(this.o.ui);
+    const text = this.line();
+    const f = (glyphs(this.o.ui).spin[this.frame % glyphs(this.o.ui).spin.length]          );
+    this.frame++;
+    if (text === "") return;
+    this.out.write(CR_ERASE + terracotta(st, text.slice(0, f.length)) + stone(st, text.slice(f.length)));
+    this.drawn = true;
+  }
+
+  // Clears the line and stops. Safe to call at any time, any number of times.
+  stop()       {
+    if (this.timer !== undefined) {
+      (this.o.clearTimer ?? ((h         ) => clearInterval(h                                  )))(this.timer);
+      this.timer = undefined;
+    }
+    this.last = undefined;
+    if (this.drawn) {
+      this.out.write(CR_ERASE);
+      this.drawn = false;
+    }
+  }
+}
+
 // ---------------------------------------------------------------- tool cards
 
 // The one piece of an argument list worth showing in a card header.
@@ -523,12 +632,26 @@ export class TurnRenderer {
           out           ;
           ui    ;
           spinner         ;
+          progress                              ;
           midLine = false; // the last thing written was model text with no trailing newline
 
-  constructor(out           , ui    , spinner         ) {
+  constructor(out           , ui    , spinner         , progress                   ) {
     this.out = out;
     this.ui = ui;
     this.spinner = spinner;
+    this.progress = progress;
+  }
+
+  // A tool call is streaming in: the waiting spinner gives way to the live progress line. Text
+  // that ended without a newline is finished first, because the line is redrawn in place.
+  toolProgress(p              )       {
+    if (!this.progress) return;
+    this.spinner.stop();
+    if (!this.progress.active && this.midLine) {
+      this.out.write("\n");
+      this.midLine = false;
+    }
+    this.progress.update(p);
   }
 
   // A request is about to be sent: show that we are waiting for the first token.
@@ -539,6 +662,7 @@ export class TurnRenderer {
   // Model text. The spinner is erased first; the text is stripped of every escape sequence.
   text(t        )       {
     this.spinner.stop();
+    this.progress?.stop();
     const clean = sanitize(t);
     if (clean === "") return;
     this.out.write(clean);
@@ -548,10 +672,12 @@ export class TurnRenderer {
   // The request finished (with or without a tool call).
   requestEnd()       {
     this.spinner.stop();
+    this.progress?.stop();
   }
 
   toolStart(name        , rawArgs        )       {
     this.spinner.stop();
+    this.progress?.stop();
     this.out.write((this.midLine ? "\n" : "") + cardHeader(name, rawArgs, this.ui) + "\n");
     this.midLine = false;
   }
@@ -568,6 +694,7 @@ export class TurnRenderer {
   // Leaves the cursor at the start of a line after a turn.
   turnEnd()       {
     this.spinner.stop();
+    this.progress?.stop();
     if (this.midLine) this.out.write("\n");
     this.midLine = false;
   }

package/dist/update.js

@@ -0,0 +1,71 @@
+// Update check and /update. The check is one short, silent GET to the npm registry; the update
+// runs npm itself (no shell string on POSIX; npm.cmd through a shell on Windows).
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+                                          
+
+export const REGISTRY_URL = "https://registry.npmjs.org/@synqa/cli/latest";
+export const PACKAGE_SPEC = "@synqa/cli@latest";
+
+// "1.2.0" -> [1, 2, 0]; anything that is not a plain x.y.z (with an optional -pre part) is undefined.
+export function parseVersion(v        )                       {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.exec(v.trim());
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined;
+}
+
+// Numeric, not textual: 1.10.0 is newer than 1.9.0. Returns <0, 0 or >0; undefined if either is unparseable.
+export function compareVersions(a        , b        )                     {
+  const x = parseVersion(a);
+  const y = parseVersion(b);
+  if (!x || !y) return undefined;
+  for (let i = 0; i < 3; i++) {
+    const d = (x[i]          ) - (y[i]          );
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+export const isNewer = (latest        , current        )          => (compareVersions(latest, current) ?? 0) > 0;
+
+// The latest published version if it is newer than `current`, else undefined. Every failure
+// (offline, slow, odd answer) is silent.
+export async function checkForUpdate(current        , fetchFn            = fetch, timeoutMs = 1500)                              {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  (timer                          ).unref?.();
+  try {
+    const res = await fetchFn(REGISTRY_URL, { headers: { accept: "application/json" }, signal: ac.signal });
+    if (!res.ok) return undefined;
+    const body = (await res.json())                         ;
+    const latest = typeof body.version === "string" ? body.version : "";
+    return isNewer(latest, current) ? latest : undefined;
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// How /update runs npm. POSIX: spawn("npm", [...]) with no shell. Windows: npm is npm.cmd, which
+// Node can only start through a shell.
+export function updateCommand(platform         = process.platform)                                                   {
+  return { file: platform === "win32" ? "npm.cmd" : "npm", args: ["install", "-g", PACKAGE_SPEC], shell: platform === "win32" };
+}
+
+export function runUpdate(platform         = process.platform, spawnFn               = spawn)                  {
+  const c = updateCommand(platform);
+  return new Promise((resolve) => {
+    try {
+      const child = spawnFn(c.file, c.args, {
+        stdio: "inherit", shell: c.shell,
+        // Never the workspace: npm must not pick up a project's .npmrc or a planted npm.cmd.
+        cwd: homedir(),
+        ...(platform === "win32" ? { env: { ...process.env, NoDefaultCurrentDirectoryInExePath: "1" } } : {}),
+      });
+      child.on("error", () => resolve(1));
+      child.on("close", (code               ) => resolve(code ?? 1));
+    } catch {
+      resolve(1);
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synqa/cli",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "Synqa terminal coding agent",
   "type": "module",
   "bin": {