nou-cli 0.0.0-stage → 0.2.0

package/dist/src/git/index.js

@@ -0,0 +1,94 @@
+import { execFileSync } from "child_process";
+import path from "path";
+function git(args) {
+    return execFileSync("git", args, { cwd: process.cwd(), encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 20 * 1024 * 1024 });
+}
+function tryGit(args) {
+    try {
+        return git(args);
+    }
+    catch {
+        return null;
+    }
+}
+let rootCache;
+export function repoRoot() {
+    if (rootCache === undefined)
+        rootCache = tryGit(["rev-parse", "--show-toplevel"])?.trim() || null;
+    return rootCache;
+}
+export const isRepo = () => repoRoot() !== null;
+/** Repo-root-relative path (what git prints) -> cwd-relative path (what the UI uses). */
+function fromRoot(p) {
+    return path.relative(process.cwd(), path.join(repoRoot(), p)).replace(/\\/g, "/");
+}
+function toRoot(p) {
+    return path.relative(repoRoot(), path.resolve(process.cwd(), p)).replace(/\\/g, "/");
+}
+export function status() {
+    const result = new Map();
+    if (!isRepo())
+        return result;
+    const out = tryGit(["status", "--porcelain=v1", "-z", "-uall"]);
+    if (!out)
+        return result;
+    const parts = out.split("\0");
+    for (let i = 0; i < parts.length; i++) {
+        const entry = parts[i];
+        if (entry.length < 4)
+            continue;
+        const xy = entry.slice(0, 2);
+        const file = fromRoot(entry.slice(3));
+        if (xy[0] === "R" || xy[0] === "C")
+            i++; // the next part is the old name
+        const code = xy === "??" ? "?"
+            : xy.includes("U") ? "U"
+                : xy.includes("D") ? "D"
+                    : xy.includes("A") ? "A"
+                        : xy[0] === "R" ? "R"
+                            : "M";
+        if (!file.startsWith(".."))
+            result.set(file, code);
+    }
+    return result;
+}
+/** The file as of the last commit, or null if it isn't tracked. */
+export function headContent(file) {
+    if (!isRepo())
+        return null;
+    return tryGit(["show", `HEAD:${toRoot(file)}`]);
+}
+/** Working copy vs HEAD as a FileChange, for the side-by-side diff view. */
+export function diffAgainstHead(file, current) {
+    const before = headContent(file);
+    if (before === current.replace(/\r\n/g, "\n") || before === current)
+        return null;
+    return { path: file, before: before ?? "", after: current, isNew: before === null };
+}
+export function branch() {
+    return tryGit(["branch", "--show-current"])?.trim() || "(detached)";
+}
+export function log(count = 10) {
+    return tryGit(["log", `-${Math.min(Math.max(count, 1), 50)}`, "--pretty=format:%h %ad %an: %s", "--date=short"])?.trim() || "(no commits)";
+}
+export function diffText(file, staged = false) {
+    const args = ["diff", ...(staged ? ["--staged"] : ["HEAD"]), "--stat", "--patch"];
+    if (file)
+        args.push("--", toRoot(file));
+    const out = tryGit(args) ?? tryGit(["diff", ...(file ? ["--", toRoot(file)] : [])]) ?? "";
+    const untracked = file && status().get(file) === "?" ? `${file} is untracked (new file, not in git yet).` : "";
+    const text = (out.trim() || untracked || "No changes.");
+    return text.length > 60_000 ? `${text.slice(0, 60_000)}\n... (diff truncated)` : text;
+}
+/** A compact snapshot for the system prompt. */
+export function summary() {
+    if (!isRepo())
+        return null;
+    const changes = [...status()].map(([file, code]) => `  ${code} ${file}`);
+    return `Git: use the git_status, git_diff and git_log tools (they need no approval) rather than running git with run_command.
+Branch: ${branch()}
+Uncommitted changes (at session start):
+${changes.length ? changes.slice(0, 40).join("\n") + (changes.length > 40 ? `\n  ... ${changes.length - 40} more` : "") : "  (clean)"}
+Recent commits:
+${log(5).split("\n").map((l) => `  ${l}`).join("\n")}`;
+}

package/dist/src/git/tools.js

@@ -0,0 +1,52 @@
+import { branch, diffText, isRepo, log, status } from "./index.js";
+/** Read-only git tools for the model. */
+export function gitTools() {
+    if (!isRepo())
+        return [];
+    return [
+        {
+            source: "git",
+            readOnly: true,
+            definition: {
+                name: "git_status",
+                description: "Show the current git branch and uncommitted changes (M modified, A added, D deleted, ? untracked).",
+                parameters: { type: "object", properties: {}, required: [] },
+            },
+            run: () => {
+                const changes = [...status()].map(([file, code]) => `${code} ${file}`);
+                return `Branch: ${branch()}\n${changes.join("\n") || "Working tree clean."}`;
+            },
+        },
+        {
+            source: "git",
+            readOnly: true,
+            definition: {
+                name: "git_diff",
+                description: "Show uncommitted changes as a unified diff against HEAD, for one file or the whole repo.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Optional file to diff. Omit for all changes." },
+                        staged: { type: "boolean", description: "Only show staged changes." },
+                    },
+                    required: [],
+                },
+            },
+            run: (args) => diffText(typeof args.path === "string" ? args.path : undefined, args.staged === true),
+        },
+        {
+            source: "git",
+            readOnly: true,
+            definition: {
+                name: "git_log",
+                description: "Show recent commits (hash, date, author, message).",
+                parameters: {
+                    type: "object",
+                    properties: { count: { type: "number", description: "How many commits, default 10, max 50." } },
+                    required: [],
+                },
+            },
+            run: (args) => log(typeof args.count === "number" ? args.count : 10),
+        },
+    ];
+}

package/dist/src/history/index.js

@@ -0,0 +1,113 @@
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import path from "path";
+import { applyPatch, structuredPatch } from "diff";
+import { NOU_HOME } from "../config/index.js";
+const MAX_CHECKPOINTS = 300;
+const MAX_FILE_BYTES = 1_000_000;
+function readOrNull(file) {
+    try {
+        return readFileSync(path.resolve(process.cwd(), file), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Every change made during and across sessions, so edits can be undone safely. */
+export class Timeline {
+    onUpdate;
+    items = [];
+    nextId = 1;
+    file;
+    constructor(onUpdate = () => { }) {
+        this.onUpdate = onUpdate;
+        const key = createHash("sha1").update(process.cwd()).digest("hex").slice(0, 16);
+        this.file = path.join(NOU_HOME, "history", `${key}.json`);
+        try {
+            const saved = JSON.parse(readFileSync(this.file, "utf-8"));
+            this.items = Array.isArray(saved.items) ? saved.items : [];
+            this.nextId = (this.items.at(-1)?.id ?? 0) + 1;
+        }
+        catch {
+            // first run in this project
+        }
+    }
+    get all() {
+        return this.items;
+    }
+    record(entry) {
+        if (entry.before === entry.after)
+            return null;
+        if ((entry.before?.length ?? 0) > MAX_FILE_BYTES || (entry.after?.length ?? 0) > MAX_FILE_BYTES)
+            return null;
+        const checkpoint = { ...entry, id: this.nextId++, time: Date.now() };
+        this.items.push(checkpoint);
+        if (this.items.length > MAX_CHECKPOINTS)
+            this.items.splice(0, this.items.length - MAX_CHECKPOINTS);
+        this.save();
+        return checkpoint;
+    }
+    /** Nou's most recent change that hasn't been undone. */
+    lastNouChange() {
+        return [...this.items].reverse().find((c) => c.source === "nou" && !c.undone);
+    }
+    /** All of Nou's live changes from its most recent turn, newest first. */
+    lastTurn() {
+        const last = this.lastNouChange();
+        if (!last)
+            return [];
+        return this.items.filter((c) => c.source === "nou" && !c.undone && c.turn === last.turn).reverse();
+    }
+    /**
+     * Reverts one checkpoint. If the file changed since, only Nou's part is reversed (patch merge);
+     * if that conflicts, nothing is written.
+     */
+    undo(checkpoint) {
+        const full = path.resolve(process.cwd(), checkpoint.path);
+        const current = readOrNull(checkpoint.path);
+        let target;
+        let merged = false;
+        if (current === checkpoint.after) {
+            target = checkpoint.before;
+        }
+        else if (current !== null && checkpoint.after !== null && checkpoint.before !== null) {
+            const eol = current.includes("\r\n") ? "\r\n" : "\n";
+            const reverse = structuredPatch("f", "f", checkpoint.after.replace(/\r\n/g, "\n"), checkpoint.before.replace(/\r\n/g, "\n"));
+            const result = applyPatch(current.replace(/\r\n/g, "\n"), reverse, { fuzzFactor: 2 });
+            if (result === false) {
+                return { ok: false, path: checkpoint.path, reason: "the file changed since in ways that overlap Nou's edit" };
+            }
+            target = result.replace(/\n/g, eol);
+            merged = true;
+        }
+        else {
+            return { ok: false, path: checkpoint.path, reason: "the file was created, removed or replaced since" };
+        }
+        try {
+            if (target === null)
+                rmSync(full, { force: true });
+            else {
+                mkdirSync(path.dirname(full), { recursive: true });
+                writeFileSync(full, target, "utf-8");
+            }
+        }
+        catch (error) {
+            return { ok: false, path: checkpoint.path, reason: error.message };
+        }
+        checkpoint.undone = true;
+        this.record({ path: checkpoint.path, before: current, after: target, source: "you", turn: checkpoint.turn });
+        this.save();
+        return { ok: true, path: checkpoint.path, merged };
+    }
+    save() {
+        try {
+            if (!existsSync(path.dirname(this.file)))
+                mkdirSync(path.dirname(this.file), { recursive: true });
+            writeFileSync(this.file, JSON.stringify({ cwd: process.cwd(), items: this.items }));
+        }
+        catch {
+            // history is best effort
+        }
+        this.onUpdate();
+    }
+}

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();