nou-cli 0.1.0 → 0.2.0

package/dist/src/lsp/client.js

@@ -0,0 +1,169 @@
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+export const toUri = (file) => pathToFileURL(path.resolve(process.cwd(), file)).href;
+/** file:// URI -> path relative to the project, with forward slashes. */
+export function fromUri(uri) {
+    try {
+        return path.relative(process.cwd(), fileURLToPath(uri)).replace(/\\/g, "/");
+    }
+    catch {
+        return uri;
+    }
+}
+/** A minimal Language Server Protocol client over stdio (JSON-RPC with Content-Length framing). */
+export class LspClient {
+    name;
+    child;
+    buffer = Buffer.alloc(0);
+    nextId = 1;
+    pending = new Map();
+    handlers = new Map();
+    versions = new Map();
+    texts = new Map();
+    ready;
+    dead = false;
+    /** Why the server stopped, if it did (shown in settings). */
+    error = null;
+    constructor(name, command, args, languageIds) {
+        this.name = name;
+        // npm-installed servers are .cmd shims on Windows, which need a shell. The command line is ours, not user text.
+        const shell = process.platform === "win32" && !/\.exe$/i.test(command);
+        // With a shell, quote the path so folders with spaces (C:\Program Files\...) work.
+        this.child = spawn(shell ? `"${command}"` : command, args, { cwd: process.cwd(), shell, windowsHide: true, stdio: ["pipe", "pipe", "ignore"] });
+        this.child.on("exit", () => this.fail(new Error(`${name} exited`)));
+        this.child.on("error", (error) => this.fail(error));
+        this.child.stdout.on("data", (chunk) => this.onData(chunk));
+        this.languageIds = languageIds;
+        this.ready = this.request("initialize", {
+            processId: process.pid,
+            rootUri: pathToFileURL(process.cwd()).href,
+            workspaceFolders: [{ uri: pathToFileURL(process.cwd()).href, name: path.basename(process.cwd()) }],
+            capabilities: {
+                textDocument: {
+                    synchronization: { didSave: true },
+                    publishDiagnostics: { relatedInformation: false },
+                    hover: { contentFormat: ["plaintext", "markdown"] },
+                    definition: { linkSupport: false },
+                },
+                workspace: { workspaceFolders: true, configuration: true },
+            },
+        }, 30_000).then(() => this.notify("initialized", {}));
+        // A server that can't start shouldn't take Nou down; mark it dead and stop it.
+        this.ready.catch((error) => {
+            this.error = error.message;
+            this.fail(error);
+            this.child.kill();
+        });
+        // Servers ask for settings; answering with nulls means "use your defaults".
+        this.onRequest("workspace/configuration", (params) => (params?.items ?? []).map(() => null));
+        this.onRequest("client/registerCapability", () => null);
+        this.onRequest("window/workDoneProgress/create", () => null);
+    }
+    languageIds;
+    requestHandlers = new Map();
+    onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+    }
+    on(method, handler) {
+        this.handlers.set(method, handler);
+    }
+    fail(error) {
+        if (this.dead)
+            return;
+        this.dead = true;
+        this.error ??= error.message;
+        for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(error);
+        }
+        this.pending.clear();
+    }
+    send(message) {
+        if (this.dead)
+            return;
+        const body = Buffer.from(JSON.stringify({ jsonrpc: "2.0", ...message }), "utf-8");
+        this.child.stdin.write(`Content-Length: ${body.length}\r\n\r\n`);
+        this.child.stdin.write(body);
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        for (;;) {
+            const headerEnd = this.buffer.indexOf("\r\n\r\n");
+            if (headerEnd < 0)
+                return;
+            const length = Number(/Content-Length: (\d+)/i.exec(this.buffer.subarray(0, headerEnd).toString())?.[1]);
+            if (!length || this.buffer.length < headerEnd + 4 + length)
+                return;
+            const body = this.buffer.subarray(headerEnd + 4, headerEnd + 4 + length).toString("utf-8");
+            this.buffer = this.buffer.subarray(headerEnd + 4 + length);
+            try {
+                this.dispatch(JSON.parse(body));
+            }
+            catch {
+                // ignore malformed messages
+            }
+        }
+    }
+    dispatch(message) {
+        if (message.id !== undefined && message.method) {
+            // A request from the server.
+            const handler = this.requestHandlers.get(message.method);
+            this.send({ id: message.id, result: handler ? handler(message.params) : null });
+        }
+        else if (message.id !== undefined) {
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                return;
+            this.pending.delete(message.id);
+            clearTimeout(pending.timer);
+            if (message.error)
+                pending.reject(new Error(message.error.message));
+            else
+                pending.resolve(message.result);
+        }
+        else if (message.method) {
+            this.handlers.get(message.method)?.(message.params);
+        }
+    }
+    request(method, params, timeout = 15_000) {
+        if (this.dead)
+            return Promise.reject(new Error(`${this.name} is not running`));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`${this.name}: ${method} timed out`));
+            }, timeout);
+            this.pending.set(id, { resolve, reject, timer });
+            this.send({ id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.send({ method, params });
+    }
+    /** Opens or updates a document with the given (possibly unsaved) text. Returns false if it was already current. */
+    async sync(file, text) {
+        await this.ready;
+        const uri = toUri(file);
+        if (this.texts.get(uri) === text)
+            return false;
+        const version = (this.versions.get(uri) ?? 0) + 1;
+        this.versions.set(uri, version);
+        if (!this.texts.has(uri)) {
+            const languageId = this.languageIds[path.extname(file).toLowerCase()] ?? "plaintext";
+            this.notify("textDocument/didOpen", { textDocument: { uri, languageId, version, text } });
+        }
+        else {
+            this.notify("textDocument/didChange", { textDocument: { uri, version }, contentChanges: [{ text }] });
+        }
+        this.texts.set(uri, text);
+        return true;
+    }
+    stop() {
+        if (this.dead)
+            return;
+        this.request("shutdown", null, 2000).then(() => this.notify("exit", null)).catch(() => { }).finally(() => this.child.kill());
+        this.dead = true;
+    }
+}

package/dist/src/lsp/index.js

@@ -0,0 +1,169 @@
+import { existsSync } from "fs";
+import path from "path";
+import { LspClient, fromUri, toUri } from "./client.js";
+/** Servers Nou knows how to talk to. Each is used only if it's installed. Users can add more in settings. */
+export const KNOWN_SERVERS = [
+    {
+        id: "typescript", name: "TypeScript", command: "typescript-language-server", args: ["--stdio"],
+        languages: { ".ts": "typescript", ".mts": "typescript", ".cts": "typescript", ".tsx": "typescriptreact", ".js": "javascript", ".mjs": "javascript", ".cjs": "javascript", ".jsx": "javascriptreact" },
+    },
+    { id: "pyright", name: "Pyright", command: "pyright-langserver", args: ["--stdio"], languages: { ".py": "python", ".pyi": "python" } },
+    { id: "rust-analyzer", name: "rust-analyzer", command: "rust-analyzer", args: [], languages: { ".rs": "rust" } },
+    { id: "gopls", name: "gopls", command: "gopls", args: [], languages: { ".go": "go" } },
+    { id: "clangd", name: "clangd", command: "clangd", args: [], languages: { ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".hpp": "cpp" } },
+];
+/** Finds a program on PATH (or in the project's node_modules/.bin), on Windows, macOS and Linux. */
+export function findExecutable(command) {
+    const dirs = [path.join(process.cwd(), "node_modules", ".bin"), ...(process.env.PATH ?? "").split(path.delimiter)].filter(Boolean);
+    const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").map((e) => e.toLowerCase()) : [""];
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            const full = path.join(dir, command + ext);
+            if (existsSync(full))
+                return full;
+        }
+    }
+    return null;
+}
+const SEVERITY = { 1: "error", 2: "warning", 3: "info", 4: "info" };
+/** Starts language servers on demand and exposes problems, hover and go-to-definition. */
+export class LspManager {
+    servers;
+    clients = new Map();
+    failures = new Map();
+    /** Servers that failed to start, with the reason. */
+    broken = new Map();
+    /** file (normalized, project-relative) -> latest published problems. Servers format URIs differently (e.g. c%3A), so never key by raw URI. */
+    published = new Map();
+    waiters = new Map();
+    constructor(servers = KNOWN_SERVERS) {
+        this.servers = servers;
+    }
+    serverFor(file) {
+        const ext = path.extname(file).toLowerCase();
+        return this.servers.find((s) => s.languages[ext] && findExecutable(s.command));
+    }
+    /** Installed servers, for the settings screen. */
+    installed() {
+        return this.servers.filter((s) => findExecutable(s.command));
+    }
+    client(file) {
+        const server = this.serverFor(file);
+        if (!server)
+            return null;
+        const existing = this.clients.get(server.id);
+        if (existing && !existing.dead)
+            return existing;
+        if (this.broken.has(server.id) || (this.failures.get(server.id) ?? 0) >= 3)
+            return null; // stop retrying
+        if (existing?.dead)
+            this.failures.set(server.id, (this.failures.get(server.id) ?? 0) + 1);
+        const client = new LspClient(server.name, findExecutable(server.command), server.args, server.languages);
+        client.on("textDocument/publishDiagnostics", (params) => {
+            const file = fromUri(params.uri);
+            this.published.set(file.toLowerCase(), (params.diagnostics ?? []).map((d) => ({
+                file,
+                line: d.range.start.line + 1,
+                col: d.range.start.character + 1,
+                endLine: d.range.end.line + 1,
+                endCol: d.range.end.character + 1,
+                severity: SEVERITY[d.severity ?? 1] ?? "error",
+                message: String(d.message).split("\n")[0],
+                source: server.id,
+                ...(d.code !== undefined ? { code: String(d.code) } : {}),
+            })));
+            for (const wake of this.waiters.get(file.toLowerCase()) ?? [])
+                wake();
+            this.waiters.delete(file.toLowerCase());
+        });
+        // If it can't even start (e.g. incompatible TypeScript version), give up on it for this session.
+        client.ready.catch((error) => this.broken.set(server.id, error.message.split(". ")[0]));
+        this.clients.set(server.id, client);
+        return client;
+    }
+    /** Sends the text and waits for the server's problems (it publishes them asynchronously). */
+    async diagnostics(file, text, timeout = 8000) {
+        const client = this.client(file);
+        if (!client)
+            return [];
+        const key = fromUri(toUri(file)).toLowerCase();
+        let wake;
+        const published = new Promise((resolve) => {
+            wake = resolve;
+            this.waiters.set(key, [...(this.waiters.get(key) ?? []), resolve]);
+        });
+        const stopWaiting = () => {
+            const left = (this.waiters.get(key) ?? []).filter((w) => w !== wake);
+            if (left.length)
+                this.waiters.set(key, left);
+            else
+                this.waiters.delete(key);
+        };
+        let changed;
+        try {
+            changed = await client.sync(file, text);
+        }
+        catch {
+            stopWaiting();
+            return [];
+        }
+        // Same text as last time: the server won't publish again, so its last results are current.
+        if (!changed && this.published.has(key)) {
+            stopWaiting();
+            return this.published.get(key);
+        }
+        // Servers often publish twice (syntax, then semantic); wait for the first, then a short quiet period.
+        let timer;
+        await Promise.race([published, new Promise((r) => (timer = setTimeout(r, timeout)))]);
+        clearTimeout(timer);
+        stopWaiting();
+        await new Promise((r) => setTimeout(r, 400));
+        return this.published.get(key) ?? [];
+    }
+    async hover(file, text, line, col) {
+        const client = this.client(file);
+        if (!client)
+            return null;
+        if (!(await client.sync(file, text).then(() => true, () => false)))
+            return null;
+        const result = await client.request("textDocument/hover", { textDocument: { uri: toUri(file) }, position: { line: line - 1, character: col - 1 } }).catch(() => null);
+        const contents = result?.contents;
+        if (!contents)
+            return null;
+        const parts = Array.isArray(contents) ? contents : [contents];
+        const textOut = parts.map((p) => (typeof p === "string" ? p : p.value ?? "")).join("\n");
+        return textOut.replace(/```\w*\n?/g, "").trim() || null;
+    }
+    async definition(file, text, line, col) {
+        const client = this.client(file);
+        if (!client)
+            return null;
+        if (!(await client.sync(file, text).then(() => true, () => false)))
+            return null;
+        const result = await client.request("textDocument/definition", { textDocument: { uri: toUri(file) }, position: { line: line - 1, character: col - 1 } }).catch(() => null);
+        const first = Array.isArray(result) ? result[0] : result;
+        if (!first?.uri && !first?.targetUri)
+            return null;
+        const uri = first.uri ?? first.targetUri;
+        const range = first.range ?? first.targetSelectionRange ?? first.targetRange;
+        return { file: fromUri(uri), line: range.start.line + 1, col: range.start.character + 1 };
+    }
+    stopAll() {
+        for (const c of this.clients.values())
+            c.stop();
+        this.clients.clear();
+    }
+    /** Problems from language servers, through the same interface as linters. */
+    provider() {
+        return {
+            id: "lsp",
+            name: "Language servers",
+            checksText: true,
+            matches: (file) => this.serverFor(file) !== undefined,
+            available: () => this.installed().length > 0,
+            check: (file, text) => this.diagnostics(file, text),
+        };
+    }
+}
+/** One set of language servers for the whole app. */
+export const lsp = new LspManager();

package/dist/src/plugins/index.js

@@ -1,7 +1,90 @@
-import { existsSync, readdirSync, statSync } from "fs";
+import { createHash } from "crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
 import path from "path";
 import { pathToFileURL } from "url";
 import { NOU_HOME } from "../config/index.js";
+import { eslintProvider, ruffProvider, typescriptProvider } from "../diagnostics/providers.js";
+import { syntaxProvider } from "../syntax/index.js";
+import { lsp } from "../lsp/index.js";
+/** Plugins that ship with Nou. On by default; they only run when the project has the tool installed. */
+export const BUILTIN_PLUGINS = [
+    {
+        id: "syntax",
+        file: "(built-in)",
+        scope: "built-in",
+        plugin: { name: "Syntax check", description: "Instant syntax errors from the tree-sitter parser, no setup needed.", diagnostics: [syntaxProvider] },
+    },
+    {
+        id: "eslint",
+        file: "(built-in)",
+        scope: "built-in",
+        plugin: { name: "ESLint", description: "Lints JS/TS with your project's own ESLint and config.", diagnostics: [eslintProvider] },
+    },
+    {
+        id: "typescript",
+        file: "(built-in)",
+        scope: "built-in",
+        plugin: { name: "TypeScript", description: "Type errors from your project's own tsc (needs tsconfig.json).", diagnostics: [typescriptProvider] },
+    },
+    {
+        id: "ruff",
+        file: "(built-in)",
+        scope: "built-in",
+        plugin: { name: "Ruff", description: "Lints Python with ruff, if it's installed.", diagnostics: [ruffProvider] },
+    },
+    {
+        id: "lsp",
+        file: "(built-in)",
+        scope: "built-in",
+        plugin: {
+            name: "Language servers",
+            description: "Problems, hover (Ctrl+K) and go-to-definition (Ctrl+G) from installed servers: typescript-language-server, pyright, rust-analyzer, gopls, clangd.",
+            diagnostics: [lsp.provider()],
+        },
+    },
+];
+/**
+ * Built-ins are on unless switched off. Your own plugins run only if you approved this exact file and
+ * content; approval is never by name, so `.nou/plugins/x.js` in a cloned repo can't ride on an approval
+ * you gave a different `x.js`.
+ */
+export function isEnabled(entry, settings) {
+    if (entry.scope === "built-in")
+        return settings.plugins[entry.id] !== false;
+    return !!entry.root && !!entry.hash && settings.trustedPlugins[entry.root] === entry.hash;
+}
+/** "changed" means you approved this plugin, but its code has changed since. */
+export function trustState(entry, settings) {
+    if (isEnabled(entry, settings))
+        return "on";
+    return entry.root && settings.trustedPlugins[entry.root] ? "changed" : "off";
+}
+/** The settings change that switches a plugin on or off. */
+export function trustPatch(entry, on, settings) {
+    if (entry.scope === "built-in")
+        return { plugins: { ...settings.plugins, [entry.id]: on } };
+    const trusted = { ...settings.trustedPlugins };
+    if (on && entry.root && entry.hash)
+        trusted[entry.root] = entry.hash;
+    else if (entry.root)
+        delete trusted[entry.root];
+    return { trustedPlugins: trusted };
+}
+function hashPlugin(root) {
+    const hash = createHash("sha256");
+    const add = (p) => {
+        if (statSync(p).isDirectory()) {
+            for (const name of readdirSync(p).sort())
+                if (name !== "node_modules" && name !== ".git")
+                    add(path.join(p, name));
+        }
+        else {
+            hash.update(path.relative(root, p)).update(readFileSync(p));
+        }
+    };
+    add(root);
+    return hash.digest("hex");
+}
 export const PLUGIN_DIRS = [
     { scope: "project", dir: path.join(process.cwd(), ".nou", "plugins") },
     { scope: "user", dir: path.join(NOU_HOME, "plugins") },
@@ -23,8 +106,16 @@ export function discoverPlugins() {
                 file = full;
             }
             const id = path.basename(name, path.extname(name));
-            if (file && !found.some((p) => p.id === id))
-                found.push({ id, file, scope });
+            if (file && !found.some((p) => p.id === id)) {
+                let hash;
+                try {
+                    hash = hashPlugin(full);
+                }
+                catch {
+                    // unreadable: stays untrusted
+                }
+                found.push({ id, file, root: full, scope, ...(hash ? { hash } : {}) });
+            }
         }
     }
     return found;

package/dist/src/providers/ids.js

@@ -0,0 +1,3 @@
+import { randomUUID } from "crypto";
+/** A tool-call id that's unique across the whole conversation (for providers that don't supply one). */
+export const newCallId = () => `call_${randomUUID().replace(/-/g, "").slice(0, 16)}`;

package/dist/src/providers/ollama.js

@@ -1,4 +1,5 @@
 import { Ollama } from "ollama";
+import { newCallId } from "./ids.js";
 export function ollamaProvider() {
     const host = process.env.OLLAMA_HOST ?? "http://127.0.0.1:11434";
     const client = new Ollama({ host });
@@ -40,7 +41,7 @@ export function ollamaProvider() {
                         onText(part.message.content);
                     }
                     for (const call of part.message.tool_calls ?? []) {
-                        toolCalls.push({ id: `call_${toolCalls.length}`, name: call.function.name, args: call.function.arguments ?? {} });
+                        toolCalls.push({ id: newCallId(), name: call.function.name, args: call.function.arguments ?? {} });
                     }
                 }
             }

package/dist/src/providers/openai.js

@@ -1,4 +1,5 @@
 import OpenAI from "openai";
+import { newCallId } from "./ids.js";
 /** Everything that speaks the OpenAI chat completions API. */
 export const OPENAI_COMPATIBLE = [
     { id: "openai", label: "OpenAI", baseURL: "https://api.openai.com/v1", keyEnv: "OPENAI_API_KEY", defaultModel: "gpt-5", local: false },
@@ -84,7 +85,7 @@ export function openAICompatibleProvider(preset) {
                 if (choice.finish_reason)
                     finish = choice.finish_reason;
             }
-            const toolCalls = [...partial.values()].map((c, i) => {
+            const toolCalls = [...partial.values()].map((c) => {
                 let args;
                 try {
                     args = c.args ? JSON.parse(c.args) : {};
@@ -92,7 +93,7 @@ export function openAICompatibleProvider(preset) {
                 catch {
                     args = { __invalid_json: c.args };
                 }
-                return { id: c.id || `call_${i}`, name: c.name, args };
+                return { id: c.id || newCallId(), name: c.name, args };
             });
             return { text, toolCalls, ...(finish === "length" && toolCalls.length ? { stop: "max_tokens" } : {}) };
         },