nou-cli 0.0.0-stage → 0.1.0

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/plugins/index.js

@@ -0,0 +1,43 @@
+import { existsSync, readdirSync, statSync } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { NOU_HOME } from "../config/index.js";
+export const PLUGIN_DIRS = [
+    { scope: "project", dir: path.join(process.cwd(), ".nou", "plugins") },
+    { scope: "user", dir: path.join(NOU_HOME, "plugins") },
+];
+const EXTENSIONS = [".js", ".mjs", ".ts", ".mts"];
+/** Finds plugin files without running them. */
+export function discoverPlugins() {
+    const found = [];
+    for (const { scope, dir } of PLUGIN_DIRS) {
+        if (!existsSync(dir))
+            continue;
+        for (const name of readdirSync(dir)) {
+            const full = path.join(dir, name);
+            let file;
+            if (statSync(full).isDirectory()) {
+                file = EXTENSIONS.map((ext) => path.join(full, `index${ext}`)).find(existsSync);
+            }
+            else if (EXTENSIONS.includes(path.extname(name))) {
+                file = full;
+            }
+            const id = path.basename(name, path.extname(name));
+            if (file && !found.some((p) => p.id === id))
+                found.push({ id, file, scope });
+        }
+    }
+    return found;
+}
+export async function loadPlugin(entry) {
+    try {
+        const mod = await import(pathToFileURL(entry.file).href);
+        const plugin = mod.default ?? mod.plugin;
+        if (!plugin || typeof plugin.name !== "string")
+            throw new Error("must default-export an object with a name");
+        return { ...entry, plugin };
+    }
+    catch (error) {
+        return { ...entry, error: error.message };
+    }
+}

package/dist/src/providers/anthropic.js

@@ -0,0 +1,109 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { existsSync } from "fs";
+import os from "os";
+import path from "path";
+// Models that accept server-side refusal fallbacks in their "default" form.
+const FALLBACK_MODELS = /^claude-(fable-5-1|opus-5-5|opus-5|sonnet-5-5)$/;
+// Current-generation models take output_config.effort.
+const EFFORT_MODELS = /^claude-(fable|mythos|opus|sonnet|haiku)-5/;
+const MAX_JSON_RETRIES = 2;
+function toAnthropic(messages) {
+    const out = [];
+    for (const m of messages) {
+        if (m.role === "user") {
+            out.push({ role: "user", content: m.content });
+        }
+        else if (m.role === "assistant") {
+            // Replay Claude's own turn unchanged (keeps thinking blocks valid); rebuild turns from other providers.
+            const content = m.raw?.provider === "anthropic"
+                ? m.raw.data
+                : [
+                    ...(m.content ? [{ type: "text", text: m.content }] : []),
+                    ...m.toolCalls.map((c) => ({ type: "tool_use", id: c.id, name: c.name, input: c.args })),
+                ];
+            out.push({ role: "assistant", content });
+        }
+        else {
+            const result = { type: "tool_result", tool_use_id: m.callId, content: m.content, ...(m.isError ? { is_error: true } : {}) };
+            // All results for one turn go back in a single user message.
+            const last = out[out.length - 1];
+            if (last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result")) {
+                last.content.push(result);
+            }
+            else {
+                out.push({ role: "user", content: [result] });
+            }
+        }
+    }
+    return out;
+}
+function hasCredentials() {
+    return !!(process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_PROFILE)
+        || existsSync(path.join(os.homedir(), ".config", "anthropic"));
+}
+export function anthropicProvider() {
+    let client = null;
+    const getClient = () => (client ??= new Anthropic());
+    return {
+        id: "anthropic",
+        label: "Anthropic (Claude)",
+        local: false,
+        defaultModel: "claude-opus-5-5",
+        unavailable: () => (hasCredentials() ? null : "set ANTHROPIC_API_KEY (or run `ant auth login`)"),
+        async chat({ model, system, messages, tools, onText, signal, effort: requested }) {
+            const fallbacks = FALLBACK_MODELS.test(model);
+            const effort = EFFORT_MODELS.test(model) ? process.env.NOU_EFFORT ?? requested ?? "high" : undefined;
+            const body = {
+                model,
+                max_tokens: 64000,
+                system: [{ type: "text", text: system, cache_control: { type: "ephemeral" } }],
+                messages: toAnthropic(messages),
+                tools: tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    input_schema: t.parameters,
+                    eager_input_streaming: true,
+                })),
+                stream: true,
+                ...(effort ? { output_config: { effort: effort } } : {}),
+                ...(fallbacks ? { betas: ["server-side-fallback-2026-07-01"], fallbacks: "default" } : {}),
+            };
+            for (let attempt = 0;; attempt++) {
+                let text = "";
+                try {
+                    const stream = getClient().beta.messages.stream(body, signal ? { signal } : {});
+                    stream.on("text", (delta) => {
+                        text += delta;
+                        onText(delta);
+                    });
+                    const message = await stream.finalMessage();
+                    const toolCalls = message.content
+                        .filter((b) => b.type === "tool_use")
+                        .map((b) => ({ id: b.id, name: b.name, args: (b.input ?? {}) }));
+                    const stop = message.stop_reason === "refusal"
+                        ? "refusal"
+                        : message.stop_reason === "max_tokens" && toolCalls.length ? "max_tokens" : undefined;
+                    return {
+                        text: message.content.filter((b) => b.type === "text").map((b) => b.text).join(""),
+                        toolCalls,
+                        raw: { provider: "anthropic", data: message.content },
+                        ...(stop ? { stop } : {}),
+                    };
+                }
+                catch (error) {
+                    // With eager input streaming, unparseable tool JSON surfaces as a plain (non-API) error: re-issue a few times.
+                    if (error instanceof Anthropic.APIError || attempt >= MAX_JSON_RETRIES || signal?.aborted)
+                        throw error;
+                    if (text)
+                        onText("\n");
+                }
+            }
+        },
+        async listModels() {
+            const models = [];
+            for await (const m of getClient().models.list())
+                models.push(m.id);
+            return models;
+        },
+    };
+}

package/dist/src/providers/index.js

@@ -0,0 +1,46 @@
+import { loadSettings, saveSettings } from "../config/index.js";
+import { anthropicProvider } from "./anthropic.js";
+import { ollamaProvider } from "./ollama.js";
+import { OPENAI_COMPATIBLE, openAICompatibleProvider } from "./openai.js";
+export const providers = [
+    ollamaProvider(),
+    ...OPENAI_COMPATIBLE.filter((p) => p.local).map(openAICompatibleProvider),
+    anthropicProvider(),
+    ...OPENAI_COMPATIBLE.filter((p) => !p.local).map(openAICompatibleProvider),
+];
+/**
+ * Parses "provider:model" (e.g. "anthropic:claude-opus-5-5", "ollama:qwen3:8b").
+ * A bare provider id picks its default model; anything else is treated as an Ollama model name.
+ */
+export function resolveModel(spec) {
+    const trimmed = spec.trim();
+    const colon = trimmed.indexOf(":");
+    const head = colon >= 0 ? trimmed.slice(0, colon) : trimmed;
+    const provider = providers.find((p) => p.id === head.toLowerCase());
+    if (provider) {
+        const model = colon >= 0 ? trimmed.slice(colon + 1) : "";
+        return { provider, model: model || provider.defaultModel };
+    }
+    return { provider: providers[0], model: trimmed };
+}
+export const describe = (choice) => `${choice.provider.id}:${choice.model}`;
+/** NOU_MODEL wins, then the model saved in settings, then local Ollama. */
+export function initialModel() {
+    if (process.env.NOU_MODEL)
+        return resolveModel(process.env.NOU_MODEL);
+    return resolveModel(loadSettings().model || "ollama");
+}
+export function saveModel(choice) {
+    saveSettings({ model: describe(choice) });
+}
+/** One-shot completion without tools, used for things like generating NOU.md. */
+export async function complete(choice, prompt) {
+    const result = await choice.provider.chat({
+        model: choice.model,
+        system: "You are a helpful assistant.",
+        messages: [{ role: "user", content: prompt }],
+        tools: [],
+        onText: () => { },
+    });
+    return result.text;
+}

package/dist/src/providers/ollama.js

@@ -0,0 +1,57 @@
+import { Ollama } from "ollama";
+export function ollamaProvider() {
+    const host = process.env.OLLAMA_HOST ?? "http://127.0.0.1:11434";
+    const client = new Ollama({ host });
+    const toOllama = (system, messages) => [
+        { role: "system", content: system },
+        ...messages.map((m) => {
+            if (m.role === "user")
+                return { role: "user", content: m.content };
+            if (m.role === "tool")
+                return { role: "tool", content: m.content, tool_name: m.name };
+            return {
+                role: "assistant",
+                content: m.content,
+                tool_calls: m.toolCalls.map((c) => ({ function: { name: c.name, arguments: c.args } })),
+            };
+        }),
+    ];
+    return {
+        id: "ollama",
+        label: `Ollama (${host})`,
+        local: true,
+        defaultModel: "qwen3:8b",
+        unavailable: () => null,
+        async chat({ model, system, messages, tools, onText, signal }) {
+            const stream = await client.chat({
+                model,
+                messages: toOllama(system, messages),
+                tools: tools.map((t) => ({ type: "function", function: t })),
+                stream: true,
+            });
+            const onAbort = () => stream.abort();
+            signal?.addEventListener("abort", onAbort);
+            let text = "";
+            const toolCalls = [];
+            try {
+                for await (const part of stream) {
+                    if (part.message.content) {
+                        text += part.message.content;
+                        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 ?? {} });
+                    }
+                }
+            }
+            finally {
+                signal?.removeEventListener("abort", onAbort);
+            }
+            return { text, toolCalls };
+        },
+        async listModels() {
+            const { models } = await client.list();
+            return models.map((m) => m.name);
+        },
+    };
+}

package/dist/src/providers/openai.js

@@ -0,0 +1,106 @@
+import OpenAI from "openai";
+/** 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 },
+    { id: "gemini", label: "Google Gemini", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/", keyEnv: "GEMINI_API_KEY", defaultModel: "gemini-2.5-pro", local: false },
+    { id: "openrouter", label: "OpenRouter", baseURL: "https://openrouter.ai/api/v1", keyEnv: "OPENROUTER_API_KEY", defaultModel: "anthropic/claude-opus-5-5", local: false },
+    { id: "groq", label: "Groq", baseURL: "https://api.groq.com/openai/v1", keyEnv: "GROQ_API_KEY", defaultModel: "llama-3.3-70b-versatile", local: false },
+    { id: "deepseek", label: "DeepSeek", baseURL: "https://api.deepseek.com/v1", keyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek-chat", local: false },
+    { id: "lmstudio", label: "LM Studio", baseURL: "http://localhost:1234/v1", urlEnv: "LMSTUDIO_BASE_URL", defaultModel: "local-model", local: true },
+    { id: "llamacpp", label: "llama.cpp server", baseURL: "http://localhost:8080/v1", urlEnv: "LLAMACPP_BASE_URL", defaultModel: "local-model", local: true },
+    { id: "custom", label: "Custom OpenAI-compatible", baseURL: "", urlEnv: "NOU_BASE_URL", keyEnv: "NOU_API_KEY", defaultModel: "default", local: true },
+];
+function toOpenAI(system, messages) {
+    const out = [{ role: "system", content: system }];
+    for (const m of messages) {
+        if (m.role === "user")
+            out.push({ role: "user", content: m.content });
+        else if (m.role === "tool")
+            out.push({ role: "tool", tool_call_id: m.callId, content: m.content });
+        else {
+            out.push({
+                role: "assistant",
+                content: m.content || null,
+                ...(m.toolCalls.length
+                    ? {
+                        tool_calls: m.toolCalls.map((c) => ({
+                            id: c.id,
+                            type: "function",
+                            function: { name: c.name, arguments: JSON.stringify(c.args) },
+                        })),
+                    }
+                    : {}),
+            });
+        }
+    }
+    return out;
+}
+export function openAICompatibleProvider(preset) {
+    const baseURL = (preset.urlEnv && process.env[preset.urlEnv]) || preset.baseURL;
+    const apiKey = (preset.keyEnv && process.env[preset.keyEnv]) || (preset.local ? "not-needed" : "");
+    let client = null;
+    const getClient = () => (client ??= new OpenAI({ baseURL, apiKey }));
+    return {
+        id: preset.id,
+        label: preset.label,
+        local: preset.local,
+        defaultModel: preset.defaultModel,
+        unavailable() {
+            if (!baseURL)
+                return `set ${preset.urlEnv}`;
+            if (!apiKey)
+                return `set ${preset.keyEnv}`;
+            return null;
+        },
+        async chat({ model, system, messages, tools, onText, signal }) {
+            const stream = await getClient().chat.completions.create({
+                model,
+                messages: toOpenAI(system, messages),
+                ...(tools.length ? { tools: tools.map((t) => ({ type: "function", function: t })) } : {}),
+                stream: true,
+            }, signal ? { signal } : {});
+            let text = "";
+            let finish = null;
+            // Tool calls stream in fragments keyed by index.
+            const partial = new Map();
+            for await (const chunk of stream) {
+                const choice = chunk.choices[0];
+                if (!choice)
+                    continue;
+                if (choice.delta.content) {
+                    text += choice.delta.content;
+                    onText(choice.delta.content);
+                }
+                for (const delta of choice.delta.tool_calls ?? []) {
+                    const call = partial.get(delta.index) ?? { id: "", name: "", args: "" };
+                    if (delta.id)
+                        call.id = delta.id;
+                    if (delta.function?.name)
+                        call.name += delta.function.name;
+                    if (delta.function?.arguments)
+                        call.args += delta.function.arguments;
+                    partial.set(delta.index, call);
+                }
+                if (choice.finish_reason)
+                    finish = choice.finish_reason;
+            }
+            const toolCalls = [...partial.values()].map((c, i) => {
+                let args;
+                try {
+                    args = c.args ? JSON.parse(c.args) : {};
+                }
+                catch {
+                    args = { __invalid_json: c.args };
+                }
+                return { id: c.id || `call_${i}`, name: c.name, args };
+            });
+            return { text, toolCalls, ...(finish === "length" && toolCalls.length ? { stop: "max_tokens" } : {}) };
+        },
+        async listModels() {
+            const models = [];
+            for await (const m of getClient().models.list())
+                models.push(m.id);
+            return models.sort();
+        },
+    };
+}

package/dist/src/providers/types.js

@@ -0,0 +1,2 @@
+/** Provider-neutral conversation format. Each provider converts to and from its own API shape. */
+export {};

package/dist/src/tools/index.js

@@ -0,0 +1,100 @@
+export const tools = [
+    {
+        type: "function",
+        function: {
+            name: "run_command",
+            description: "Run a terminal command",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "The shell command to run",
+                    }
+                },
+                required: ["command"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read the contents of a file",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Path to file",
+                    }
+                },
+                required: ["path"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "list_files",
+            description: "List the files and folders of the project (or a sub folder) as a tree",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Folder to list, relative to the project root. Defaults to the root.",
+                    }
+                },
+                required: []
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "edit_file",
+            description: "Edit an existing file by replacing one exact snippet of text with new text. Prefer this over write_file for changes to existing files. Read the file first so old_string matches exactly.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Path to the file to edit"
+                    },
+                    old_string: {
+                        type: "string",
+                        description: "The exact text to replace. Must appear exactly once in the file."
+                    },
+                    new_string: {
+                        type: "string",
+                        description: "The text to put in its place"
+                    }
+                },
+                required: ["path", "old_string", "new_string"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Create a new file or fully overwrite a file (TypeScript, JavaScript, Python, etc.). Use this to generate boilerplate, add features, or create scripts.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "The relative path including extension (e.g., \"scripts/setup.py\")"
+                    },
+                    content: {
+                        type: "string",
+                        description: "The RAW source code. Do NOT wrap in markdown code blocks. Use real newlines, not escaped \\n characters."
+                    }
+                },
+                required: ["path", "content"]
+            }
+        }
+    }
+];
+export const toolDefs = tools.map((t) => t.function);