nou-cli 0.0.0-stage → 0.1.0

package/.env.example

@@ -0,0 +1,24 @@
+# Copy to .env and fill in only the providers you use. .env is gitignored.
+
+# Pick the starting model as provider:model (or switch in the app with /model).
+# NOU_MODEL=ollama:qwen3:8b
+# NOU_MODEL=anthropic:claude-opus-5-5
+
+# --- Local ---
+# OLLAMA_HOST=http://127.0.0.1:11434
+# LMSTUDIO_BASE_URL=http://localhost:1234/v1
+# LLAMACPP_BASE_URL=http://localhost:8080/v1
+# Any other OpenAI-compatible server (vLLM, Jan, LocalAI, ...):
+# NOU_BASE_URL=http://localhost:8000/v1
+# NOU_API_KEY=
+
+# --- Cloud ---
+# ANTHROPIC_API_KEY=
+# OPENAI_API_KEY=
+# GEMINI_API_KEY=
+# OPENROUTER_API_KEY=
+# GROQ_API_KEY=
+# DEEPSEEK_API_KEY=
+
+# Claude effort level: low | medium | high | xhigh | max (default high)
+# NOU_EFFORT=high

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# Nou
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An IDE-style AI coding assistant that lives in your terminal: file explorer, code view with live side-by-side diffs, a built-in editor, and a chat with an agent that reads, edits and runs things in your project. Works with local models (Ollama, LM Studio, llama.cpp) and cloud ones (Claude, OpenAI, Gemini, OpenRouter, Groq, DeepSeek).
+
+```
+npm install -g nou-cli
+cd your-project
+nou
+```
+
+Needs Node 20.12+ and an interactive terminal (Windows Terminal, PowerShell, macOS/Linux terminals). For local models, install [Ollama](https://ollama.com) and pull a model, e.g. `ollama pull qwen3:8b` (the default).
+
+## Using it
+
+| Key | Does |
+| --- | --- |
+| `Tab` | switch between files, code and chat |
+| `Ctrl+P` | fuzzy-find a file |
+| `e` | edit the open file (`Ctrl+S` save, `Ctrl+Z` undo, `Esc` close) |
+| `v` | diff the open file against git `HEAD` (or Nou's last edit) |
+| `c` | in the file tree, show only changed files |
+| `f` | follow mode: jump to files Nou is reading/editing |
+| `s` or `/settings` | settings: model, preferences, plugins |
+| `y` / `n` | accept / reject a proposed edit or command |
+| `Esc` | stop Nou, close a diff, back to chat |
+
+Nou sees what you're looking at: the open file and visible lines (or your cursor line and unsaved edits while editing) are attached to each message, so "explain this function" just works. In a git repo it also gets your branch, uncommitted changes and recent commits, plus `git_status` / `git_diff` / `git_log` tools.
+
+Chat commands: `/settings`, `/model [provider:model]`, `/models [provider]`, `/clear`, `/help`.
+
+## Models
+
+Pick one in `/settings`, with `/model anthropic`, `/model ollama:qwen3:8b`, or `NOU_MODEL=provider:model`. API keys come from your environment or a `.env` file in the project; see [.env.example](.env.example).
+
+| Provider | Setup |
+| --- | --- |
+| Ollama (default) | runs locally, `OLLAMA_HOST` to change |
+| LM Studio, llama.cpp | start their local server |
+| Any OpenAI-compatible server | `NOU_BASE_URL`, optional `NOU_API_KEY` |
+| Anthropic | `ANTHROPIC_API_KEY` |
+| OpenAI / Gemini / OpenRouter / Groq / DeepSeek | `OPENAI_API_KEY` / `GEMINI_API_KEY` / `OPENROUTER_API_KEY` / `GROQ_API_KEY` / `DEEPSEEK_API_KEY` |
+
+## Plugins (early)
+
+Drop a `.js`/`.mjs` file into `.nou/plugins/` (project) or `~/.nou/plugins/` (everywhere), then enable it in `/settings → Plugins`. A plugin can add tools for the model, slash commands, and system prompt text. See [examples/plugins/word-count.mjs](examples/plugins/word-count.mjs). Plugins run code on your machine, so they stay off until you enable them.
+
+## Development
+
+```
+npm install
+npm run dev        # run from source
+npm run build      # compile to dist/
+```
+
+Releases: create a GitHub release tagged `vX.Y.Z` and the Publish workflow builds and publishes that version to npm (needs an `NPM_TOKEN` secret in the `production` environment).

package/dist/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { existsSync } from "fs";
+import { createElement } from "react";
+import { render } from "ink";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { artWork } from "./src/util/index.js";
+import { ensureProjectContext, loadPermanentContext } from "./src/context/index.js";
+import { describe, initialModel, resolveModel } from "./src/providers/index.js";
+import { App } from "./src/ui/App.js";
+async function main() {
+    if (!process.stdin.isTTY) {
+        console.error("Nou needs an interactive terminal (try Windows Terminal / PowerShell).");
+        process.exit(1);
+    }
+    // API keys can live in a .env next to the project (it's gitignored).
+    if (existsSync(".env"))
+        process.loadEnvFile(".env");
+    p.intro(chalk.cyan(`${artWork} \n Hello I am Nou! 🌞`));
+    let choice = initialModel();
+    const problem = choice.provider.unavailable();
+    if (problem) {
+        p.log.warn(`${choice.provider.label} isn't set up (${problem}), falling back to local Ollama.`);
+        choice = resolveModel("ollama");
+    }
+    p.log.info(`Model: ${chalk.yellow(describe(choice))}  (change it any time with /model)`);
+    await ensureProjectContext(choice);
+    const permContext = await loadPermanentContext();
+    const app = render(createElement(App, { initialModel: choice, permContext }), {
+        alternateScreen: true,
+    });
+    await app.waitUntilExit();
+    p.outro(chalk.cyan("Bye bye!"));
+}
+main().catch(console.error);

package/dist/src/agent/index.js

@@ -0,0 +1,214 @@
+import { toolDefs } from "../tools/index.js";
+import { applyChange, fileTree, proposeEdit, proposeWrite, readFile, runCommand, toRelative, } from "../commands/index.js";
+import { describe } from "../providers/index.js";
+const MAX_STEPS = 25;
+export function buildSystemPrompt(permContext, extras = []) {
+    return `You are Nou, a coding assistant running in the user's terminal, working in ${process.cwd()}.
+You can read, edit and create files and run commands with the tools you have.
+- Read a file before editing it. Prefer edit_file for small changes and write_file for new files.
+- Every edit and command is shown to the user, who approves or rejects it.
+- Keep replies short and to the point.
+
+Project files:
+${fileTree(".", 3)}
+${extras.map((e) => `\n${e}`).join("")}
+${permContext}`;
+}
+/** Checks required arguments are present before a tool runs (models, especially small local ones, skip them). */
+function invalidArgs(call, tools) {
+    if ("__invalid_json" in call.args)
+        return `The arguments were not valid JSON: ${JSON.stringify(call.args.__invalid_json)}`;
+    const def = tools.find((t) => t.name === call.name);
+    if (!def)
+        return null;
+    const missing = def.parameters.required.filter((key) => call.args[key] === undefined || call.args[key] === null);
+    return missing.length ? `Missing or non-string arguments: ${missing.join(", ")}` : null;
+}
+export class Agent {
+    choice;
+    system;
+    hooks;
+    messages = [];
+    controller = null;
+    extraTools = [];
+    effort;
+    constructor(choice, system, hooks) {
+        this.choice = choice;
+        this.system = system;
+        this.hooks = hooks;
+    }
+    configure(options) {
+        if (options.system !== undefined)
+            this.system = options.system;
+        if (options.extraTools)
+            this.extraTools = options.extraTools;
+        if (options.effort)
+            this.effort = options.effort;
+    }
+    get tools() {
+        return [...toolDefs, ...this.extraTools.map((t) => t.definition)];
+    }
+    /** Switches model; the conversation carries over. */
+    setModel(choice) {
+        this.choice = choice;
+    }
+    clear() {
+        this.messages = [];
+    }
+    cancel() {
+        this.controller?.abort();
+    }
+    /** `context` (what the user is looking at) is sent to the model but not shown in the chat. */
+    async send(text, context) {
+        this.messages.push({ role: "user", content: context ? `${text}\n\n${context}` : text });
+        this.controller = new AbortController();
+        const { signal } = this.controller;
+        try {
+            for (let step = 0; step < MAX_STEPS; step++) {
+                this.hooks.onBusy(`Pondering with ${describe(this.choice)}...`);
+                let streamed = "";
+                const result = await this.choice.provider.chat({
+                    model: this.choice.model,
+                    system: this.system,
+                    messages: this.messages,
+                    tools: this.tools,
+                    signal,
+                    ...(this.effort ? { effort: this.effort } : {}),
+                    onText: (delta) => {
+                        streamed += delta;
+                        this.hooks.onStream(streamed);
+                    },
+                });
+                this.hooks.onStream("");
+                this.messages.push({
+                    role: "assistant",
+                    content: result.text,
+                    toolCalls: result.toolCalls,
+                    ...(result.raw ? { raw: result.raw } : {}),
+                });
+                const visible = result.text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+                if (visible)
+                    this.hooks.onEntry({ kind: "assistant", text: visible });
+                if (result.stop === "refusal") {
+                    this.hooks.onEntry({ kind: "error", text: "The model declined this request." });
+                    this.dropUnansweredCalls();
+                    return;
+                }
+                if (result.stop === "max_tokens") {
+                    this.hooks.onEntry({ kind: "error", text: "The response was cut off before its tool call finished. Try asking for a smaller change." });
+                    this.dropUnansweredCalls();
+                    return;
+                }
+                if (result.toolCalls.length === 0)
+                    return;
+                for (const call of result.toolCalls) {
+                    if (signal.aborted)
+                        break;
+                    this.hooks.onBusy(`Running ${call.name}...`);
+                    const problem = invalidArgs(call, this.tools);
+                    const output = problem ?? await this.runTool(call);
+                    this.messages.push({
+                        role: "tool",
+                        callId: call.id,
+                        name: call.name,
+                        content: problem ? `Error: ${problem}` : output,
+                        ...(problem ? { isError: true } : {}),
+                    });
+                }
+                if (signal.aborted)
+                    throw new Error("aborted");
+            }
+            this.hooks.onEntry({ kind: "error", text: `Stopped after ${MAX_STEPS} steps.` });
+        }
+        catch (error) {
+            this.hooks.onStream("");
+            if (signal.aborted) {
+                this.hooks.onEntry({ kind: "info", text: "Cancelled." });
+            }
+            else {
+                this.hooks.onEntry({ kind: "error", text: `${describe(this.choice)}: ${error.message}` });
+            }
+            this.dropUnansweredCalls();
+        }
+        finally {
+            this.controller = null;
+            this.hooks.onBusy(null);
+        }
+    }
+    /** Every tool call needs a result before the next request, or most APIs reject the history. */
+    dropUnansweredCalls() {
+        const answered = new Set(this.messages.flatMap((m) => (m.role === "tool" ? [m.callId] : [])));
+        for (const m of this.messages) {
+            if (m.role !== "assistant")
+                continue;
+            for (const call of m.toolCalls) {
+                if (answered.has(call.id))
+                    continue;
+                this.messages.push({ role: "tool", callId: call.id, name: call.name, content: "Not run: the turn was interrupted.", isError: true });
+                answered.add(call.id);
+            }
+        }
+    }
+    async runTool(call) {
+        const { name, args } = call;
+        try {
+            switch (name) {
+                case "read_file": {
+                    this.hooks.onRead(toRelative(args.path));
+                    this.hooks.onEntry({ kind: "tool", text: `Read ${args.path}` });
+                    return await readFile(args.path);
+                }
+                case "list_files":
+                case "get_file_tree": {
+                    this.hooks.onEntry({ kind: "tool", text: `Listed ${args.path ?? "."}` });
+                    return fileTree(args.path ?? ".", 4);
+                }
+                case "edit_file":
+                case "write_file": {
+                    const change = name === "edit_file"
+                        ? await proposeEdit(args.path, args.old_string, args.new_string)
+                        : await proposeWrite(args.path, args.content ?? "");
+                    return await this.reviewChange(change);
+                }
+                case "run_command": {
+                    const ok = await this.hooks.approve({ kind: "command", command: args.command });
+                    if (!ok) {
+                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${args.command}` });
+                        return "User denied permission to run this command.";
+                    }
+                    this.hooks.onEntry({ kind: "tool", text: `Ran: ${args.command}` });
+                    const output = await runCommand(args.command);
+                    return output.trim() || "(no output)";
+                }
+                default: {
+                    const extra = this.extraTools.find((t) => t.definition.name === name);
+                    if (!extra)
+                        return `Unknown tool: ${name}`;
+                    if (!extra.readOnly && !(await this.hooks.approve({ kind: "tool", name, args }))) {
+                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${name}` });
+                        return "User denied permission to run this tool.";
+                    }
+                    this.hooks.onEntry({ kind: "tool", text: `${extra.source}: ${name}${args.path ? ` ${args.path}` : ""}` });
+                    return String(await extra.run(args));
+                }
+            }
+        }
+        catch (error) {
+            this.hooks.onEntry({ kind: "error", text: `${name}: ${error.message}` });
+            return `Error: ${error.message}`;
+        }
+    }
+    async reviewChange(change) {
+        this.hooks.onChange(change, "pending");
+        const ok = await this.hooks.approve({ kind: "change", change });
+        if (!ok) {
+            this.hooks.onChange(change, "rejected");
+            this.hooks.onEntry({ kind: "tool", text: `Rejected edit to ${change.path}` });
+            return "User rejected this change. Ask them what they would like instead.";
+        }
+        const result = await applyChange(change);
+        this.hooks.onChange(change, "applied");
+        this.hooks.onEntry({ kind: "tool", text: result });
+        return result;
+    }
+}

package/dist/src/commands/index.js

@@ -0,0 +1,115 @@
+import path from "path";
+import fs from "fs/promises";
+import { readdirSync } from "fs";
+import { exec } from "child_process";
+export const IGNORED = new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", ".venv"]);
+function resolveInProject(filePath) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    const rel = path.relative(process.cwd(), fullPath);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`${filePath} is outside the project folder`);
+    }
+    return fullPath;
+}
+export function toRelative(filePath) {
+    return path.relative(process.cwd(), path.resolve(process.cwd(), filePath)).replace(/\\/g, "/");
+}
+export async function readFile(filepath) {
+    try {
+        const fullPath = path.resolve(process.cwd(), filepath);
+        const content = await fs.readFile(fullPath, "utf-8");
+        return content;
+    }
+    catch {
+        return "Error: File not found or could not be read.";
+    }
+}
+;
+export function runCommand(command) {
+    // Async so the UI keeps rendering while the command runs.
+    return new Promise((resolve) => {
+        exec(command, { cwd: process.cwd(), timeout: 120_000, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error) {
+                const reason = error.killed ? "timed out after 2 minutes" : `Exit Code ${error.code ?? "?"}`;
+                resolve(`Error (${reason}): ${stderr || error.message}${stdout ? `
+${stdout}` : ""}`);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+export function fileTree(dir = ".", maxDepth = 3) {
+    const lines = [];
+    const walk = (current, depth, prefix) => {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true })
+                .filter((e) => !IGNORED.has(e.name))
+                .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            lines.push(`${prefix}${entry.name}${entry.isDirectory() ? "/" : ""}`);
+            if (entry.isDirectory())
+                walk(path.join(current, entry.name), depth + 1, prefix + "  ");
+        }
+    };
+    walk(path.resolve(process.cwd(), dir), 1, "");
+    return lines.join("\n") || "(empty)";
+}
+function cleanContent(content) {
+    return content
+        .replace(/\\n/g, "\n")
+        .replace(/^```[a-z]*\n/i, "")
+        .replace(/\n```$/g, "")
+        .trim() + "\n";
+}
+async function readOrEmpty(fullPath) {
+    try {
+        return await fs.readFile(fullPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Works out what write_file would do, without touching the disk. */
+export async function proposeWrite(filePath, content) {
+    const fullPath = resolveInProject(filePath);
+    const before = await readOrEmpty(fullPath);
+    return { path: toRelative(filePath), before: before ?? "", after: cleanContent(content), isNew: before === null };
+}
+/** Works out what edit_file would do, without touching the disk. */
+export async function proposeEdit(filePath, oldString, newString) {
+    const fullPath = resolveInProject(filePath);
+    const before = await readOrEmpty(fullPath);
+    if (before === null)
+        throw new Error(`${filePath} does not exist. Use write_file to create it.`);
+    // Models often send LF while Windows files use CRLF, so match on normalized text.
+    const eol = before.includes("\r\n") ? "\r\n" : "\n";
+    const normalized = before.replace(/\r\n/g, "\n");
+    const target = oldString.replace(/\r\n/g, "\n");
+    const count = target ? normalized.split(target).length - 1 : 0;
+    if (count === 0)
+        throw new Error("old_string was not found in the file. Read the file and copy the text exactly.");
+    if (count > 1)
+        throw new Error(`old_string appears ${count} times. Include more surrounding lines so it is unique.`);
+    const after = normalized.replace(target, () => newString.replace(/\r\n/g, "\n")).replace(/\n/g, eol);
+    return { path: toRelative(filePath), before, after, isNew: false };
+}
+export async function applyChange(change) {
+    try {
+        const fullPath = resolveInProject(change.path);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, change.after, "utf-8");
+        return `Successfully ${change.isNew ? "created" : "updated"} ${change.path}`;
+    }
+    catch (error) {
+        return `Failed to write file: ${error.message}`;
+    }
+}

package/dist/src/config/index.js

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+export const NOU_HOME = path.join(os.homedir(), ".nou");
+const CONFIG_PATH = path.join(NOU_HOME, "config.json");
+export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+export const DEFAULT_SETTINGS = {
+    model: "",
+    effort: "high",
+    followMode: true,
+    autoApproveEdits: false,
+    autoApproveCommands: false,
+    gitContext: true,
+    plugins: {},
+};
+export function loadSettings() {
+    try {
+        const saved = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+        return { ...DEFAULT_SETTINGS, ...saved, plugins: { ...saved.plugins } };
+    }
+    catch {
+        return { ...DEFAULT_SETTINGS, plugins: {} };
+    }
+}
+export function saveSettings(patch) {
+    const next = { ...loadSettings(), ...patch };
+    try {
+        if (!existsSync(NOU_HOME))
+            mkdirSync(NOU_HOME, { recursive: true });
+        writeFileSync(CONFIG_PATH, JSON.stringify(next, null, 2));
+    }
+    catch {
+        // settings are best effort; the session still uses them
+    }
+    return next;
+}

package/dist/src/context/index.js

@@ -0,0 +1,53 @@
+import { highlight } from "cli-highlight";
+import fs from "fs/promises";
+import path from "path";
+import { fileTree, readFile } from "../commands/index.js";
+import { complete } from "../providers/index.js";
+import * as p from "@clack/prompts";
+export const sugarfy = (str) => {
+    return highlight(str, { language: "typescript", ignoreIllegals: true });
+};
+export async function generateContext(contextPath, choice) {
+    const s = p.spinner();
+    s.start("Analyzing project structure to create NOU.md...");
+    const dirStructure = fileTree(".", 2);
+    const packageJson = await readFile("package.json");
+    let content;
+    try {
+        content = await complete(choice, `I am starting a new project. Based on these files: \n${dirStructure}\n\nAnd this package.json: \n${packageJson}\n\nPlease generate a NOU.md file that summarizes: 
+      1. What this project is.
+      2. Commands to build, test, and run it.
+      3. Tech stack used.
+      Output ONLY the markdown content.`);
+    }
+    catch (error) {
+        s.stop(`Skipped NOU.md: ${error.message}`);
+        return;
+    }
+    await fs.writeFile(contextPath, content);
+    s.stop("NOU.md generated! Nou is now context-aware.");
+}
+;
+export async function ensureProjectContext(choice) {
+    const contextPath = path.join(process.cwd(), "NOU.md");
+    try {
+        await fs.access(contextPath);
+        const nonEmpty = (await fs.readFile(contextPath, "utf-8")).trim().length > 0;
+        if (!nonEmpty) {
+            await generateContext(contextPath, choice);
+        }
+    }
+    catch {
+        await generateContext(contextPath, choice);
+    }
+}
+export async function loadPermanentContext() {
+    const contextPath = path.join(process.cwd(), "NOU.md");
+    try {
+        const content = await fs.readFile(contextPath, "utf-8");
+        return `\n\nPROJECT SPECIFIC RULES (from NOU.md):\n${content}`;
+    }
+    catch (err) {
+        return "";
+    }
+}

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