@lzhzzzzwill/cofos 1.1.14 → 1.1.19

package/bin/cofos.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { spawn, spawnSync } from "node:child_process";
-import { createInterface, emitKeypressEvents } from "node:readline";
+import { clearLine, createInterface, cursorTo } from "node:readline";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -16,6 +16,7 @@ const DEFAULT_CONFIG = process.env.COFOS_CONFIG || "config/config.yaml";
 /* ─── ANSI ─── */
 const R = "\x1b[0m", B = "\x1b[1m", D = "\x1b[2m";
 const C = "\x1b[96m", W = "\x1b[97m", G = "\x1b[90m", Y = "\x1b[93m";
+const M = "\x1b[95m", BL = "\x1b[94m", GR = "\x1b[92m", A = "\x1b[38;5;208m";
 
 /* ─── Protocol markers ─── */
 const READY = "===READY===", RESPONSE = "===RESPONSE===", DONE = "===DONE===";
@@ -30,9 +31,16 @@ const ART_W = ART[0].length;
 
 function vis(t) { return t.replace(/\x1b\[[0-9;]*m/g, "").length; }
 function fw() { return Math.min(Math.max((process.stdout.columns || 110) - 2, 82), 150); }
-function top(w)  { return "╭" + "─".repeat(w) + "╮"; }
-function bot(w)  { return "╰" + "─".repeat(w) + "╯"; }
-function sep(w)  { return "├" + "─".repeat(w) + "┤"; }
+function plain(t) { return t.replace(/\x1b\[[0-9;]*m/g, ""); }
+function topTitle(w, left, right = "") {
+  const l = ` ${C}${B}${left}${R} `;
+  const r = right ? ` ${G}${right}${R} ` : "";
+  const room = Math.max(0, w - vis(l) - vis(r));
+  return C + "╭" + R + l + C + "─".repeat(room) + R + r + C + "╮" + R;
+}
+function top(w)  { return C + "╭" + "─".repeat(w) + "╮" + R; }
+function bot(w)  { return C + "╰" + "─".repeat(w) + "╯" + R; }
+function sep(w)  { return C + "├" + "─".repeat(w) + "┤" + R; }
 function vpad(t, w) { return t + " ".repeat(Math.max(0, w - vis(t))); }
 function clip(t, w) {
   const plain = t.replace(/\x1b\[[0-9;]*m/g, "");
@@ -41,12 +49,12 @@ function clip(t, w) {
   return plain.slice(0, w - 1) + "…";
 }
 function cell(t, w) { return vpad(clip(t, w), w); }
-function row(left, right, lw, rw) { return "│ " + cell(left, lw) + " │ " + cell(right, rw) + " │"; }
-function full(t, w) { return "│ " + cell(t, w - 2) + " │"; }
+function row(left, right, lw, rw) { return C + "│ " + R + cell(left, lw) + C + " │ " + R + cell(right, rw) + C + " │" + R; }
+function full(t, w) { return C + "│ " + R + cell(t, w - 2) + C + " │" + R; }
 function empty(w) { return full("", w); }
 
 function logoLines(width) {
-  if (width >= ART_W) return ART.map((line) => C + B + line + R);
+  if (width >= ART_W) return ART.map((line, i) => (i < 2 ? C : i < 4 ? BL : M) + B + line + R);
   return [C + B + "COFOS" + R];
 }
 
@@ -60,25 +68,26 @@ function render({ modelPath, cacheDir, pdfDir }) {
     ...logoLines(Math.floor((w - 5) * 0.48)),
     "",
     G + "Scientific RAG CLI" + R,
-    W + "Model" + R + "   " + modelPath,
-    W + "Params" + R + "  9B",
-    W + "Path" + R + "    " + cwd,
-    W + "Cache" + R + "   " + cacheDir,
+    Y + "Model" + R + "   " + W + modelPath + R,
+    Y + "Params" + R + "  " + W + "9B" + R,
+    Y + "Path" + R + "    " + W + cwd + R,
+    Y + "Cache" + R + "   " + W + cacheDir + R,
   ];
   const right = [
-    W + B + "What COFOS Does" + R,
+    GR + B + "What COFOS Does" + R,
     "COFOS answers scientific questions about covalent organic frameworks,",
     "photocatalysis, reactive oxygen species, and oxygen-reduction products.",
     rag,
     "",
-    W + B + "Suggested Commands" + R,
-    "/help      show commands and PDF-RAG usage",
-    "/topk 5    change retrieval depth",
-    "/rag off   answer without retrieval",
-    "cofos --pdf-dir ./new_pdfs   add local papers",
+    A + B + "Suggested Commands" + R,
+    C + "/help" + R + "      show commands and PDF-RAG usage",
+    C + "/topk 5" + R + "    change retrieval depth",
+    C + "/rag off" + R + "   answer without retrieval",
+    M + "cofos --pdf-dir ./new_pdfs" + R + "   add local papers",
   ];
 
-  const lines = [top(w)];
+  const titleLeft = `COFOS CLI v${pkg.version}`;
+  const lines = [topTitle(w, titleLeft)];
   if (w >= minSplit) {
     const inner = w - 5;
     const lw = Math.max(46, Math.floor(inner * 0.48));
@@ -114,7 +123,7 @@ function slashMatches(line) {
 function slashCompletions(line) {
   if (!line.startsWith("/")) return [[], line];
   const hits = slashMatches(line).map(({ cmd }) => cmd);
-  return [hits.length ? hits : SLASH_COMMANDS.map(({ cmd }) => cmd), line];
+  return [hits, line];
 }
 
 function slashHint(line = "/") {
@@ -247,6 +256,11 @@ function main() {
   const inputQ = [];
   const mainPrompt = C + "  cofos " + R;
   const contPrompt = G + "  ...   " + R;
+  const docked = Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  let dockRows = process.stdout.rows || 24;
+  let dockCols = process.stdout.columns || 80;
+  let historyRow = Math.max(0, dockRows - 2);
+  let historyCol = 0;
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -254,32 +268,72 @@ function main() {
     prompt: mainPrompt,
     completer: slashCompletions,
   });
-  let lastSlashHint = "";
   rl.on("line", (l) => {
-    lastSlashHint = "";
     if (!ready || generating) inputQ.push(l);
     else if (!handle(l)) ask();
   });
-  if (process.stdin.isTTY) {
-    emitKeypressEvents(process.stdin, rl);
-    process.stdin.on("keypress", () => {
-      if (!ready || generating || closed) return;
-      const line = rl.line || "";
-      if (!line.startsWith("/")) {
-        lastSlashHint = "";
-        return;
-      }
-      const key = line.trim();
-      if (key && key !== lastSlashHint) {
-        lastSlashHint = key;
-        rl.output.write(slashHint(line));
-        rl.prompt(true);
+
+  function resetDock() {
+    if (docked) process.stdout.write("\x1b[r");
+  }
+
+  function setupDock() {
+    if (!docked) return;
+    dockRows = process.stdout.rows || dockRows;
+    dockCols = process.stdout.columns || dockCols;
+    historyRow = Math.max(0, dockRows - 2);
+    historyCol = Math.min(historyCol, Math.max(0, dockCols - 1));
+    process.stdout.write(`\x1b[1;${Math.max(1, dockRows - 1)}r`);
+    cursorTo(process.stdout, 0, dockRows - 1);
+    clearLine(process.stdout, 0);
+  }
+
+  function redrawInput() {
+    if (!docked || closed) return;
+    cursorTo(rl.output, 0, dockRows - 1);
+    clearLine(rl.output, 0);
+    rl.prompt(true);
+  }
+
+  function writeHistory(data) {
+    if (!docked) {
+      process.stdout.write(data);
+      return;
+    }
+    cursorTo(process.stdout, historyCol, historyRow);
+    for (const ch of data) {
+      process.stdout.write(ch);
+      if (ch === "\n") {
+        historyCol = 0;
+      } else if (ch === "\r") {
+        historyCol = 0;
+      } else {
+        historyCol += 1;
+        if (historyCol >= dockCols) historyCol = 0;
       }
-    });
+    }
+    redrawInput();
   }
 
-  // Forward Python stderr (status / progress messages) to our stderr.
-  proc.stderr.on("data", (chunk) => { process.stderr.write(chunk); });
+  function preserveInputWrite(stream, chunk) {
+    const data = String(chunk);
+    if (!rl.terminal || closed) {
+      stream.write(data);
+      return;
+    }
+    writeHistory(data);
+  }
+
+  setupDock();
+  process.stdout.on("resize", () => { setupDock(); redrawInput(); });
+
+  // Let users type while the Python backend is still loading. Submitted lines
+  // are queued until READY, while status logs are written above and the input
+  // line is restored afterward.
+  ask();
+
+  // Forward Python stderr (status / progress messages) without destroying the input line.
+  proc.stderr.on("data", (chunk) => { preserveInputWrite(process.stderr, chunk); });
 
   proc.stdout.on("data", (chunk) => {
     buf += chunk;
@@ -314,19 +368,19 @@ function main() {
     const di = buf.indexOf(DONE);
     if (di !== -1) {
       const pre = buf.slice(0, di);
-      if (pre) process.stdout.write(pre);
+      if (pre) preserveInputWrite(process.stdout, pre);
       buf = buf.slice(di + DONE.length);
       if (buf[0] === "\n") buf = buf.slice(1);
       generating = false;
       responseOpen = false;
-      console.log("");
+      preserveInputWrite(process.stdout, "\n");
       drain();
     } else {
       // Stream buffered content, keeping enough tail to catch a partial DONE marker.
       const keep = DONE.length - 1;
       if (buf.length > keep) {
         const out = buf.slice(0, -keep);
-        if (out) process.stdout.write(out);
+        if (out) preserveInputWrite(process.stdout, out);
         buf = buf.slice(-keep);
       }
     }
@@ -335,6 +389,7 @@ function main() {
   proc.on("error", (e) => { console.error("[cofos] Python error:", e.message); process.exit(1); });
   proc.on("exit", (c) => {
     closed = true;
+    resetDock();
     if (c && c !== 0) console.error("[cofos] Python exited with code", c);
     try { rl.close(); } catch (_) {}
     // Let queued stdout writes flush before tearing the process down.
@@ -344,6 +399,7 @@ function main() {
   function shutdown() {
     if (closed) return;
     closed = true;
+    resetDock();
     try { proc.stdin.end(); } catch (_) {}
     try { rl.close(); } catch (_) {}
     proc.kill("SIGTERM");
@@ -353,6 +409,7 @@ function main() {
   rl.on("SIGINT", () => { console.log("\n[cofos] Interrupted."); shutdown(); });
   rl.on("close", () => { if (!closed) shutdown(); });
   process.on("SIGTERM", shutdown);
+  process.on("exit", resetDock);
 
   function drain() {
     while (inputQ.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lzhzzzzwill/cofos",
-  "version": "1.1.14",
+  "version": "1.1.19",
   "description": "COFOS 9B + RAG chat CLI with optional local PDF ingestion.",
   "type": "module",
   "bin": {