nou-cli 0.5.2 → 0.5.4

package/dist/src/providers/anthropic.js

@@ -81,7 +81,7 @@ export function anthropicProvider() {
             apiKey: process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || "",
             api: "anthropic-messages",
         }),
-        async chat({ model, system, messages, tools, onText, signal, effort: requested }) {
+        async chat({ model, system, messages, tools, onText, onThinking, signal, effort: requested }) {
             const fallbacks = FALLBACK_MODELS.test(model);
             const effort = EFFORT_MODELS.test(model) ? process.env.NOU_EFFORT ?? requested ?? "high" : undefined;
             const body = {
@@ -105,20 +105,9 @@ export function anthropicProvider() {
                 let text = "";
                 try {
                     const stream = getClient().beta.messages.stream(body, signal ? { signal } : {});
-                    // Thinking streams as a quote above the reply (the chat shows quotes dimmed); only the reply is kept.
-                    let thinking = false;
-                    stream.on("thinking", (delta) => {
-                        const piece = `${thinking ? "" : "> "}${delta.replace(/\n/g, "\n> ")}`;
-                        thinking = true;
-                        text += piece;
-                        onText(piece);
-                    });
+                    // Thinking goes to the progress line, not the reply: it isn't kept, so it mustn't reflow the chat.
+                    stream.on("thinking", (delta) => onThinking?.(delta));
                     stream.on("text", (delta) => {
-                        if (thinking) {
-                            thinking = false;
-                            text += "\n\n";
-                            onText("\n\n");
-                        }
                         text += delta;
                         onText(delta);
                     });

package/dist/src/syntax/index.js

@@ -101,28 +101,27 @@ const CALLS = /^(call_expression|call|method_invocation|new_expression)$/;
 /** A named string node (anonymous keyword nodes can also be called "string", e.g. the TS type). */
 const isString = (n) => n.isNamed && STRINGS.test(n.type);
 const hasSubstitution = (n) => n.children.some((c) => c !== null && /substitution|interpolation/.test(c.type));
-function colorFor(node) {
+/**
+ * The color of a leaf. Its `parent` and `grand`parent and whether it's `inString` come from the walk over
+ * the tree: asking the node for them (node.parent) crosses into wasm, and every token used to, several times.
+ */
+function colorFor(node, parent, grand, inString) {
     const type = node.type;
     if (type.includes("comment"))
         return "comment";
     // Inside a string (but not inside ${...} substitutions)?
-    for (let p = node; p; p = p.parent) {
-        if (/substitution|interpolation/.test(p.type))
-            break;
-        if (isString(p))
-            return "string";
-    }
+    if (inString || isString(node))
+        return "string";
     // Built-in type names (`number`, `string`) and Python annotations (`name: str`).
-    if (node.parent?.type === "predefined_type" || (node.parent?.type === "type" && /identifier$/.test(type)))
+    if (parent?.type === "predefined_type" || (parent?.type === "type" && /identifier$/.test(type)))
         return "type";
     if (NUMBERS.test(type))
         return "number";
     if (CONSTANTS.test(type) || CONSTANTS.test(node.text))
         return node.isNamed || /^[a-zA-Z]+$/.test(node.text) ? "constant" : null;
-    if (TYPES.test(type) && (node.isNamed || node.parent?.type === "predefined_type"))
+    if (TYPES.test(type) && (node.isNamed || parent?.type === "predefined_type"))
         return "type";
     if (/identifier$/.test(type)) {
-        const parent = node.parent;
         if (parent && FUNCTION_PARENTS.test(parent.type) && parent.childForFieldName("name")?.equals(node))
             return "func";
         if (parent && CALLS.test(parent.type) && parent.childForFieldName("function")?.equals(node))
@@ -131,7 +130,7 @@ function colorFor(node) {
         const member = parent && /member_expression|attribute|field_expression|selector_expression/.test(parent.type)
             ? parent.childForFieldName("property") ?? parent.childForFieldName("attribute") ?? parent.childForFieldName("field")
             : null;
-        if (member?.equals(node) && parent.parent && CALLS.test(parent.parent.type) && parent.parent.childForFieldName("function")?.equals(parent))
+        if (member?.equals(node) && grand && CALLS.test(grand.type) && grand.childForFieldName("function")?.equals(parent))
             return "func";
     }
     if (PROPERTIES.test(type))
@@ -146,7 +145,7 @@ function colorFor(node) {
         return null;
     }
     if (!node.isNamed) {
-        if (node.parent?.type === "predefined_type")
+        if (parent?.type === "predefined_type")
             return "type";
         return /^[a-z_]+$/i.test(type) ? "keyword" : "punctuation";
     }
@@ -162,14 +161,14 @@ export function highlightTree(file, text) {
     let out = "";
     let pos = 0;
     const cursor = tree.walk();
-    // Depth-first over leaves, coloring each span.
-    const visit = () => {
+    // Depth-first over leaves, coloring each span; each level knows its parent, grandparent and whether it's in a string.
+    const visit = (parent, grand, inString) => {
         do {
             const node = cursor.currentNode;
             if (node.childCount === 0 || node.type.includes("comment") || (isString(node) && !hasSubstitution(node))) {
                 if (node.startIndex >= pos) {
                     out += themeColors().plain(text.slice(pos, node.startIndex));
-                    const color = colorFor(node);
+                    const color = colorFor(node, parent, grand, inString);
                     const span = text.slice(node.startIndex, node.endIndex);
                     // Color each line separately so styles don't bleed across line breaks.
                     out += span.split("\n").map((part) => (color ? themeColors()[color](part) : themeColors().plain(part))).join("\n");
@@ -177,13 +176,14 @@ export function highlightTree(file, text) {
                 }
             }
             else if (cursor.gotoFirstChild()) {
-                visit();
+                // A ${...} substitution inside a string starts code again.
+                visit(node, parent, /substitution|interpolation/.test(node.type) ? false : inString || isString(node));
                 cursor.gotoParent();
             }
         } while (cursor.gotoNextSibling());
     };
     if (cursor.gotoFirstChild())
-        visit();
+        visit(tree.rootNode, null, false);
     out += themeColors().plain(text.slice(pos));
     tree.delete();
     return out.split("\n");

package/dist/src/terminal/index.js

@@ -0,0 +1,127 @@
+import { spawn } from "child_process";
+import { existsSync, statSync } from "fs";
+import os from "os";
+import path from "path";
+import { stripVTControlCharacters } from "util";
+import { stopProcess } from "../commands/index.js";
+/** Lines of output kept (the oldest go first). */
+const KEEP = 3000;
+/**
+ * The terminal panel's shell: runs what you type with your shell in the folder you've `cd`'d to, and
+ * keeps the output. Each command is its own process (no native pseudo-terminal), so full-screen programs
+ * like vim won't draw, but builds, tests, git and servers work, and what you type while one runs goes
+ * to it.
+ */
+export class Shell {
+    onChange;
+    lines = [];
+    cwd = process.cwd();
+    child = null;
+    /** The line being written (output without its newline yet; a \r starts it over, like progress bars). */
+    partial = "";
+    constructor(onChange) {
+        this.onChange = onChange;
+        process.once("exit", () => this.interrupt()); // nothing it started is left running after Nou
+    }
+    get running() {
+        return !!this.child;
+    }
+    /** Runs a command line; `cd` and `clear` are handled here so they stick. */
+    run(command) {
+        const line = command.trim();
+        if (!line)
+            return;
+        if (this.child)
+            return this.input(command);
+        this.push({ text: `${this.prompt()}${line}`, kind: "command" });
+        if (line === "clear" || line === "cls") {
+            this.lines = [];
+            return this.onChange();
+        }
+        const cd = /^cd(?:\s+(.*))?$/.exec(line);
+        if (cd)
+            return this.changeDir(cd[1]?.trim().replace(/^["']|["']$/g, "") || os.homedir());
+        const posix = process.platform !== "win32";
+        const child = spawn(line, {
+            cwd: this.cwd,
+            shell: posix ? process.env.SHELL || true : true,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: posix, // its own process group, so Ctrl+C stops everything it started
+            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+        });
+        this.child = child;
+        const write = (chunk) => this.write(chunk.toString("utf-8"));
+        child.stdout?.on("data", write);
+        child.stderr?.on("data", write);
+        child.stdin?.on("error", () => { }); // it may exit before reading what you typed
+        child.on("error", (error) => this.push({ text: error.message, kind: "error" }));
+        child.on("close", (code, signal) => {
+            this.flush();
+            if (signal)
+                this.push({ text: "stopped", kind: "info" });
+            else if (code)
+                this.push({ text: `exit ${code}`, kind: "error" });
+            this.child = null;
+            this.onChange();
+        });
+        this.onChange();
+    }
+    /** Text for the running command's input (it gets a newline, like pressing Enter in a terminal). */
+    input(text) {
+        if (!this.child?.stdin?.writable)
+            return;
+        this.push({ text, kind: "command" });
+        this.child.stdin.write(`${text}\n`);
+    }
+    /** Ctrl+C: stops the running command. */
+    interrupt() {
+        if (this.child)
+            stopProcess(this.child);
+    }
+    clear() {
+        this.lines = [];
+        this.partial = "";
+        this.onChange();
+    }
+    dispose() {
+        this.interrupt();
+    }
+    prompt() {
+        const home = os.homedir();
+        const where = this.cwd === home ? "~" : this.cwd.startsWith(home + path.sep) ? `~${this.cwd.slice(home.length)}` : this.cwd;
+        return `${where.length > 30 ? `…${path.sep}${path.basename(where)}` : where} $ `;
+    }
+    changeDir(target) {
+        const next = path.resolve(this.cwd, target.startsWith("~") ? path.join(os.homedir(), target.slice(1)) : target);
+        if (!existsSync(next) || !statSync(next).isDirectory())
+            this.push({ text: `cd: no such folder: ${target}`, kind: "error" });
+        else
+            this.cwd = next;
+        this.onChange();
+    }
+    write(text) {
+        const parts = stripVTControlCharacters(text).replace(/\r\n/g, "\n").split("\n");
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            // A carriage return goes back to the start of the line: what follows replaces it.
+            this.partial = part.includes("\r") ? part.slice(part.lastIndexOf("\r") + 1) || this.partial : this.partial + part;
+            if (i < parts.length - 1)
+                this.flush(true);
+        }
+        this.onChange();
+    }
+    flush(always = false) {
+        if (this.partial || always)
+            this.push({ text: this.partial.replace(/\t/g, "  "), kind: "out" });
+        this.partial = "";
+    }
+    /** The output so far, with the line still being written. */
+    view() {
+        return this.partial ? [...this.lines, { text: this.partial, kind: "out" }] : this.lines;
+    }
+    push(line) {
+        this.lines.push(line);
+        if (this.lines.length > KEEP)
+            this.lines.splice(0, this.lines.length - KEEP);
+    }
+}