nou-cli 0.5.6 → 0.5.11

package/dist/src/ui/commands.js

@@ -2,19 +2,59 @@
  * Commands that only change what's on screen (or handle a busy Nou themselves): they run right away
  * while Nou works instead of waiting in the queue behind it.
  */
-const INSTANT = new Set(["fold", "unfold", "redraw", "new", "tab", "close", "terminal", "games", "open", "settings", "auto", "diff", "sessions", "history", "problems", "copy", "help", "version", "cancel"]);
+const INSTANT = new Set(["zoom", "now", "fold", "unfold", "redraw", "new", "tab", "close", "terminal", "games", "open", "settings", "auto", "diff", "sessions", "history", "problems", "copy", "help", "version", "cancel"]);
 /** Whether a typed command runs right away while Nou works (see INSTANT); `/showme` counts only to look or step. */
+/**
+ * The command a mistyped name means: the same letters in another order ("/termnial"), or one letter off
+ * ("/termial", "/terminall"). Only when exactly one command fits, so a typo never runs the wrong one.
+ */
+export function closestCommand(name, names) {
+    const word = name.toLowerCase();
+    if (word.length < 3)
+        return null;
+    const sorted = (s) => [...s].sort().join("");
+    const anagrams = names.filter((n) => n.length === word.length && sorted(n) === sorted(word));
+    if (anagrams.length === 1)
+        return anagrams[0];
+    if (anagrams.length > 1)
+        return null;
+    const near = names.filter((n) => editDistance(word, n) <= 1);
+    return near.length === 1 ? near[0] : null;
+}
+/** Levenshtein distance, stopping early once it's over 1 (all closestCommand needs). */
+function editDistance(a, b) {
+    if (Math.abs(a.length - b.length) > 1)
+        return 2;
+    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        const row = [i];
+        for (let j = 1; j <= b.length; j++)
+            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        if (Math.min(...row) > 1)
+            return 2;
+        prev = row;
+    }
+    return prev[b.length];
+}
 export function runsWhileBusy(text) {
     const [name, ...rest] = text.slice(1).trim().split(/\s+/);
-    if (name === "showme" || name === "teach")
-        return !rest.length || /^(next|skip|stop|end)$/.test(rest.join(" "));
-    return text.startsWith("/") && INSTANT.has(name ?? "");
+    if (name === "showme" || name === "teach" || name === "teachme")
+        return !rest.length || /^(next|skip|back|prev|previous|stop|end|done|clear)$/.test(rest.join(" "));
+    if (!text.startsWith("/") || !name)
+        return false;
+    return INSTANT.has(name) || INSTANT.has(closestCommand(name, SLASH_COMMANDS.map((c) => c.name)) ?? "");
 }
+/** Whether a command only changes what's on screen, so running it for a typo can't do harm. */
+export const onlyChangesScreen = (name) => INSTANT.has(name);
 export const SLASH_COMMANDS = [
     { name: "model", args: "[provider:model]", description: "show or switch the model" },
     { name: "models", args: "[provider]", description: "list the models a provider offers" },
     { name: "connect", args: "<provider>", description: "enter an API key (and URL) for a provider" },
     { name: "open", args: "<file>[:line]", description: "open a file in the code view (part of its name is enough)" },
+    { name: "effort", args: "[fastest|fast|balanced|smarter|smartest]", description: "speed vs smarts: how hard the model thinks (cheaper + faster, or smarter)" },
+    { name: "workspace", args: "[new <folder> | n]", description: "several projects in this window, a tab each in the header: open one, or switch" },
+    { name: "zoom", args: "in|out|reset", description: "make the code panel bigger or smaller (+ and - with the code focused, = resets)" },
+    { name: "now", description: "stop Nou and send your queued messages right away (or click them)" },
     { name: "settings", description: "models, engine, preferences and plugins" },
     { name: "auto", args: "[ask|auto-edit|auto]", description: "how much Nou does without asking" },
     { name: "engine", args: "[name]", description: "which agent answers: nou, claude-code, codex or pi" },
@@ -28,8 +68,8 @@ export const SLASH_COMMANDS = [
     { name: "copy", args: "[code|file]", description: "copy the last reply, its last code block, or the open file" },
     { name: "compact", description: "summarize the conversation to free up context" },
     { name: "clear", description: "start a fresh conversation" },
-    { name: "showme", args: "<what you want>", description: "Nou shows you how, step by step, and you type it (with the code shown ahead of your cursor)" },
-    { name: "teach", args: "<what you want>", description: "same as /showme: Nou teaches you to make the change yourself, step by step" },
+    { name: "showme", args: "<question>", description: "Nou explains it and opens the places in the code, highlighted (next/back step through them); any engine" },
+    { name: "teach", args: "<what you want>", description: "Nou walks you through making the change yourself, step by step, with the code shown ahead of your cursor" },
     { name: "new", description: "a new conversation tab: another agent, working alongside this one" },
     { name: "tab", args: "[n]", description: "list the conversation tabs, or switch to tab n" },
     { name: "close", description: "close this conversation tab (it stays saved for /resume)" },

package/dist/src/ui/keys.js

@@ -0,0 +1,8 @@
+/**
+ * Keys named the way the platform names them. On a Mac, Find is Cmd+F: terminals that report the Cmd key
+ * (kitty's keyboard protocol, which Nou asks for: Ghostty, kitty, WezTerm, iTerm2) send it as "super". Ctrl+F
+ * works everywhere too, for terminals that keep Cmd for themselves.
+ */
+export const FIND_KEY = process.platform === "darwin" ? "Cmd+F" : "Ctrl+F";
+/** Ctrl+F, or Cmd+F where the terminal reports Cmd. */
+export const isFind = (input, key) => input === "f" && (!!key.ctrl || !!key.super);

package/dist/src/ui/theme.js

@@ -1,6 +1,9 @@
 import path from "path";
-/** Tokyo Night inspired palette (truecolor; Windows Terminal supports it). */
-export const C = {
+/**
+ * Tokyo Night inspired palette (truecolor; Windows Terminal supports it). Secondary text ("dim") is still at
+ * least 4.5:1 against common dark backgrounds, so hints and help lines stay easy to read.
+ */
+const DARK = {
     accent: "#7aa2f7",
     accent2: "#bb9af7",
     cyan: "#7dcfff",
@@ -9,27 +12,70 @@ export const C = {
     orange: "#ff9e64",
     red: "#f7768e",
     text: "#c0caf5",
-    dim: "#565f89",
+    dim: "#8b93c0",
+    /** Lines around panes that aren't focused: quieter than text, since they aren't read. */
+    border: "#565f89",
     panel: "#1f2335",
+    /** Text on a colored badge (CHAT, CLOUD, EDITING...). */
+    onBadge: "#1a1b26",
 };
+/** For terminals with a light background: the same roles, dark enough to read on white (4.5:1 or more). */
+const LIGHT = {
+    accent: "#2e59c9",
+    accent2: "#7341c2",
+    cyan: "#007197",
+    green: "#3b7a1e",
+    yellow: "#8f5e00",
+    orange: "#b4501b",
+    red: "#c2264b",
+    text: "#1f2335",
+    dim: "#5a607a",
+    border: "#a8aecb",
+    panel: "#e6e7ed",
+    onBadge: "#ffffff",
+};
+/** The colors in use: dark unless the terminal is light (see setPalette). Read at render time, so set it first. */
+export const C = { ...DARK };
+let current = "dark";
+export const palette = () => current;
+/** Switches every color to the dark or light set. Call before the first render. */
+export function setPalette(which) {
+    current = which;
+    Object.assign(C, which === "light" ? LIGHT : DARK);
+    Object.assign(GIT_COLORS, gitColors());
+    for (const [ext, color] of Object.entries(iconColors()))
+        ICONS[ext][1] = color;
+}
 /** Every spinner and shimmer ticks on this one interval, so they redraw together in a single frame. */
 export const ANIMATION_MS = 100;
 export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const GRADIENT = [C.accent, "#8c9cf7", C.accent2, "#c39af2", "#e08ad6", C.red, C.orange, C.yellow, C.green, C.cyan];
+const gradientColors = () => current === "light"
+    ? [C.accent, "#4b4fc4", C.accent2, "#8a3fb0", "#a8327f", C.red, C.orange, C.yellow, C.green, C.cyan]
+    : [C.accent, "#8c9cf7", C.accent2, "#c39af2", "#e08ad6", C.red, C.orange, C.yellow, C.green, C.cyan];
 /** Colors for each character of a label, shifted by `frame` so it shimmers when animated. */
 export function gradient(text, frame = 0) {
-    return [...text].map((ch, i) => ({ ch, color: GRADIENT[(i + frame) % GRADIENT.length] }));
+    const colors = gradientColors();
+    return [...text].map((ch, i) => ({ ch, color: colors[(i + frame) % colors.length] }));
 }
-export const GIT_COLORS = {
-    M: C.yellow, A: C.green, "?": C.green, D: C.red, R: C.cyan, U: C.orange,
+const gitColors = () => ({ M: C.yellow, A: C.green, "?": C.green, D: C.red, R: C.cyan, U: C.orange });
+export const GIT_COLORS = gitColors();
+/** Each file type's icon color: language colors, with JavaScript's yellow darkened on a light background. */
+const iconColors = () => {
+    const js = current === "light" ? "#8a7400" : "#f1e05a";
+    return {
+        ".ts": "#3178c6", ".tsx": C.cyan, ".mts": "#3178c6", ".cts": "#3178c6",
+        ".js": js, ".jsx": C.cyan, ".mjs": js, ".cjs": js,
+        ".py": "#3572a5", ".json": C.yellow, ".md": C.text, ".css": C.accent2,
+        ".html": C.orange, ".yml": C.red, ".yaml": C.red, ".go": C.cyan,
+        ".rs": C.orange, ".sh": C.green, ".ps1": C.accent, ".lock": C.dim,
+    };
 };
-const ICONS = {
-    ".ts": ["◆", "#3178c6"], ".tsx": ["◆", C.cyan], ".mts": ["◆", "#3178c6"], ".cts": ["◆", "#3178c6"],
-    ".js": ["◆", "#f1e05a"], ".jsx": ["◆", C.cyan], ".mjs": ["◆", "#f1e05a"], ".cjs": ["◆", "#f1e05a"],
-    ".py": ["◆", "#3572a5"], ".json": ["◇", C.yellow], ".md": ["≡", C.text], ".css": ["◆", C.accent2],
-    ".html": ["◆", C.orange], ".yml": ["◇", C.red], ".yaml": ["◇", C.red], ".go": ["◆", C.cyan],
-    ".rs": ["◆", C.orange], ".sh": ["$", C.green], ".ps1": ["$", C.accent], ".lock": ["◌", C.dim],
+const ICON_SHAPES = {
+    ".ts": "◆", ".tsx": "◆", ".mts": "◆", ".cts": "◆", ".js": "◆", ".jsx": "◆", ".mjs": "◆", ".cjs": "◆",
+    ".py": "◆", ".json": "◇", ".md": "≡", ".css": "◆", ".html": "◆", ".yml": "◇", ".yaml": "◇", ".go": "◆",
+    ".rs": "◆", ".sh": "$", ".ps1": "$", ".lock": "◌",
 };
+const ICONS = Object.fromEntries(Object.entries(iconColors()).map(([ext, color]) => [ext, [ICON_SHAPES[ext], color]]));
 export function fileIcon(file) {
     const base = path.basename(file).toLowerCase();
     if (base.startsWith(".env"))

package/dist/src/workspaces/client.js

@@ -0,0 +1,69 @@
+import net from "net";
+import path from "path";
+import { useSyncExternalStore } from "react";
+let tabs = [];
+const listeners = new Set();
+let socket = null;
+/** Whether this Nou is one workspace of several (run by the host). */
+export const isHosted = () => !!process.env.NOU_HOST_PORT && !!process.env.NOU_WORKSPACE_ID;
+export function workspaceTabs() {
+    return tabs;
+}
+export function useWorkspaceTabs() {
+    return useSyncExternalStore((fn) => {
+        listeners.add(fn);
+        return () => listeners.delete(fn);
+    }, workspaceTabs, workspaceTabs);
+}
+/** One JSON message a line. */
+export function lineReader(onMessage) {
+    let carry = "";
+    return (chunk) => {
+        carry += String(chunk);
+        let at;
+        while ((at = carry.indexOf("\n")) >= 0) {
+            const line = carry.slice(0, at);
+            carry = carry.slice(at + 1);
+            try {
+                onMessage(JSON.parse(line));
+            }
+            catch {
+                // not ours
+            }
+        }
+    };
+}
+/** Connects to the host (when hosted) and passes on what it says. */
+export function connectToHost(on) {
+    if (!isHosted() || socket)
+        return;
+    const s = net.connect(Number(process.env.NOU_HOST_PORT), "127.0.0.1");
+    s.unref(); // never what keeps Nou running once you quit it
+    socket = s;
+    s.on("connect", () => sendToHost({ type: "hello", id: process.env.NOU_WORKSPACE_ID, token: process.env.NOU_HOST_TOKEN ?? "" }));
+    s.on("data", lineReader((msg) => {
+        if (msg.type === "tabs") {
+            tabs = msg.tabs;
+            for (const fn of listeners)
+                fn();
+        }
+        else if (msg.type === "redraw")
+            on.redraw();
+        else if (msg.type === "error")
+            on.error(msg.text);
+    }));
+    s.on("error", () => { });
+    s.on("close", () => (socket = null));
+}
+export function sendToHost(msg) {
+    if (!socket || socket.destroyed)
+        return false;
+    socket.write(`${JSON.stringify(msg)}\n`);
+    return true;
+}
+/** What a tab is called: the folder's name. */
+export const tabName = (folder) => path.basename(path.resolve(folder)) || folder;
+/** Set when this Nou should reopen as a workspaces window as it quits (see cli.ts). */
+let reopenAs = null;
+export const reopenAsWorkspaces = (folders) => (reopenAs = folders);
+export const pendingWorkspaces = () => reopenAs;

package/dist/src/workspaces/host.js

@@ -0,0 +1,144 @@
+import { randomBytes } from "crypto";
+import { existsSync, statSync } from "fs";
+import net from "net";
+import os from "os";
+import path from "path";
+import { loadPackage } from "../engines/index.js";
+import { lineReader, tabName } from "./client.js";
+/** The pseudo-terminal package workspaces run in, installed on first use into ~/.nou/engines like an engine. */
+export const PTY_PACKAGE = "@lydell/node-pty";
+/** A folder for a new workspace: `~` and relative paths (from `from`) resolved; null when it isn't a folder. */
+export function workspaceFolder(folder, from) {
+    const raw = folder.trim().replace(/^["']|["']$/g, "") || from;
+    const full = path.resolve(from, raw.startsWith("~") ? path.join(os.homedir(), raw.slice(1)) : raw);
+    try {
+        return existsSync(full) && statSync(full).isDirectory() ? full : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Runs the workspaces window: each folder becomes a workspace, a whole Nou in its own pseudo-terminal. Only
+ * the active one is drawn; the others keep working (their agents too) and draw everything again when you
+ * switch to them. `firstArgs` go to the first workspace (e.g. --continue, to pick its conversation back up).
+ * Resolves with the exit code once the last workspace is closed.
+ */
+export async function runHost(folders, firstArgs, command = [process.execPath, process.argv[1]]) {
+    const mod = await loadPackage(PTY_PACKAGE);
+    const spawnPty = mod.spawn ?? mod.default?.spawn;
+    const token = randomBytes(16).toString("hex");
+    const workspaces = [];
+    let active = null;
+    let nextId = 1;
+    const size = () => ({ cols: process.stdout.columns || 120, rows: process.stdout.rows || 40 });
+    const send = (w, msg) => w.socket?.write(`${JSON.stringify(msg)}\n`);
+    const tabs = () => workspaces.map((w) => ({ id: w.id, name: tabName(w.folder), folder: w.folder, busy: w.busy, active: w === active }));
+    const broadcast = () => {
+        const list = tabs();
+        for (const w of workspaces)
+            send(w, { type: "tabs", tabs: list });
+    };
+    const activate = (w) => {
+        active = w;
+        broadcast();
+        send(w, { type: "redraw" });
+    };
+    const server = net.createServer((socket) => {
+        socket.on("data", lineReader((msg) => {
+            const from = workspaces.find((w) => w.socket === socket);
+            if (msg.type === "hello") {
+                const w = workspaces.find((x) => x.id === msg.id);
+                if (!w || msg.token !== token)
+                    return socket.destroy(); // only our own workspaces
+                w.socket = socket;
+                send(w, { type: "tabs", tabs: tabs() });
+                if (w === active)
+                    send(w, { type: "redraw" });
+                return;
+            }
+            if (!from)
+                return;
+            if (msg.type === "state") {
+                from.busy = msg.busy;
+                broadcast();
+            }
+            else if (msg.type === "switch") {
+                const to = workspaces[msg.index];
+                if (to && to !== active)
+                    activate(to);
+            }
+            else if (msg.type === "new") {
+                const folder = workspaceFolder(msg.folder, from.folder);
+                if (!folder)
+                    return send(from, { type: "error", text: `No such folder: ${msg.folder}` });
+                activate(open(folder, []));
+            }
+        }));
+        socket.on("error", () => { });
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const port = server.address().port;
+    let finish = () => { };
+    const done = new Promise((resolve) => (finish = resolve));
+    function open(folder, args) {
+        const id = String(nextId++);
+        const { cols, rows } = size();
+        const pty = spawnPty(command[0], [...command.slice(1), ...args], {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: folder,
+            env: { ...process.env, NOU_HOST_PORT: String(port), NOU_HOST_TOKEN: token, NOU_WORKSPACE_ID: id },
+        });
+        const w = { id, folder, pty, busy: false, socket: null };
+        workspaces.push(w);
+        pty.onData((data) => {
+            if (w === active)
+                process.stdout.write(data);
+        });
+        pty.onExit(({ exitCode }) => {
+            const at = workspaces.indexOf(w);
+            if (at >= 0)
+                workspaces.splice(at, 1);
+            w.socket?.destroy();
+            if (!workspaces.length)
+                return finish(exitCode);
+            if (w === active)
+                activate(workspaces[Math.min(at, workspaces.length - 1)]);
+            else
+                broadcast();
+        });
+        return w;
+    }
+    // Keys and mouse go to the workspace on screen; a resize goes to all of them.
+    const stdin = process.stdin;
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdin.resume();
+    const onInput = (data) => active?.pty.write(data.toString("utf-8"));
+    stdin.on("data", onInput);
+    const onResize = () => {
+        const { cols, rows } = size();
+        for (const w of workspaces)
+            w.pty.resize(cols, rows);
+    };
+    process.stdout.on("resize", onResize);
+    const killAll = () => {
+        for (const w of workspaces)
+            w.pty.kill();
+    };
+    process.on("exit", killAll);
+    folders.forEach((folder, i) => open(folder, i === 0 ? firstArgs : []));
+    active = workspaces[workspaces.length - 1] ?? null; // the one just opened is the one you asked for
+    broadcast();
+    const code = await done;
+    stdin.off("data", onInput);
+    if (stdin.isTTY)
+        stdin.setRawMode(false);
+    stdin.pause();
+    process.stdout.off("resize", onResize);
+    process.off("exit", killAll);
+    server.close();
+    return code;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nou-cli",
-  "version": "0.5.6",
+  "version": "0.5.11",
   "description": "Nou: an IDE-style AI coding assistant for your terminal. Local (Ollama, LM Studio) and cloud (Claude, OpenAI, Gemini...) models, live diffs, git-aware, built-in editor.",
   "type": "module",
   "bin": {
@@ -61,6 +61,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@lydell/node-pty": "1.2.0-beta.18",
     "@types/node": "^22.20.5",
     "@types/react": "^19.3.0",
     "eslint": "^10.2.0",