@synqa/cli 0.0.0-stage → 1.1.1

package/dist/statusbar.js

@@ -0,0 +1,121 @@
+// The status bar: one line with the tier, routing mode, TTFT, tok/s and session tokens. On a
+// terminal it is pinned to the bottom row (the scroll region stops one row short of it); anywhere
+// else it is printed as an ordinary line by the caller, so nothing here needs a terminal to be tested.
+                                               
+
+                           
+             
+                                                   
+                 
+                  
+                     
+                                               
+  
+
+// 1234567 -> "1,234,567" without relying on the locale.
+export function groupDigits(n        )         {
+  return String(Math.max(0, Math.round(n))).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
+export function formatTtft(ms                    )         {
+  return ms === undefined || !Number.isFinite(ms) || ms < 0 ? "-" : `${(ms / 1000).toFixed(2)}s`;
+}
+
+export function formatRate(tps                    )         {
+  return tps === undefined || !Number.isFinite(tps) || tps <= 0 ? "-" : `${tps.toFixed(1)} tok/s`;
+}
+
+// Fits `width` columns by dropping segments from the least important end; the tier always stays.
+// Unknown values (routing "?", no TTFT or rate yet) are left out, never shown as "?" or "-".
+export function formatStatus(p             , width         )         {
+  const tier = p.tier.display;
+  const effort = p.effort === "default" ? "" : `effort ${p.effort}`;
+  const route = p.routing && p.routing !== "?" ? p.routing : "";
+  const ttft = formatTtft(p.ttftMs);
+  const t = ttft === "-" ? "" : `TTFT ${ttft}`;
+  const r = formatRate(p.tokPerSec);
+  const rate = r === "-" ? "" : r;
+  const toks = `${groupDigits(p.tokens)} tokens`;
+  const short = `${groupDigits(p.tokens)} tok`;
+  const variants = [
+    [tier, effort, route, t, rate, toks],
+    [tier, route, t, rate, toks],
+    [tier, route, rate, short],
+    [tier, route, short],
+    [tier, route],
+  ];
+  const join = (parts          ) => parts.filter((x) => x !== "").join(" | ");
+  if (width === undefined) return join(variants[0]            );
+  for (const v of variants) {
+    const s = join(v);
+    if (s.length <= width) return s;
+  }
+  const last = join(variants[variants.length - 1]            );
+  return width > 1 ? last.slice(0, width - 1) + "…" : last.slice(0, width);
+}
+
+                                                                                 
+
+const ESC = "\x1b";
+
+// Pins `text` to the last terminal row. All escape sequences are fixed strings made here; the text
+// comes from formatStatus (tier names and numbers), never from the model.
+export class StatusBar {
+          out     ;
+          on         ;
+          text = "";
+          installed = false;
+          paint                       ;
+
+  constructor(out     , enabled         , paint                        = (s) => s) {
+    this.out = out;
+    this.paint = paint;
+    // Needs room for at least the bar plus a few lines of scrollback.
+    this.on = enabled && (out.rows ?? 0) >= 6 && (out.columns ?? 0) >= 20;
+  }
+
+  get enabled()          {
+    return this.on;
+  }
+
+          rows()         {
+    return this.out.rows ?? 24;
+  }
+
+          cols()         {
+    return this.out.columns ?? 80;
+  }
+
+  install()       {
+    if (!this.on || this.installed) return;
+    this.installed = true;
+    // A newline guarantees a spare row below the cursor, then the cursor goes back up.
+    this.out.write(`\n${ESC}[1A${ESC}7${ESC}[1;${this.rows() - 1}r${ESC}8`);
+    this.draw();
+  }
+
+  update(text        )       {
+    this.text = text;
+    this.draw();
+  }
+
+  // Terminal size changed: move the scroll region and repaint.
+  resize()       {
+    if (!this.on || !this.installed) return;
+    this.out.write(`${ESC}7${ESC}[1;${this.rows() - 1}r${ESC}8`);
+    this.draw();
+  }
+
+          draw()       {
+    if (!this.on || !this.installed) return;
+    const line = this.text.length > this.cols() - 1 ? this.text.slice(0, this.cols() - 2) + "…" : this.text;
+    this.out.write(`${ESC}7${ESC}[${this.rows()};1H${ESC}[2K${this.paint(line)}${ESC}8`);
+  }
+
+  // Gives the whole screen back and clears the bar row.
+  uninstall()       {
+    if (!this.on || !this.installed) return;
+    this.installed = false;
+    this.out.write(`${ESC}7${ESC}[r${ESC}[${this.rows()};1H${ESC}[2K${ESC}8`);
+  }
+}

package/dist/theme.js

@@ -0,0 +1,146 @@
+// The Synqa palette and every colour escape the CLI emits. This file is the only place that builds
+// an escape sequence for colour; text from the model or from tools never reaches it as a code.
+// 24-bit colour only when the terminal is known to draw it (COLORTERM=truecolor|24bit, or a
+// TERM_PROGRAM known for it); macOS Terminal.app and anything unknown get xterm-256 colours, which
+// every modern terminal draws. NO_COLOR, a non-TTY or TERM=dumb turn all of it off.
+
+                                                    
+
+export const TERRACOTTA      = [0xc8, 0x5a, 0x32]; // #c85a32 accent: the period, spinner, prompt, monogram
+export const BONE      = [0xf0, 0xea, 0xd8]; // #f0ead8 warm bone: name and active values
+export const STONE      = [0x9e, 0x95, 0x85]; // #9e9585 warm stone: borders, labels, footer
+export const SAGE      = [0x4a, 0x7c, 0x59]; // #4a7c59 sage: balance highlights and added diff lines
+
+                                
+
+// depth is optional; absent means 256 colours, the safe choice (Terminal.app has no 24-bit colour).
+// bg is the terminal background when the environment says so (COLORFGBG); bone text is used only
+// on a known dark background, plain bold otherwise, so names read on light and dark themes.
+                                          
+                                                                            
+
+export function colorEnabled(env                                    , isTTY         )          {
+  if (env.NO_COLOR !== undefined && env.NO_COLOR !== "") return false;
+  if (env.TERM === "dumb") return false;
+  return isTTY;
+}
+
+// Terminals that draw 24-bit colour, by TERM_PROGRAM (compared lower case).
+const TRUECOLOR_PROGRAMS = new Set(["iterm.app", "wezterm", "vscode", "ghostty", "hyper", "tabby", "warpterminal", "rio", "kitty", "alacritty", "contour", "zed"]);
+
+export function colorDepth(env                                    )             {
+  const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+  // Terminal.app before macOS 26 misdraws 24-bit escapes, and a COLORTERM copied from another
+  // terminal's profile (or passed through ssh or tmux) must not switch them on there.
+  if (program === "apple_terminal") return 8;
+  const c = (env.COLORTERM ?? "").toLowerCase();
+  if (c === "truecolor" || c === "24bit") return 24;
+  if (TRUECOLOR_PROGRAMS.has(program)) return 24;
+  const term = (env.TERM ?? "").toLowerCase();
+  if (/(^|-)(kitty|alacritty|direct|truecolor|ghostty|wezterm)($|-)/.test(term) || term.endsWith("-direct")) return 24;
+  return 8;
+}
+
+// COLORFGBG ("15;0", or "15;default;0") names the background colour index when a terminal sets
+// it (rxvt, Konsole, iTerm2 with the option on). 0-6 and 8 are dark; 7 and 9-15 are light.
+export function detectBackground(env                                    )                         {
+  const raw = env.COLORFGBG;
+  if (!raw) return undefined;
+  const bg = Number(raw.split(";").pop());
+  if (!Number.isInteger(bg) || bg < 0 || bg > 15) return undefined;
+  return bg === 7 || bg >= 9 ? "light" : "dark";
+}
+
+const CUBE = [0, 95, 135, 175, 215, 255]         ;
+
+// Nearest xterm-256 colour: the best of the 6x6x6 cube (16..231) and the grey ramp (232..255).
+export function rgbTo256(rgb     )         {
+  const [r, g, b] = rgb;
+  const nearest = (v        ) => {
+    let best = 0;
+    for (let i = 1; i < CUBE.length; i++) {
+      if (Math.abs((CUBE[i]          ) - v) < Math.abs((CUBE[best]          ) - v)) best = i;
+    }
+    return best;
+  };
+  const ri = nearest(r);
+  const gi = nearest(g);
+  const bi = nearest(b);
+  const cubeIdx = 16 + 36 * ri + 6 * gi + bi;
+  const dist = (x     ) => (x[0] - r) ** 2 + (x[1] - g) ** 2 + (x[2] - b) ** 2;
+  const cubeDist = dist([CUBE[ri]          , CUBE[gi]          , CUBE[bi]          ]);
+  const grey = Math.min(23, Math.max(0, Math.round(((r + g + b) / 3 - 8) / 10)));
+  const level = 8 + 10 * grey;
+  const greyDist = dist([level, level, level]);
+  return greyDist < cubeDist ? 232 + grey : cubeIdx;
+}
+
+const RESET = "\x1b[0m";
+
+// The SGR parameters that select `rgb` as the foreground.
+// Hand-picked 256-colour stand-ins where the nearest match loses the brand: the nearest index for
+// terracotta (167) is a pink salmon; 166 (#d75f00) keeps the burnt orange and reads on light and
+// dark backgrounds.
+const TUNED_256 = new Map                ([[TERRACOTTA.join(","), 166]]);
+
+export function to256(rgb     )         {
+  return TUNED_256.get(rgb.join(",")) ?? rgbTo256(rgb);
+}
+
+export function fgParams(depth                        , rgb     )         {
+  return depth === 24 ? `38;2;${rgb[0]};${rgb[1]};${rgb[2]}` : `38;5;${to256(rgb)}`;
+}
+
+function paint(s       , params        , text        )         {
+  return s.color ? `\x1b[${params}m${text}${RESET}` : text;
+}
+
+export function terracotta(s       , text        )         {
+  return paint(s, fgParams(s.depth, TERRACOTTA), text);
+}
+
+// Bone on a known dark background; plain bold (the terminal's own text colour) otherwise, because
+// bone is nearly invisible on a light background.
+export function boneBold(s       , text        )         {
+  return paint(s, s.bg === "dark" ? `1;${fgParams(s.depth, BONE)}` : "1", text);
+}
+
+export function terracottaBold(s       , text        )         {
+  return paint(s, `1;${fgParams(s.depth, TERRACOTTA)}`, text);
+}
+
+export function stone(s       , text        )         {
+  return paint(s, fgParams(s.depth, STONE), text);
+}
+
+// Stone and bold together: labels stay readable on a light terminal background.
+export function stoneBold(s       , text        )         {
+  return paint(s, `1;${fgParams(s.depth, STONE)}`, text);
+}
+
+export function sage(s       , text        )         {
+  return paint(s, fgParams(s.depth, SAGE), text);
+}
+
+// Kept names: the accent is terracotta.
+export const accent = terracotta;
+
+export function dim(s       , text        )         {
+  return paint(s, "2", text);
+}
+
+export function bold(s       , text        )         {
+  return paint(s, "1", text);
+}
+
+export function green(s       , text        )         {
+  return paint(s, "32", text);
+}
+
+export function red(s       , text        )         {
+  return paint(s, "31", text);
+}
+
+export function cyan(s       , text        )         {
+  return paint(s, "36", text);
+}

package/dist/tiers.js

@@ -0,0 +1,53 @@
+                                                                
+
+export const TIERS                  = [
+  { key: "blink", id: "synqa-blink-5.5", display: "Blink 5.5" },
+  { key: "sonata", id: "synqa-sonata-6.0", display: "Sonata 6.0" },
+  { key: "aeon", id: "synqa-aeon-6.5", display: "Aeon 6.5" },
+];
+
+export const DEFAULT_TIER = "blink";
+
+// Reasoning effort the user can pick. "default" sends no reasoning_effort at all.
+export const EFFORTS = ["default", "low", "medium"]         ;
+                                              
+
+export function findEffort(name        )                     {
+  const n = name.trim().toLowerCase();
+  return EFFORTS.find((e) => e === n);
+}
+export const CONTEXT_TOKENS = 262144;
+export const MAX_OUTPUT_TOKENS = 16384;
+export const REQUEST_TIMEOUT_MS = 600_000;
+
+export function findTier(name        )                   {
+  const n = name.trim().toLowerCase();
+  return TIERS.find((t) => t.key === n || t.id === n);
+}
+
+// Map the x-synqa-routing header to what the status bar shows.
+// local and local-gated -> local, hybrid -> hybrid, fallback-* -> fallback, absent -> "?".
+export function routingLabel(header                           )         {
+  if (!header) return "?";
+  const v = header.trim().toLowerCase();
+  if (v === "local" || v === "local-gated") return "local";
+  if (v === "hybrid") return "hybrid";
+  if (v.startsWith("fallback")) return "fallback";
+  return "?";
+}
+
+                                                           
+
+export function usageFrom(raw         )                    {
+  if (!raw || typeof raw !== "object") return undefined;
+  const r = raw                           ;
+  const p = r.prompt_tokens;
+  const c = r.completion_tokens;
+  if (typeof p !== "number" && typeof c !== "number") return undefined;
+  return { prompt: typeof p === "number" ? p : 0, completion: typeof c === "number" ? c : 0 };
+}
+
+export function statusLine(tier      , routing        , usage       , total       )         {
+  const ctx = usage.prompt > 0 ? ` | ctx ${usage.prompt}/${CONTEXT_TOKENS}` : "";
+  return `${tier.display} | ${routing} | tokens ${total.prompt} in ${total.completion} out${ctx}`;
+}