nou-cli 0.5.1 → 0.5.3

package/dist/src/ui/definition.js

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { projectFiles } from "../search/index.js";
+const IDENT = /[A-Za-z_$][\w$]*/g;
+/** Lines that bring names in from another file, with the module path as group 1 (or 2 for Python's from). */
+const IMPORT_LINE = /^\s*(?:import\b.*?from\s+["']([^"']+)["']|import\s+["']([^"']+)["']|export\b.*?from\s+["']([^"']+)["']|.*\brequire\(\s*["']([^"']+)["']\s*\)|from\s+([\w.]+)\s+import\b|import\s+([\w.]+))/;
+const STRING = /(["'`])((?:\\.|(?!\1).)*)\1/g;
+/** The identifier at column `col` (1-based) of a line, if any. */
+export function wordAt(text, col) {
+    for (const m of text.matchAll(IDENT)) {
+        if (col - 1 >= m.index && col - 1 < m.index + m[0].length)
+            return { word: m[0], start: m.index + 1 };
+    }
+    return null;
+}
+/** The module an import line names, e.g. "./b.js" or "pkg.mod". */
+function importedModule(line) {
+    const m = line.match(IMPORT_LINE);
+    return m ? m.slice(1).find((g) => g) ?? null : null;
+}
+/** The file a module path resolves to from `fromFile`: relative imports and Python modules in the project. */
+export function resolveModule(fromFile, spec) {
+    const dir = path.dirname(fromFile);
+    const candidates = [];
+    if (spec.startsWith(".") || spec.startsWith("/")) {
+        const base = path.join(dir, spec);
+        // TypeScript imports name the .js the .ts compiles to.
+        const stripped = base.replace(/\.(m|c)?js$/, "");
+        for (const b of [base, stripped]) {
+            candidates.push(b);
+            for (const ext of [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json", ".py"])
+                candidates.push(b + ext);
+            for (const ext of [".ts", ".tsx", ".js", ".jsx", ".py"])
+                candidates.push(path.join(b, `index${ext}`));
+        }
+        if (spec.startsWith(".") && /^\.+[\w.]/.test(spec) && fromFile.endsWith(".py")) {
+            // Python relative: from .mod import x / from ..pkg.mod import x
+            const dots = spec.match(/^\.+/)[0].length;
+            const up = path.join(dir, ...Array(dots - 1).fill(".."), ...spec.slice(dots).split("."));
+            candidates.push(`${up}.py`, path.join(up, "__init__.py"));
+        }
+    }
+    else if (/^[\w.]+$/.test(spec)) {
+        const parts = spec.split(".");
+        for (const root of [".", "src", dir])
+            candidates.push(path.join(root, ...parts) + ".py", path.join(root, ...parts, "__init__.py"));
+    }
+    const found = candidates.find((c) => {
+        try {
+            return statSync(c).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+    return found ? path.normalize(found).replace(/\\/g, "/") : null;
+}
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Lines that declare `name`, most specific first. */
+function declares(name) {
+    const n = escape(name);
+    return new RegExp("^\\s*(?:export\\s+)?(?:default\\s+)?(?:declare\\s+)?(?:async\\s+)?(?:" +
+        `function\\*?\\s+${n}\\b|(?:abstract\\s+)?class\\s+${n}\\b|interface\\s+${n}\\b|type\\s+${n}\\b|enum\\s+${n}\\b|` +
+        `(?:const|let|var)\\s+${n}\\b|(?:const|let|var)\\s*\\{[^}]*\\b${n}\\b[^}]*\\}\\s*=|def\\s+${n}\\b|class\\s+${n}\\b|func\\s+(?:\\([^)]*\\)\\s*)?${n}\\b|fn\\s+${n}\\b|${n}\\s*=[^=])` +
+        `|^\\s*(?:public|private|protected|static|readonly|async|\\s)*${n}\\s*\\([^)]*\\)\\s*(?::[^{;]*)?\\{`);
+}
+function declarationIn(lines, name, skip = -1) {
+    const re = declares(name);
+    return lines.findIndex((l, i) => i !== skip && re.test(l));
+}
+function readLines(file) {
+    try {
+        const text = readFileSync(file, "utf-8");
+        return text.length > 2_000_000 ? null : text.split(/\r?\n/);
+    }
+    catch {
+        return null;
+    }
+}
+/** Where to go for a Ctrl+click at `line`:`col` (1-based) in `file`, whose current text is `text`. */
+export function findDefinition(file, text, line, col) {
+    const lines = text.split(/\r?\n/);
+    const here = lines[line - 1] ?? "";
+    const spec = importedModule(here);
+    // On the path of an import: open that file.
+    if (spec) {
+        for (const m of here.matchAll(STRING)) {
+            if (col - 1 >= m.index && col - 1 < m.index + m[0].length) {
+                const target = resolveModule(file, m[2]);
+                return target ? { file: target, line: 1 } : null;
+            }
+        }
+    }
+    const at = wordAt(here, col);
+    if (!at)
+        return null;
+    const { word } = at;
+    // On a name in an import line: where that file declares it (or just the file).
+    if (spec) {
+        const target = resolveModule(file, spec);
+        if (!target)
+            return null;
+        const theirs = readLines(target);
+        const index = theirs ? declarationIn(theirs, word) : -1;
+        return { file: target, line: index + 1 || 1 };
+    }
+    // Imported here: its import line, where the path is a click away.
+    const importLine = lines.findIndex((l) => importedModule(l) && new RegExp(`\\b${escape(word)}\\b`).test(l.replace(STRING, "")));
+    if (importLine >= 0 && importLine !== line - 1)
+        return { file, line: importLine + 1, col: lines[importLine].search(new RegExp(`\\b${escape(word)}\\b`)) + 1 };
+    // Declared in this file.
+    const local = declarationIn(lines, word, line - 1);
+    if (local >= 0)
+        return { file, line: local + 1 };
+    // Declared somewhere else in the project.
+    const ext = path.extname(file);
+    // A click waits on this, so it reads at most a few megabytes before giving up.
+    const files = projectFiles().filter((f) => f !== file && path.extname(f) === ext).slice(0, 3000);
+    let budget = 8_000_000;
+    for (const other of files) {
+        if (!existsSync(other) || budget <= 0)
+            continue;
+        const size = statSync(other).size;
+        if (size > 1_000_000)
+            continue;
+        budget -= size;
+        const theirs = readLines(other);
+        if (!theirs)
+            continue;
+        const index = declarationIn(theirs, word);
+        if (index >= 0)
+            return { file: other, line: index + 1 };
+    }
+    return null;
+}

package/dist/src/ui/fast-width.js

@@ -0,0 +1,62 @@
+/**
+ * A faster `string-width` for Ink. Ink measures every line of text on screen each frame (to wrap it, and
+ * again to work out how much of a changed line it can leave on screen), and string-width splits each one
+ * into graphemes and runs emoji regexes over them: a fifth of all rendering time, mostly spent on lines
+ * of plain text and box-drawing characters whose width is simply their length.
+ *
+ * This answers those with one regex test, remembers the rest, and hands anything unusual to the real
+ * string-width. Ink and its dependencies import string-width by name, so a module hook points that name
+ * here; it has to be installed before Ink loads (index.ts does it first).
+ */
+// A namespace import: Node before 22.15 has no registerHooks, and a named import of it would fail to load.
+import * as nodeModule from "module";
+/**
+ * Characters string-width counts as one column each and that never combine with what's next to them:
+ * ASCII, Latin, Greek, Cyrillic, punctuation, arrows, math, box drawing and the symbols Nou's UI uses.
+ * Emoji, combining marks and invisible characters are left out. The unit tests check every one.
+ */
+export const NARROW = /^[\u0020-\u007e\u00a0-\u00ac\u00ae-\u02ff\u0370-\u0482\u048a-\u04ff\u2010-\u2027\u202f-\u205e\u2190-\u2319\u231c-\u2328\u232b-\u23e8\u23ed-\u23ef\u23f1-\u23f2\u23f4-\u25fc\u25ff-\u2613\u2616-\u262f\u2638-\u2647\u2654-\u267e\u2680-\u2689\u2690-\u2692\u2694-\u26a0\u26a2-\u26a9\u26ac-\u26bc\u26bf-\u26c3\u26c6-\u26cd\u26cf-\u26d3\u26d5-\u26e9\u26eb-\u26f1\u26f4\u26f6-\u26f9\u26fb-\u26fc\u26fe-\u2704\u2706-\u2709\u270c-\u2727\u2729-\u274b\u274d\u274f-\u2752\u2756\u2758-\u2794\u2798-\u27af\u27b1-\u27be\u2b00-\u2b1a\u2b1d-\u2b4f\u2b51-\u2b54\u2b56-\u2bff]*$/;
+/** Plenty for every line on screen and in scrollback; cleared rather than evicted one by one. */
+const MAX_CACHED = 20_000;
+/** Wraps a string-width function with the fast path and a cache. Same answers, exported for tests. */
+export function fastStringWidth(real) {
+    const cache = new Map();
+    return (text, options) => {
+        if (options && (options.ambiguousIsNarrow === false || options.countAnsiEscapeCodes))
+            return real(text, options);
+        if (typeof text !== "string")
+            return real(text, options);
+        if (NARROW.test(text))
+            return text.length;
+        let width = cache.get(text);
+        if (width === undefined) {
+            if (cache.size > MAX_CACHED)
+                cache.clear();
+            width = real(text, options);
+            cache.set(text, width);
+        }
+        return width;
+    };
+}
+let installed = false;
+/** Points every `import "string-width"` that loads from now on at the fast version. Returns whether it could. */
+export function installFastWidth() {
+    if (installed)
+        return true;
+    // registerHooks runs in-thread and synchronously (Node 22.15+); older versions keep the original.
+    const { registerHooks } = nodeModule;
+    if (typeof registerHooks !== "function" || process.env.NOU_NO_FAST_WIDTH)
+        return false;
+    const shim = new URL(`./width-shim${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url).href;
+    registerHooks({
+        resolve(specifier, context, nextResolve) {
+            const resolved = nextResolve(specifier, context);
+            if (specifier !== "string-width" || context.parentURL?.startsWith(shim))
+                return resolved;
+            // Each copy of string-width (Ink may have its own) gets its own wrapper.
+            return { ...resolved, url: `${shim}?of=${encodeURIComponent(resolved.url)}` };
+        },
+    });
+    installed = true;
+    return true;
+}

package/dist/src/ui/mouse.js

@@ -15,6 +15,7 @@ export function parseMouse(chunk) {
         const y = Number(m[3]) - 1;
         const button = code & 0b11000011; // drop the shift/alt/ctrl bits
         const shift = (code & 4) !== 0;
+        const modified = (code & (8 | 16)) !== 0; // Alt (Option) or Ctrl
         if (button === 64 || button === 65)
             events.push({ kind: "wheel", dir: button === 64 ? -1 : 1, x, y, horizontal: shift });
         else if (button === 66 || button === 67)
@@ -22,7 +23,9 @@ export function parseMouse(chunk) {
         else if (button === 0 && code & 32)
             events.push({ kind: "drag", x, y }); // 32: moved with the left button held
         else if (button === 0)
-            events.push({ kind: m[4] === "M" ? "click" : "release", x, y });
+            events.push(m[4] === "M" ? { kind: "click", x, y, ...(modified ? { define: true } : {}) } : { kind: "release", x, y });
+        else if (button === 2 && m[4] === "M")
+            events.push({ kind: "click", x, y, define: true }); // right-click
     }
     return events;
 }

package/dist/src/ui/render-options.js

@@ -8,4 +8,8 @@ export const RENDER_OPTIONS = {
     incrementalRendering: true,
     // Up to 60 frames a second, so scrolling and typing keep up with the keyboard and mouse.
     maxFps: 60,
+    // Terminals that speak the kitty keyboard protocol (kitty, Ghostty, WezTerm, iTerm2, foot...) then tell
+    // Enter from Ctrl+Enter, Cmd+Enter and Shift+Enter, so those can add a line in the chat. Others just
+    // don't answer the query and keys work as before.
+    kittyKeyboard: { mode: "auto", flags: ["disambiguateEscapeCodes"] },
 };

package/dist/src/ui/text.js

@@ -1,7 +1,16 @@
 import path from "path";
-import { highlight, supportsLanguage } from "cli-highlight";
 import { diffLines } from "diff";
-import { highlightTree } from "../syntax/index.js";
+import { highlightTree, notifySyntaxLoaded } from "../syntax/index.js";
+import { highlightJsTheme } from "../syntax/themes.js";
+let fallback = null;
+let loading = null;
+export function loadFallbackHighlighter() {
+    loading ??= import("cli-highlight").then((m) => {
+        fallback = { highlight: m.highlight, supportsLanguage: m.supportsLanguage };
+        notifySyntaxLoaded();
+    }, () => { });
+    return loading;
+}
 const LANGUAGES = {
     ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript",
     ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript",
@@ -23,10 +32,16 @@ export function highlightLines(filePath, text) {
     if (tree)
         return tree;
     const language = LANGUAGES[path.extname(filePath).toLowerCase()];
-    if (!language || !supportsLanguage(language) || text.length > 200_000)
+    if (!language || text.length > 200_000)
+        return plain;
+    if (!fallback) {
+        void loadFallbackHighlighter();
+        return plain;
+    }
+    if (!fallback.supportsLanguage(language))
         return plain;
     try {
-        return highlight(plain.join("\n"), { language, ignoreIllegals: true }).split("\n");
+        return fallback.highlight(plain.join("\n"), { language, ignoreIllegals: true, theme: highlightJsTheme() }).split("\n");
     }
     catch {
         return plain;
@@ -135,7 +150,7 @@ export function inlineSpans(text, base = { text: "" }) {
         out.push({ ...base, text: text.slice(pos) });
     return out.filter((s) => s.text);
 }
-const sameStyle = (a, b) => !!a.bold === !!b.bold && !!a.italic === !!b.italic && !!a.code === !!b.code && !!a.dim === !!b.dim;
+const sameStyle = (a, b) => !!a.bold === !!b.bold && !!a.italic === !!b.italic && !!a.code === !!b.code && !!a.dim === !!b.dim && a.link === b.link;
 /** Word-wraps styled spans; continuation lines start with `indent` spaces. */
 function wrapSpans(spans, width, indent = 0) {
     const max = Math.max(1, width);
@@ -186,7 +201,9 @@ function wrapSpans(spans, width, indent = 0) {
 }
 const cells = (row) => row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
 /** Renders markdown for the terminal: headings, lists, quotes, code blocks, tables and inline styles, wrapped to `width`. */
-export function renderMarkdown(text, width) {
+export function renderMarkdown(text, width, isFile) {
+    // File references become links before wrapping, so a long path that wraps is still one link.
+    const spansOf = (line, base) => (isFile ? linkFileRefs(inlineSpans(line, base), isFile) : inlineSpans(line, base));
     const out = [];
     const src = splitLines(text);
     let fence = null;
@@ -215,7 +232,7 @@ export function renderMarkdown(text, width) {
             for (; j < src.length && /^\s*\|/.test(src[j]); j++)
                 rows.push(cells(src[j]));
             i = j - 1;
-            const plain = rows.map((r) => r.map((c) => inlineSpans(c).map((s) => s.text).join("")));
+            const plain = rows.map((r) => r.map((c) => spansOf(c).map((s) => s.text).join("")));
             const columns = Math.max(...plain.map((r) => r.length));
             const widths = Array.from({ length: columns }, (_, c) => Math.max(...plain.map((r) => (r[c] ?? "").length)));
             const fits = widths.reduce((a, b) => a + b, 0) + 3 * (columns - 1) <= width;
@@ -224,7 +241,7 @@ export function renderMarkdown(text, width) {
                 row.forEach((cell, c) => {
                     if (c > 0)
                         spans.push({ text: " │ ", dim: true });
-                    spans.push(...inlineSpans(cell, r === 0 ? { text: "", bold: true } : { text: "" }));
+                    spans.push(...spansOf(cell, r === 0 ? { text: "", bold: true } : { text: "" }));
                     if (fits && c < columns - 1)
                         spans.push({ text: " ".repeat(widths[c] - plain[r][c].length) });
                 });
@@ -237,7 +254,7 @@ export function renderMarkdown(text, width) {
         }
         const heading = raw.match(/^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/);
         if (heading) {
-            for (const line of wrapSpans(inlineSpans(heading[2], { text: "", bold: true }), width))
+            for (const line of wrapSpans(spansOf(heading[2], { text: "", bold: true }), width))
                 out.push({ kind: "heading", spans: line });
             continue;
         }
@@ -247,7 +264,7 @@ export function renderMarkdown(text, width) {
         }
         const quote = raw.match(/^\s*>\s?(.*)/);
         if (quote) {
-            for (const line of wrapSpans(inlineSpans(quote[1], { text: "", italic: true }), width - 2))
+            for (const line of wrapSpans(spansOf(quote[1], { text: "", italic: true }), width - 2))
                 out.push({ kind: "quote", spans: [{ text: "│ ", dim: true }, ...line] });
             continue;
         }
@@ -256,12 +273,115 @@ export function renderMarkdown(text, width) {
             const depth = Math.floor(item[1].length / 2) * 2;
             const task = item[3] ? (/x/i.test(item[3]) ? "☑ " : "☐ ") : "";
             const bullet = `${" ".repeat(depth)}${/\d/.test(item[2]) ? item[2] : "•"} ${task}`;
-            for (const line of wrapSpans([{ text: bullet }, ...inlineSpans(item[4])], width, bullet.length))
+            for (const line of wrapSpans([{ text: bullet }, ...spansOf(item[4])], width, bullet.length))
                 out.push({ kind: "text", spans: line });
             continue;
         }
-        for (const line of wrapSpans(inlineSpans(raw), width))
+        for (const line of wrapSpans(spansOf(raw), width))
             out.push({ kind: "text", spans: line });
     }
     return out;
 }
+/**
+ * path, path:line or path:line-line; a path has a dot in its last part, so plain words don't match.
+ * Windows paths (C:\\dir\\file.ts, dir\\file.ts) count too.
+ */
+const FILE_REF = /(?<![\w/\\.@~-])((?:[A-Za-z]:[\\/]|\.{0,2}[\\/])?(?:[\w@.~+-]+[\\/])*[\w@-][\w@.~+-]*\.[A-Za-z0-9]{1,8})(?::(\d+)(?:[-–](\d+))?)?(?![\w/\\])/g;
+/** Splits out the references to files that exist (per `isFile`) as link spans, keeping each span's style. */
+export function linkFileRefs(spans, isFile) {
+    const out = [];
+    for (const span of spans) {
+        let pos = 0;
+        for (const m of span.text.matchAll(FILE_REF)) {
+            const file = m[1].replace(/^\.[\\/]/, "");
+            if (!isFile(file))
+                continue;
+            if (m.index > pos)
+                out.push({ ...span, text: span.text.slice(pos, m.index) });
+            const link = { path: file };
+            if (m[2])
+                link.line = Number(m[2]);
+            if (m[3])
+                link.to = Number(m[3]);
+            out.push({ ...span, text: m[0], link });
+            pos = m.index + m[0].length;
+        }
+        if (pos < span.text.length)
+            out.push(pos ? { ...span, text: span.text.slice(pos) } : span);
+    }
+    return out;
+}
+/** The link at column `col` of a line of spans, if any. */
+export function linkAt(spans, col) {
+    let x = 0;
+    for (const span of spans) {
+        if (col >= x && col < x + span.text.length)
+            return span.link ?? null;
+        x += span.text.length;
+    }
+    return null;
+}
+// eslint-disable-next-line no-control-regex -- color codes start with ESC
+const ESCAPE = /\x1b\[[\d;]*m/y;
+/**
+ * Columns `from` to `from + width` of a highlighted line, keeping its colors: the color codes before
+ * `from` are kept (so the text still starts in the right color), the characters are dropped.
+ */
+export function sliceAnsi(line, from, width = Infinity) {
+    let out = "";
+    let column = 0;
+    for (let i = 0; i < line.length;) {
+        ESCAPE.lastIndex = i;
+        const code = ESCAPE.exec(line);
+        if (code) {
+            out += code[0];
+            i += code[0].length;
+            continue;
+        }
+        const ch = String.fromCodePoint(line.codePointAt(i));
+        if (column >= from && column < from + width)
+            out += ch;
+        column++;
+        i += ch.length;
+    }
+    return out;
+}
+/** Wraps visible columns `from`..`to` of a highlighted line in `open`/`close` codes (e.g. to mark a search match). */
+export function markAnsi(line, from, to, open = "\x1b[7m", close = "\x1b[27m") {
+    let out = "";
+    let column = 0;
+    for (let i = 0; i < line.length;) {
+        ESCAPE.lastIndex = i;
+        const code = ESCAPE.exec(line);
+        if (code) {
+            out += code[0];
+            i += code[0].length;
+            continue;
+        }
+        const ch = String.fromCodePoint(line.codePointAt(i));
+        if (column === from)
+            out += open;
+        out += ch;
+        column++;
+        if (column === to)
+            out += close;
+        i += ch.length;
+    }
+    return out;
+}
+/**
+ * A reply still streaming, with its open markdown closed for now (a code block, **bold**, `code`), so it
+ * renders the way it will once finished instead of reflowing when the closing marker arrives.
+ */
+export function closeOpenMarkdown(text) {
+    const fences = text.match(/^\s*(`{3,}|~{3,})/gm)?.length ?? 0;
+    if (fences % 2)
+        return `${text}\n\`\`\``;
+    const last = text.slice(text.lastIndexOf("\n") + 1);
+    let out = text;
+    if ((last.match(/`/g)?.length ?? 0) % 2)
+        out += "`";
+    else if ((last.match(/\*\*/g)?.length ?? 0) % 2)
+        out += "**";
+    return out;
+}

package/dist/src/ui/width-shim.js

@@ -0,0 +1,7 @@
+/** Stands in for string-width (see fast-width.ts): the real one, named in this module's URL, made faster. */
+import { fastStringWidth } from "./fast-width.js";
+const of = new URL(import.meta.url).searchParams.get("of");
+if (!of)
+    throw new Error("width-shim needs ?of=<string-width url>");
+const real = (await import(of)).default;
+export default fastStringWidth(real);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nou-cli",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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": {
@@ -47,6 +47,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.133.0",
     "@clack/prompts": "^1.1.0",
+    "@modelcontextprotocol/sdk": "1.32.1",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.1.11",
     "diff": "^9.0.0",