nou-cli 0.2.1 → 0.3.0

package/dist/src/search/index.js

@@ -0,0 +1,183 @@
+import { execFileSync } from "child_process";
+import { readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { IGNORED, isInProject, toRelative } from "../commands/index.js";
+const MAX_FILES = 20_000;
+const MAX_FILE_BYTES = 1_000_000;
+const MAX_LINE = 200;
+/**
+ * The project's files, relative and with forward slashes: git's list when it's a repo (so .gitignore is
+ * respected), otherwise a walk that skips the usual build and dependency folders.
+ */
+export function projectFiles(under = ".") {
+    const base = toRelative(under) || ".";
+    try {
+        const out = execFileSync("git", ["ls-files", "-co", "--exclude-standard", "--", base], {
+            cwd: process.cwd(), encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024,
+        });
+        // ls-files also lists deleted-but-tracked files; keep the ones that exist.
+        return out.split("\n").filter(Boolean).slice(0, MAX_FILES).filter((file) => {
+            try {
+                return statSync(file).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        const files = [];
+        const walk = (dir) => {
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (files.length >= MAX_FILES || IGNORED.has(entry.name))
+                    continue;
+                const rel = dir === "." ? entry.name : `${dir}/${entry.name}`;
+                if (entry.isDirectory())
+                    walk(rel);
+                else if (entry.isFile())
+                    files.push(rel);
+            }
+        };
+        walk(base);
+        return files;
+    }
+}
+/**
+ * Glob to regex: `**` crosses folders, `*` and `?` stay within one, `{a,b}` is either. A pattern without a
+ * slash matches the file name anywhere ("*.ts" finds src/x.ts), like most tools.
+ */
+export function globToRegex(pattern) {
+    let source = "";
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === "*" && pattern[i + 1] === "*") {
+            // "**/" matches zero or more folders.
+            if (pattern[i + 2] === "/") {
+                source += "(?:.*/)?";
+                i += 2;
+            }
+            else {
+                source += ".*";
+                i += 1;
+            }
+        }
+        else if (ch === "*")
+            source += "[^/]*";
+        else if (ch === "?")
+            source += "[^/]";
+        else if (ch === "{") {
+            const end = pattern.indexOf("}", i);
+            if (end < 0)
+                source += "\\{";
+            else {
+                source += `(?:${pattern.slice(i + 1, end).split(",").map((part) => part.replace(/[.+^$()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*")).join("|")})`;
+                i = end;
+            }
+        }
+        else
+            source += ch.replace(/[.+^$()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(pattern.includes("/") ? `^${source}$` : `(?:^|/)${source}$`);
+}
+/** Files matching a glob, newest first (recently changed files are usually the relevant ones). */
+export function globFiles(pattern, under = ".", limit = 200) {
+    if (!isInProject(under))
+        return `${under} is outside the project folder.`;
+    const regex = globToRegex(pattern.replace(/\\/g, "/").replace(/^\.\//, ""));
+    const base = toRelative(under);
+    const matches = projectFiles(under).filter((file) => regex.test(base && base !== "." ? path.posix.relative(base, file) : file) || regex.test(file));
+    if (!matches.length)
+        return `No files match ${pattern}.`;
+    const dated = matches.map((file) => {
+        try {
+            return { file, time: statSync(file).mtimeMs };
+        }
+        catch {
+            return { file, time: 0 };
+        }
+    });
+    dated.sort((a, b) => b.time - a.time);
+    const shown = dated.slice(0, limit).map((d) => d.file);
+    return `${shown.join("\n")}${matches.length > limit ? `\n[${matches.length - limit} more; narrow the pattern]` : ""}`;
+}
+/** Searches file contents with a regex (or plain text, if the pattern isn't a valid regex). */
+export function grep(options) {
+    const { pattern, ignoreCase = false, filesOnly = false } = options;
+    const under = options.path ?? ".";
+    const limit = options.limit ?? 100;
+    const context = Math.max(0, Math.min(5, options.context ?? 0));
+    if (!pattern)
+        return "Give a pattern to search for.";
+    if (!isInProject(under))
+        return `${under} is outside the project folder.`;
+    let regex;
+    try {
+        regex = new RegExp(pattern, ignoreCase ? "i" : "");
+    }
+    catch {
+        regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), ignoreCase ? "i" : "");
+    }
+    let files;
+    try {
+        files = statSync(under).isFile() ? [toRelative(under)] : projectFiles(under);
+    }
+    catch {
+        return `${under} doesn't exist.`;
+    }
+    if (options.glob) {
+        const only = globToRegex(options.glob);
+        files = files.filter((file) => only.test(file));
+    }
+    const out = [];
+    const matchedFiles = [];
+    let total = 0;
+    let shownMatches = 0;
+    for (const file of files) {
+        let text;
+        try {
+            if (statSync(file).size > MAX_FILE_BYTES)
+                continue;
+            text = readFileSync(file, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (text.includes("\0"))
+            continue; // binary
+        const lines = text.split("\n");
+        let inFile = 0;
+        let lastShown = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (!regex.test(lines[i]))
+                continue;
+            total++;
+            inFile++;
+            if (filesOnly || shownMatches >= limit)
+                continue;
+            shownMatches++;
+            if (context && lastShown >= 0 && i - context > lastShown + 1)
+                out.push("--");
+            for (let j = Math.max(0, i - context, lastShown + 1); j <= Math.min(lines.length - 1, i + context); j++) {
+                const line = lines[j].replace(/\r$/, "");
+                const shown = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}...` : line;
+                out.push(`${file}:${j + 1}${j === i ? ":" : "-"} ${shown}`);
+                lastShown = j;
+            }
+        }
+        if (inFile)
+            matchedFiles.push(`${file} (${inFile})`);
+    }
+    if (!total)
+        return `No matches for ${pattern}${options.glob ? ` in ${options.glob} files` : ""}.`;
+    if (filesOnly) {
+        return `${matchedFiles.slice(0, limit).join("\n")}${matchedFiles.length > limit ? `\n[${matchedFiles.length - limit} more files]` : ""}`;
+    }
+    return `${out.join("\n")}${total > shownMatches ? `\n[${total} matches in ${matchedFiles.length} files; showing the first ${limit}. Narrow the pattern, path or glob, or use files_only.]` : ""}`;
+}

package/dist/src/setup/index.js

@@ -0,0 +1,240 @@
+import { spawn, spawnSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import os from "os";
+import path from "path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { describe, providers, resolveModel } from "../providers/index.js";
+import { sameModel } from "../providers/ollama.js";
+import { noteOrigin } from "../config/origins.js";
+function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Claude Code keeps API settings in the "env" block of ~/.claude/settings.json. Only API keys are reused:
+ * a Claude subscription login (claude.ai) belongs to Claude Code and isn't something other apps may use.
+ */
+function claudeCode() {
+    const dir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+    const settings = readJson(path.join(dir, "settings.json"));
+    const env = {};
+    for (const name of ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL"]) {
+        const value = settings?.env?.[name];
+        if (typeof value === "string" && value)
+            env[name] = value;
+    }
+    if (!env.ANTHROPIC_API_KEY && !env.ANTHROPIC_AUTH_TOKEN)
+        return null;
+    // Aliases like "opus" only mean something to Claude Code; full ids work anywhere.
+    const model = [settings?.env?.ANTHROPIC_MODEL, settings?.model].find((m) => typeof m === "string" && m.startsWith("claude-"));
+    return { env, ...(model ? { model } : {}) };
+}
+/** Codex stores an API-key login in ~/.codex/auth.json (ChatGPT sign-ins aren't reusable) and its model in config.toml. */
+function codex() {
+    const dir = process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+    const key = readJson(path.join(dir, "auth.json"))?.OPENAI_API_KEY;
+    if (typeof key !== "string" || !key)
+        return null;
+    let model;
+    try {
+        // Top-level keys only: everything before the first [section].
+        const top = readFileSync(path.join(dir, "config.toml"), "utf-8").split(/^\s*\[/m)[0];
+        const provider = top.match(/^\s*model_provider\s*=\s*"([^"]*)"/m)?.[1];
+        const found = top.match(/^\s*model\s*=\s*"([^"]+)"/m)?.[1];
+        // Codex-only models need the Responses API, which Nou doesn't speak.
+        if (found && (!provider || provider === "openai") && !found.includes("codex"))
+            model = found;
+    }
+    catch {
+        // no config.toml
+    }
+    return { env: { OPENAI_API_KEY: key }, ...(model ? { model } : {}) };
+}
+/**
+ * Fills in API keys from Claude Code's and Codex's config for providers you haven't set up yourself.
+ * Your environment and .env always win; nothing is written anywhere.
+ */
+export function borrowToolConfig() {
+    const found = [];
+    const sources = [
+        { tool: "Claude Code", provider: "anthropic", read: claudeCode, has: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"] },
+        { tool: "Codex", provider: "openai", read: codex, has: ["OPENAI_API_KEY"] },
+    ];
+    for (const source of sources) {
+        if (source.has.some((name) => process.env[name]))
+            continue;
+        const config = source.read();
+        if (!config)
+            continue;
+        for (const [name, value] of Object.entries(config.env))
+            process.env[name] ??= value;
+        noteOrigin(Object.keys(config.env), `${source.tool}'s settings`);
+        found.push({ tool: source.tool, provider: source.provider, ...(config.model ? { model: config.model } : {}) });
+    }
+    return found;
+}
+/** A local server's models, or null if it isn't reachable within `ms`. */
+async function localModels(provider, ms = 1500) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), ms);
+    });
+    try {
+        return await Promise.race([provider.listModels(), timeout]);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+const ollama = () => providers.find((x) => x.id === "ollama");
+/**
+ * First run (no model chosen yet): offer what's already on this machine (Ollama models, a running
+ * LM Studio, API keys including ones from Claude Code or Codex) instead of always starting on Ollama.
+ * Returns null to keep the default.
+ */
+export async function pickStartingModel(borrowed) {
+    const options = [];
+    const add = (choice, hint) => {
+        if (!options.some((o) => describe(o.choice) === describe(choice)))
+            options.push({ choice, hint });
+    };
+    for (const b of borrowed)
+        add(resolveModel(b.model ? `${b.provider}:${b.model}` : b.provider), `API key from ${b.tool}`);
+    const s = p.spinner();
+    s.start("Looking for models you already have...");
+    const local = await Promise.all(providers.filter((x) => x.local && !x.unavailable()).map(async (x) => ({ provider: x, models: await localModels(x) })));
+    s.stop("Checked for models");
+    for (const { provider, models } of local) {
+        for (const model of (models ?? []).slice(0, provider.id === "ollama" ? 5 : 1))
+            add({ provider, model }, `${provider.label}, installed`);
+    }
+    for (const provider of providers.filter((x) => !x.local && !x.unavailable()))
+        add({ provider, model: provider.defaultModel }, "API key found");
+    if (!options.length)
+        return null;
+    if (options.length === 1) {
+        p.log.info(`Found ${chalk.yellow(describe(options[0].choice))} (${options[0].hint}).`);
+        return options[0].choice;
+    }
+    const download = `download ${ollama().defaultModel} with Ollama (free, runs locally)`;
+    const picked = await p.select({
+        message: "Which model should Nou use? (change it any time with /model)",
+        options: [
+            ...options.map((o, i) => ({ value: String(i), label: describe(o.choice), hint: o.hint })),
+            ...(local.find((l) => l.provider.id === "ollama")?.models?.some((m) => sameModel(m, ollama().defaultModel)) ? [] : [{ value: "download", label: download }]),
+        ],
+    });
+    if (p.isCancel(picked) || picked === "download")
+        return null;
+    return options[Number(picked)].choice;
+}
+const isLocalHost = () => /^(https?:\/\/)?(127\.0\.0\.1|localhost|0\.0\.0\.0)(:|\/|$)/.test(process.env.OLLAMA_HOST ?? "127.0.0.1");
+/** The ollama executable: on PATH, or where the Windows installer puts it (PATH may not be updated yet). */
+function ollamaBinary() {
+    if (spawnSync("ollama", ["--version"], { stdio: "ignore", windowsHide: true }).status === 0)
+        return "ollama";
+    const windows = path.join(process.env.LOCALAPPDATA ?? "", "Programs", "Ollama", "ollama.exe");
+    return process.platform === "win32" && existsSync(windows) ? windows : null;
+}
+const has = (command) => spawnSync(command, ["--version"], { stdio: "ignore", windowsHide: true }).status === 0;
+function installCommand() {
+    if (process.platform === "win32") {
+        return has("winget")
+            ? { command: "winget", args: ["install", "--id", "Ollama.Ollama", "-e", "--accept-source-agreements", "--accept-package-agreements"], shown: "winget install Ollama.Ollama" }
+            : null;
+    }
+    if (process.platform === "darwin")
+        return has("brew") ? { command: "brew", args: ["install", "ollama"], shown: "brew install ollama" } : null;
+    // Ollama's official Linux installer.
+    return has("curl") ? { command: "sh", args: ["-c", "curl -fsSL https://ollama.com/install.sh | sh"], shown: "curl -fsSL https://ollama.com/install.sh | sh" } : null;
+}
+/** Gets a local Ollama running, installing it first if you agree. Returns its models, or null if it isn't available. */
+async function startOllama() {
+    if (!isLocalHost()) {
+        p.log.warn(`Can't reach Ollama at ${process.env.OLLAMA_HOST}.`);
+        return null;
+    }
+    let binary = ollamaBinary();
+    if (!binary) {
+        const install = installCommand();
+        if (!install) {
+            p.log.warn("Ollama isn't installed. Get it from https://ollama.com/download, or pick a cloud model with /model.");
+            return null;
+        }
+        const ok = await p.confirm({ message: `Ollama (runs models locally, free) isn't installed. Install it now? ${chalk.dim(`(${install.shown})`)}` });
+        if (ok !== true)
+            return null;
+        const result = spawnSync(install.command, install.args, { stdio: "inherit" });
+        binary = ollamaBinary();
+        if (result.status !== 0 || !binary) {
+            p.log.warn("Installing Ollama didn't work. Get it from https://ollama.com/download.");
+            return null;
+        }
+    }
+    // The desktop installers usually start Ollama themselves; otherwise start the server in the background.
+    let models = await localModels(ollama());
+    if (models)
+        return models;
+    const s = p.spinner();
+    s.start("Starting Ollama...");
+    spawn(binary, ["serve"], { detached: true, stdio: "ignore", windowsHide: true }).on("error", () => { }).unref();
+    for (let i = 0; i < 20 && !models; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        models = await localModels(ollama());
+    }
+    s.stop(models ? "Ollama is running" : "Ollama didn't start");
+    return models;
+}
+/** Downloads an Ollama model with a progress line. */
+async function pullWithProgress(model) {
+    const s = p.spinner();
+    s.start(`Downloading ${model}...`);
+    let last = "";
+    try {
+        await ollama().pull(model, (status, percent) => {
+            const line = `Downloading ${model}: ${percent === null ? status : `${percent}%`}`;
+            if (line !== last)
+                s.message((last = line));
+        });
+        s.stop(`Downloaded ${model}`);
+        return true;
+    }
+    catch (error) {
+        s.stop(`Couldn't download ${model}: ${error.message}`);
+        return false;
+    }
+}
+/**
+ * When the model is an Ollama one: make sure Ollama runs and the model is downloaded, offering to install,
+ * start and download what's missing (or to use a model you already have).
+ */
+export async function ensureLocalModel(choice) {
+    if (choice.provider.id !== "ollama")
+        return choice;
+    const installed = (await localModels(choice.provider)) ?? (await startOllama());
+    if (!installed)
+        return choice;
+    if (installed.some((m) => sameModel(m, choice.model)))
+        return choice;
+    const picked = await p.select({
+        message: `${choice.model} isn't downloaded yet.`,
+        options: [
+            { value: "", label: `Download ${choice.model}`, hint: "a few GB, one time" },
+            ...installed.slice(0, 8).map((m) => ({ value: m, label: `Use ${m}`, hint: "already installed" })),
+        ],
+    });
+    if (p.isCancel(picked))
+        return choice;
+    if (picked)
+        return { provider: choice.provider, model: picked };
+    await pullWithProgress(choice.model);
+    return choice;
+}

package/dist/src/tools/index.js

@@ -20,19 +20,85 @@ export const tools = [
         type: "function",
         function: {
             name: "read_file",
-            description: "Read the contents of a file",
+            description: "Read a file. Long files come back in pages of up to 1000 lines; the end of each page says how to read on.",
             parameters: {
                 type: "object",
                 properties: {
                     path: {
                         type: "string",
                         description: "Path to file",
+                    },
+                    offset: {
+                        type: "number",
+                        description: "First line to read (1-based). Defaults to 1.",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "How many lines to read. Defaults to 1000.",
                     }
                 },
                 required: ["path"]
             }
         }
     },
+    {
+        type: "function",
+        function: {
+            name: "grep",
+            description: "Search the contents of the project's files with a regular expression (or plain text). Returns file:line: matching line. Use it to find where something is defined or used before reading files.",
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "Regular expression (JavaScript syntax) or plain text to look for",
+                    },
+                    path: {
+                        type: "string",
+                        description: "File or folder to search in. Defaults to the whole project.",
+                    },
+                    glob: {
+                        type: "string",
+                        description: "Only search files matching this glob, e.g. \"*.ts\" or \"src/**/*.py\"",
+                    },
+                    ignore_case: {
+                        type: "boolean",
+                        description: "Match regardless of case",
+                    },
+                    context: {
+                        type: "number",
+                        description: "Lines to show before and after each match (0-5)",
+                    },
+                    files_only: {
+                        type: "boolean",
+                        description: "List only the files that match, with match counts",
+                    }
+                },
+                required: ["pattern"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "glob",
+            description: "Find files by name pattern, e.g. \"**/*.test.ts\" or \"*config*\". Newest first. Patterns without a slash match file names anywhere.",
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "Glob pattern: * and ? within a folder, ** across folders, {a,b} for either",
+                    },
+                    path: {
+                        type: "string",
+                        description: "Folder to search in. Defaults to the whole project.",
+                    }
+                },
+                required: ["pattern"]
+            }
+        }
+    },
     {
         type: "function",
         function: {
@@ -64,11 +130,15 @@ export const tools = [
                     },
                     old_string: {
                         type: "string",
-                        description: "The exact text to replace. Must appear exactly once in the file."
+                        description: "The exact text to replace. Must appear exactly once in the file, unless replace_all is true."
                     },
                     new_string: {
                         type: "string",
                         description: "The text to put in its place"
+                    },
+                    replace_all: {
+                        type: "boolean",
+                        description: "Replace every occurrence of old_string (e.g. to rename something throughout the file). Defaults to false."
                     }
                 },
                 required: ["path", "old_string", "new_string"]