nou-cli 0.0.0-stage → 0.2.0

package/dist/src/plugins/index.js

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

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

package/dist/src/providers/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,58 @@
+import { Ollama } from "ollama";
+import { newCallId } from "./ids.js";
+export function ollamaProvider() {
+    const host = process.env.OLLAMA_HOST ?? "http://127.0.0.1:11434";
+    const client = new Ollama({ host });
+    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: newCallId(), 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,107 @@
+import OpenAI from "openai";
+import { newCallId } from "./ids.js";
+/** Everything that speaks the OpenAI chat completions API. */
+export const OPENAI_COMPATIBLE = [
+    { id: "openai", label: "OpenAI", baseURL: "https://api.openai.com/v1", keyEnv: "OPENAI_API_KEY", defaultModel: "gpt-5", local: false },
+    { 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) => {
+                let args;
+                try {
+                    args = c.args ? JSON.parse(c.args) : {};
+                }
+                catch {
+                    args = { __invalid_json: c.args };
+                }
+                return { id: c.id || newCallId(), 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 {};