nou-cli 0.1.0 → 0.2.1

package/dist/src/diagnostics/index.js

@@ -0,0 +1,235 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { diffLines } from "diff";
+const ORDER = { error: 0, warning: 1, info: 2 };
+export const sortDiagnostics = (list) => [...list].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || ORDER[a.severity] - ORDER[b.severity]);
+export function formatDiagnostic(d, withFile = false) {
+    return `${withFile ? `${d.file}:` : "line "}${d.line}:${d.col} ${d.severity}: ${d.message}${d.code ? ` (${d.source} ${d.code})` : ` (${d.source})`}`;
+}
+/** Problems in `after` that weren't in `before`, matched by checker + code + message (line numbers shift). */
+export function newProblems(before, after) {
+    const key = (d) => `${d.source}|${d.code ?? ""}|${d.message}`;
+    const seen = new Map();
+    for (const d of before)
+        seen.set(key(d), (seen.get(key(d)) ?? 0) + 1);
+    return after.filter((d) => {
+        const left = seen.get(key(d)) ?? 0;
+        if (left > 0) {
+            seen.set(key(d), left - 1);
+            return false;
+        }
+        return true;
+    });
+}
+/** tsc and the TypeScript language server can report the same error; keep one. */
+function dedupe(list) {
+    const seen = new Set();
+    return list.filter((d) => {
+        const key = `${d.file}|${d.line}|${d.col}|${d.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Line numbers in `after` that an edit added or changed, plus the line where text was removed. */
+export function touchedLines(before, after) {
+    const touched = new Set();
+    let line = 1;
+    for (const part of diffLines(before.replace(/\r\n/g, "\n"), after.replace(/\r\n/g, "\n"))) {
+        const count = part.count ?? part.value.split("\n").length - 1;
+        if (part.added)
+            for (let i = 0; i < count; i++)
+                touched.add(line + i);
+        if (part.removed)
+            touched.add(line);
+        else
+            line += count;
+    }
+    return touched;
+}
+function readText(file) {
+    try {
+        return readFileSync(path.resolve(process.cwd(), file), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Runs checkers, caches their results per file, and tells the UI when anything changes. */
+export class DiagnosticsManager {
+    providers = [];
+    availability = new Map();
+    /** file -> provider id -> problems */
+    results = new Map();
+    projectTimer = null;
+    /** Project checks run one at a time; a queued run is shared by everyone who asks while it waits. */
+    projectChain = Promise.resolve();
+    projectQueued = null;
+    /** Whether a full project check has finished, i.e. we know which problems already existed. */
+    projectBaseline = false;
+    running = new Set();
+    listeners = new Set();
+    setProviders(providers) {
+        const ids = new Set(providers.map((p) => p.id));
+        // Drop results from checkers that were switched off.
+        for (const byProvider of this.results.values()) {
+            for (const id of [...byProvider.keys()])
+                if (!ids.has(id))
+                    byProvider.delete(id);
+        }
+        this.providers = providers;
+        this.emit();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit() {
+        for (const l of this.listeners)
+            l();
+    }
+    /** Names of checkers currently running, for the status bar. */
+    get busy() {
+        return [...this.running];
+    }
+    async isAvailable(p) {
+        if (!this.availability.has(p.id)) {
+            try {
+                this.availability.set(p.id, await p.available());
+            }
+            catch {
+                this.availability.set(p.id, false);
+            }
+        }
+        return this.availability.get(p.id);
+    }
+    async activeProviders() {
+        const out = [];
+        for (const p of this.providers)
+            if (await this.isAvailable(p))
+                out.push(p);
+        return out;
+    }
+    async runProvider(p, file, text) {
+        this.running.add(p.name);
+        this.emit();
+        try {
+            return await p.check(file, text);
+        }
+        catch {
+            return [];
+        }
+        finally {
+            this.running.delete(p.name);
+            this.emit();
+        }
+    }
+    store(file, providerId, list) {
+        const byProvider = this.results.get(file) ?? new Map();
+        byProvider.set(providerId, list);
+        this.results.set(file, byProvider);
+    }
+    /** Checks one file (unsaved `text` if given, otherwise what's on disk) with the per-file checkers. */
+    async checkFile(file, text) {
+        const content = text ?? readText(file);
+        if (content === null)
+            return [];
+        const providers = (await this.activeProviders()).filter((p) => !p.projectWide && p.matches(file));
+        await Promise.all(providers.map(async (p) => this.store(file, p.id, await this.runProvider(p, file, content))));
+        this.emit();
+        return this.get(file);
+    }
+    /**
+     * Runs project-wide checkers (like tsc) and replaces their results everywhere. Runs never overlap (they'd
+     * overwrite each other); asking while one is queued reuses it, since it will see the latest files anyway.
+     */
+    checkProject() {
+        if (this.projectQueued)
+            return this.projectQueued;
+        const run = this.projectChain.then(() => {
+            this.projectQueued = null;
+            return this.runProject();
+        });
+        this.projectQueued = run;
+        this.projectChain = run.catch(() => { });
+        return run;
+    }
+    async runProject() {
+        const providers = (await this.activeProviders()).filter((p) => p.projectWide);
+        await Promise.all(providers.map(async (p) => {
+            const list = await this.runProvider(p, ".", "");
+            for (const byProvider of this.results.values())
+                byProvider.delete(p.id);
+            const byFile = new Map();
+            for (const d of list)
+                byFile.set(d.file, [...(byFile.get(d.file) ?? []), d]);
+            for (const [file, items] of byFile)
+                this.store(file, p.id, items);
+        }));
+        this.projectBaseline = true;
+        this.emit();
+    }
+    /** Debounced checkProject, for after saves. */
+    scheduleProject(delay = 1500) {
+        if (this.projectTimer)
+            clearTimeout(this.projectTimer);
+        this.projectTimer = setTimeout(() => void this.checkProject(), delay);
+    }
+    /** Checks text without storing it, e.g. a proposed edit. Only checkers that accept unsaved text. */
+    async checkText(file, text) {
+        const providers = (await this.activeProviders()).filter((p) => p.checksText && !p.projectWide && p.matches(file));
+        return (await Promise.all(providers.map((p) => this.runProvider(p, file, text)))).flat();
+    }
+    get(file) {
+        return dedupe(sortDiagnostics([...(this.results.get(file)?.values() ?? [])].flat()));
+    }
+    all() {
+        return dedupe(sortDiagnostics([...this.results.values()].flatMap((m) => [...m.values()].flat())));
+    }
+    counts(file) {
+        const list = file ? this.get(file) : this.all();
+        return {
+            errors: list.filter((d) => d.severity === "error").length,
+            warnings: list.filter((d) => d.severity === "warning").length,
+        };
+    }
+    /** Per-file counts, for markers in the file tree. */
+    fileCounts() {
+        const out = new Map();
+        for (const d of this.all()) {
+            const c = out.get(d.file) ?? { errors: 0, warnings: 0 };
+            if (d.severity === "error")
+                c.errors++;
+            else if (d.severity === "warning")
+                c.warnings++;
+            out.set(d.file, c);
+        }
+        return out;
+    }
+    /**
+     * After Nou's edit: the problems it introduced in that file, compared with the file before.
+     * Checks both versions with per-file checkers, and re-runs project-wide ones.
+     */
+    async introducedBy(file, before, after) {
+        const projectIds = (await this.activeProviders()).filter((p) => p.projectWide && p.matches(file)).map((p) => p.id);
+        const hadBaseline = this.projectBaseline;
+        const projectBefore = this.getFrom(file, projectIds);
+        // One after the other: language servers hold a single copy of each document.
+        const beforeList = await this.checkText(file, before);
+        const afterList = await this.checkFile(file, after);
+        if (projectIds.length)
+            await this.checkProject();
+        let projectNew = newProblems(projectBefore, this.getFrom(file, projectIds));
+        if (!hadBaseline) {
+            // No check finished before this edit, so old and new problems look the same.
+            // Only blame the edit for problems on lines it actually touched.
+            const touched = touchedLines(before, after);
+            projectNew = projectNew.filter((d) => touched.has(d.line));
+        }
+        return [...newProblems(beforeList, afterList), ...projectNew];
+    }
+    getFrom(file, providerIds) {
+        return providerIds.flatMap((id) => this.results.get(file)?.get(id) ?? []);
+    }
+}

package/dist/src/diagnostics/process.js

@@ -0,0 +1,64 @@
+import { spawn, spawnSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+/** Runs a program without a shell (safe with any file name), optionally piping text to stdin. */
+export function run(command, args, options = {}) {
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let child;
+        try {
+            child = spawn(command, args, { cwd: process.cwd(), windowsHide: true });
+        }
+        catch (error) {
+            resolve({ code: -1, stdout: "", stderr: error.message });
+            return;
+        }
+        const timer = setTimeout(() => child.kill(), options.timeout ?? 60_000);
+        child.stdout.on("data", (d) => (stdout += d));
+        child.stderr.on("data", (d) => (stderr += d));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            resolve({ code: -1, stdout, stderr: error.message });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr });
+        });
+        if (options.input !== undefined)
+            child.stdin.end(options.input);
+        else
+            child.stdin.end();
+    });
+}
+/** Whether a program is on PATH (e.g. `ruff`). */
+export function onPath(command) {
+    try {
+        return spawnSync(command, ["--version"], { windowsHide: true, timeout: 5000 }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Finds a CLI installed in the user's project (not Nou's own copy), e.g. their ESLint,
+ * returning the JS entry point so it can be run with `node` on every OS.
+ */
+export function projectBin(pkg, bin = pkg) {
+    try {
+        const require = createRequire(path.join(process.cwd(), "package.json"));
+        const manifestPath = require.resolve(`${pkg}/package.json`);
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        const rel = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[bin];
+        if (!rel)
+            return null;
+        const full = path.join(path.dirname(manifestPath), rel);
+        // Only use it if it's really the project's install, not something hoisted from Nou itself.
+        const inside = path.relative(process.cwd(), full);
+        return existsSync(full) && !inside.startsWith("..") && !path.isAbsolute(inside) ? full : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/diagnostics/providers.js

@@ -0,0 +1,103 @@
+import { existsSync } from "fs";
+import path from "path";
+import { onPath, projectBin, run } from "./process.js";
+const rel = (file) => path.relative(process.cwd(), path.resolve(process.cwd(), file)).replace(/\\/g, "/");
+/** ESLint, using the project's own install and config, so results match `npm run lint`. */
+export const eslintProvider = {
+    id: "eslint",
+    name: "ESLint",
+    checksText: true,
+    matches: (file) => /\.(m|c)?(j|t)sx?$/.test(file),
+    available: () => projectBin("eslint") !== null,
+    async check(file, text) {
+        const bin = projectBin("eslint");
+        if (!bin)
+            return [];
+        const result = await run(process.execPath, [bin, "--stdin", "--stdin-filename", file, "--format", "json"], { input: text, timeout: 60_000 });
+        let reports;
+        try {
+            reports = JSON.parse(result.stdout);
+        }
+        catch {
+            return [];
+        }
+        return reports.flatMap((report) => (report.messages ?? [])
+            // "File ignored by config" isn't a real problem.
+            .filter((m) => !(m.ruleId === null && /ignored/i.test(m.message)))
+            .map((m) => ({
+            file: rel(file),
+            line: m.line ?? 1,
+            col: m.column ?? 1,
+            ...(m.endLine ? { endLine: m.endLine } : {}),
+            ...(m.endColumn ? { endCol: m.endColumn } : {}),
+            severity: m.severity === 2 ? "error" : "warning",
+            message: m.message,
+            source: "eslint",
+            ...(m.ruleId ? { code: m.ruleId } : {}),
+        })));
+    },
+};
+/** The TypeScript compiler over the whole project (type errors need the full picture). */
+export const typescriptProvider = {
+    id: "typescript",
+    name: "TypeScript",
+    checksText: false,
+    projectWide: true,
+    matches: (file) => /\.(m|c)?tsx?$/.test(file),
+    available: () => existsSync(path.join(process.cwd(), "tsconfig.json")) && projectBin("typescript", "tsc") !== null,
+    async check() {
+        const bin = projectBin("typescript", "tsc");
+        if (!bin)
+            return [];
+        const result = await run(process.execPath, [bin, "--noEmit", "-p", ".", "--pretty", "false"], { timeout: 180_000 });
+        const diagnostics = [];
+        for (const line of result.stdout.split(/\r?\n/)) {
+            const m = line.match(/^(.+?)\((\d+),(\d+)\): (error|warning) (TS\d+): (.*)$/);
+            if (m) {
+                diagnostics.push({
+                    file: rel(m[1]),
+                    line: Number(m[2]),
+                    col: Number(m[3]),
+                    severity: m[4] === "error" ? "error" : "warning",
+                    message: m[6],
+                    source: "tsc",
+                    code: m[5],
+                });
+            }
+            else if (line.startsWith("  ") && diagnostics.length) {
+                diagnostics[diagnostics.length - 1].message += ` ${line.trim()}`;
+            }
+        }
+        return diagnostics;
+    },
+};
+let ruffInstalled;
+/** Ruff for Python, if it's installed. */
+export const ruffProvider = {
+    id: "ruff",
+    name: "Ruff (Python)",
+    checksText: true,
+    matches: (file) => /\.pyi?$/.test(file),
+    available: () => (ruffInstalled ??= onPath("ruff")),
+    async check(file, text) {
+        const result = await run("ruff", ["check", "--output-format", "json", "--stdin-filename", file, "-"], { input: text, timeout: 30_000 });
+        let items;
+        try {
+            items = JSON.parse(result.stdout);
+        }
+        catch {
+            return [];
+        }
+        return items.map((item) => ({
+            file: rel(file),
+            line: item.location?.row ?? 1,
+            col: item.location?.column ?? 1,
+            ...(item.end_location ? { endLine: item.end_location.row, endCol: item.end_location.column } : {}),
+            // Syntax errors (no code / E9) and pyflakes (F) are real bugs; style rules are warnings.
+            severity: !item.code || /^(E9|F)/.test(item.code) ? "error" : "warning",
+            message: item.message,
+            source: "ruff",
+            ...(item.code ? { code: item.code } : {}),
+        }));
+    },
+};

package/dist/src/diagnostics/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/env.js

@@ -0,0 +1,12 @@
+import { existsSync } from "fs";
+// This module must be imported before anything else (index.ts imports it first).
+// npm only warns about an unsupported Node version, so check here, before Ink loads and fails confusingly.
+const [major, minor] = process.versions.node.split(".").map(Number);
+if (major < 22 || (major === 22 && minor < 12)) {
+    console.error(`Nou needs Node.js 22.12 or newer (you have ${process.versions.node}). Get it from https://nodejs.org`);
+    process.exit(1);
+}
+// Load the project's .env (API keys, base URLs). Providers read their settings when they load,
+// so loading .env later would be too late for them.
+if (existsSync(".env"))
+    process.loadEnvFile(".env");

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