@xingjisoft/neutrino 0.1.3 → 0.1.5

package/dist/compact.js

@@ -0,0 +1,87 @@
+/**
+ * Helpers for compressing a long conversation so it fits back inside the
+ * model's context window.
+ *
+ * Everything here is pure: deciding *what* to summarise, and flattening that
+ * part into a plain transcript. The actual "ask the model to summarise" step
+ * lives in `LLMClient.summarize`, so this module stays trivially unit-testable.
+ */
+/** Ignore stale/corrupt metadata rather than hiding any original messages. */
+export function normalizeContext(value, messageCount) {
+    if (!value || typeof value !== "object")
+        return null;
+    const context = value;
+    if (typeof context.end !== "number" || !Number.isInteger(context.end) ||
+        context.end <= 0 || context.end > messageCount ||
+        typeof context.summary !== "string" || !context.summary.trim())
+        return null;
+    return { end: context.end, summary: context.summary };
+}
+/** Derive a bounded model history while leaving the complete transcript intact. */
+export function modelHistory(messages, context) {
+    const original = messages.filter((message) => message.role !== "system");
+    const valid = normalizeContext(context, original.length);
+    return valid
+        ? [{ role: "summary", content: valid.summary }, ...original.slice(valid.end)]
+        : original;
+}
+/** How many trailing messages are always kept verbatim when compressing. */
+export const COMPACT_KEEP = 4;
+/** Per-message character budget fed to the summariser, to bound its own input. */
+export const COMPACT_MAX_CHARS_PER_MESSAGE = 4000;
+/**
+ * Split `messages` into an older prefix to summarise and a recent suffix to
+ * keep. The kept suffix never begins with a bare tool result — that would be an
+ * orphan without the assistant tool-call that produced it — so such messages
+ * are folded into the prefix instead.
+ *
+ * Returns null when there is nothing worth compressing (the conversation is
+ * already short enough).
+ */
+export function planCompaction(messages, keep = COMPACT_KEEP) {
+    if (keep < 1)
+        keep = 1;
+    const head = [];
+    const tail = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (tail.length < keep)
+            tail.unshift(messages[i]);
+        else
+            head.push(messages[i]);
+    }
+    head.reverse();
+    // Never open the kept suffix with an orphan tool result.
+    while (tail.length > 1 && tail[0].role === "tool") {
+        head.push(tail.shift());
+    }
+    if (head.length === 0 || tail.length === 0)
+        return null;
+    return { head, tail };
+}
+/**
+ * Flatten messages into a plain transcript for the summariser, clipping each
+ * message so a single huge tool result cannot dominate the summary request.
+ */
+export function transcriptFor(messages, maxCharsPerMessage = COMPACT_MAX_CHARS_PER_MESSAGE) {
+    const clip = (s) => {
+        const t = s.replace(/\r\n?/g, "\n").trim();
+        return t.length > maxCharsPerMessage ? t.slice(0, maxCharsPerMessage) + "\n…[truncated]" : t;
+    };
+    const parts = [];
+    for (const m of messages) {
+        const body = clip(m.content ?? "");
+        if (m.role === "tool") {
+            parts.push(`TOOL ${m.name ?? ""} RESULT:\n${body}`);
+        }
+        else if (m.role === "assistant") {
+            parts.push(`ASSISTANT:\n${body}`);
+        }
+        else if (m.role === "user") {
+            parts.push(`USER:\n${body}`);
+        }
+        else {
+            parts.push(`${m.role.toUpperCase()}:\n${body}`);
+        }
+    }
+    return parts.join("\n\n");
+}

package/dist/config.js

@@ -2,12 +2,32 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { sameCwd } from "./cwd.js";
+import { normalizeContext } from "./compact.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = path.resolve(__dirname, "..");
 export const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
 export const MODEL_FILE = path.join(NEUTRINO_DIR, "model.json");
 export const SESSION_DIR = path.join(NEUTRINO_DIR, "session");
 export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
+export const DEFAULT_CONTEXT_WINDOW = 1_000_000;
+export const CONTEXT_COMPRESSION_RATIO = 0.8;
+export const CONTEXT_WINDOW_OPTIONS = [32_000, 64_000, 128_000, 200_000, 256_000, 512_000, 1_000_000, 2_000_000, 4_000_000];
+export function isContextWindow(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+export function contextWindow(value) {
+    return isContextWindow(value) ? value : DEFAULT_CONTEXT_WINDOW;
+}
+/** Reload the exact provider/model so settings also apply to active chats. */
+export function modelContextWindow(provider, model) {
+    const saved = loadModels().providers.find((p) => p.name === provider)?.models.find((m) => m.name === model.name);
+    return contextWindow((saved ?? model).context_window);
+}
+export function contextCompressionThreshold(provider, model) {
+    return Math.max(1, Math.floor(modelContextWindow(provider, model) * CONTEXT_COMPRESSION_RATIO));
+}
 export const DEFAULT_MODELS = {
     providers: [
         {
@@ -36,6 +56,16 @@ export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
     default_intensity: "High",
+    // Default for new conversations; each conversation can override it.
+    approval_mode: "request",
+    // Delete-class commands need a human unless this and Auto Approval are on.
+    auto_approve_extreme_risk: false,
+    // Audible cue when a turn ends or an approval request is waiting.
+    sound_alerts: true,
+    // Model that reviews approval requests. Empty = same model as the chat.
+    approval_model: "",
+    // Initialized as a salted hash of the default Web password on first use.
+    web_password_hash: "",
 };
 export const INTENSITY_LEVELS = ["Low", "Medium", "High", "Max", "Ultra"];
 export const INTENSITY_PARAMS = {
@@ -45,20 +75,28 @@ export const INTENSITY_PARAMS = {
     Max: { temperature: 1.0, top_p: 1.0 },
     Ultra: { temperature: 1.5, top_p: 1.0 },
 };
+export function normalizeApprovalMode(value) {
+    // Config files are hand-edited: "Auto" or " autO " must not silently
+    // downgrade the conversation to a prompt on every tool call.
+    return typeof value === "string" && value.trim().toLowerCase() === "auto"
+        ? "auto"
+        : "request";
+}
 export function ensureDirs() {
     fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
     fs.mkdirSync(SESSION_DIR, { recursive: true });
 }
 export function loadModels() {
-    ensureDirs();
-    if (!fs.existsSync(MODEL_FILE)) {
-        saveModels(DEFAULT_MODELS);
-        return DEFAULT_MODELS;
-    }
     try {
+        ensureDirs();
+        if (!fs.existsSync(MODEL_FILE)) {
+            saveModels(DEFAULT_MODELS);
+            return DEFAULT_MODELS;
+        }
         return JSON.parse(fs.readFileSync(MODEL_FILE, "utf-8"));
     }
     catch {
+        // Same reasoning as loadConfig: this sits on the approval path.
         return DEFAULT_MODELS;
     }
 }
@@ -67,15 +105,17 @@ export function saveModels(data) {
     fs.writeFileSync(MODEL_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
 export function loadConfig() {
-    ensureDirs();
-    if (!fs.existsSync(CONFIG_FILE)) {
-        saveConfig(DEFAULT_CONFIG);
-        return { ...DEFAULT_CONFIG };
-    }
     try {
+        ensureDirs();
+        if (!fs.existsSync(CONFIG_FILE)) {
+            saveConfig(DEFAULT_CONFIG);
+            return { ...DEFAULT_CONFIG };
+        }
         return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
     }
     catch {
+        // The approval gate reads this on every tool call; a directory we cannot
+        // create or a file we cannot parse must fall back, not throw.
         return { ...DEFAULT_CONFIG };
     }
 }
@@ -83,6 +123,18 @@ export function saveConfig(data) {
     ensureDirs();
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), "utf-8");
 }
+/** Look a model up by name across every configured provider. */
+export function findModel(name) {
+    const wanted = name.trim();
+    if (!wanted)
+        return null;
+    for (const [provider, models] of Object.entries(getModelsByProvider())) {
+        const model = models.find((m) => m.name === wanted);
+        if (model)
+            return { provider, model };
+    }
+    return null;
+}
 export function getModelsByProvider() {
     const data = loadModels();
     const result = {};
@@ -91,10 +143,30 @@ export function getModelsByProvider() {
     }
     return result;
 }
-export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens) {
+/** Resolve a provider/model pair exactly, including when names repeat across providers. */
+export function resolveModelSelection(value, requireKey = true) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid model selection");
+    const input = value;
+    if (typeof input.provider !== "string" || typeof input.model !== "string" ||
+        typeof input.intensity !== "string")
+        throw new Error("provider, model and intensity are required");
+    if (!INTENSITY_LEVELS.includes(input.intensity))
+        throw new Error("invalid thinking intensity");
+    const provider = loadModels().providers.find((p) => p.name === input.provider);
+    if (!provider)
+        throw new Error("unknown provider");
+    const model = provider.models.find((m) => m.name === input.model);
+    if (!model)
+        throw new Error("unknown model for this provider");
+    if (requireKey && !model.api_key?.trim())
+        throw new Error("this model has no API key configured");
+    return { provider: provider.name, model: { ...model }, intensity: input.intensity };
+}
+export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode) {
     ensureDirs();
     const now = new Date();
-    const id = sessionId ?? now.toISOString().replace(/[:.]/g, "-");
+    const id = sessionId ?? `${now.toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
     const existing = sessionId ? loadSession(sessionId) : null;
     const created_at = existing ? existing.created_at : now.toISOString();
     let title = "";
@@ -115,9 +187,37 @@ export function saveSession(messages, modelName, provider, intensity, cwd, sessi
         title,
         messages,
         tokens,
+        approval_mode: normalizeApprovalMode(approvalMode ?? existing?.approval_mode),
     };
+    const validContext = normalizeContext(context, messages.filter((m) => m.role !== "system").length);
+    if (validContext)
+        session.context = validContext;
     const filePath = path.join(SESSION_DIR, `${id}.json`);
-    fs.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+    // Keep the last complete transcript intact if writing or replacing fails.
+    // The temporary file shares the destination directory so rename is atomic.
+    const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    const contents = JSON.stringify(session, null, 2);
+    let fd;
+    try {
+        fd = fs.openSync(tempPath, "wx", 0o600);
+        fs.writeFileSync(fd, contents, "utf-8");
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = undefined;
+        fs.renameSync(tempPath, filePath);
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* Preserve the write error. */ }
+        }
+        try {
+            fs.rmSync(tempPath, { force: true });
+        }
+        catch { /* Best-effort cleanup. */ }
+    }
     return id;
 }
 export function loadSession(sessionId) {
@@ -171,6 +271,14 @@ export function listSessions() {
     sessions.sort((a, b) => (b.updated_at || b.created_at).localeCompare(a.updated_at || a.created_at));
     return sessions;
 }
+/**
+ * Sessions that were started in `cwd` (the directory neutrino runs in).
+ * The history menu is scoped to the current project so sessions started in
+ * other directories do not clutter it.
+ */
+export function listSessionsForCwd(cwd = process.cwd()) {
+    return listSessions().filter((s) => sameCwd(s.cwd, cwd));
+}
 function readAsset(...candidates) {
     for (const candidate of candidates) {
         try {

package/dist/cwd.js

@@ -0,0 +1,54 @@
+/**
+ * Helpers for deciding whether a stored session belongs to the directory the
+ * agent is currently running in.
+ *
+ * Every agent records the working directory in its own flavour — `C:\a\b`,
+ * `C:/a/b`, a trailing slash, a differently cased drive letter, or a WSL style
+ * `/mnt/c/a/b` — so the comparison has to be forgiving about the spelling and
+ * strict about the actual location.
+ */
+/** Reduce a directory path to a canonical form that can be compared for equality. */
+export function normalizeCwd(dir) {
+    let p = (dir ?? "").trim();
+    if (!p)
+        return "";
+    // The Windows long-path prefix ("\\?\C:\a") carries no meaning for us.
+    p = p.replace(/^\\\\\?\\/, "");
+    p = p.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+    let drive = "";
+    let rest = p;
+    const wslDrive = /^\/(?:mnt|cygdrive)\/([a-zA-Z])(\/.*)?$/.exec(p);
+    const winDrive = /^([a-zA-Z]):(\/.*)?$/.exec(p);
+    if (wslDrive) {
+        drive = wslDrive[1];
+        rest = wslDrive[2] ?? "/";
+    }
+    else if (winDrive) {
+        drive = winDrive[1];
+        rest = winDrive[2] ?? "/";
+    }
+    if (drive) {
+        if (rest.length > 1)
+            rest = rest.replace(/\/+$/, "");
+        // Drive paths are Windows paths, which are case-insensitive.
+        return `${drive.toLowerCase()}:${(rest || "/").toLowerCase()}`;
+    }
+    // POSIX paths are case-sensitive: only drop trailing separators.
+    return p.length > 1 ? p.replace(/\/+$/, "") : p;
+}
+/** True when both paths point at the same directory. Empty paths never match. */
+export function sameCwd(a, b) {
+    const na = normalizeCwd(a);
+    const nb = normalizeCwd(b);
+    return na !== "" && na === nb;
+}
+/**
+ * Claude Code names each project directory after the working directory with
+ * every non-alphanumeric character replaced by a dash. That lets us attribute
+ * transcripts that do not carry an explicit `cwd` field.
+ */
+export function claudeProjectKey(dir) {
+    return normalizeCwd(dir)
+        .replace(/[^a-zA-Z0-9]/g, "-")
+        .toLowerCase();
+}

package/dist/header.js

@@ -2,6 +2,14 @@ import { C } from "./colors.js";
 import { truncateByWidth } from "./width.js";
 export function drawHeader(buf, state) {
     const w = buf.width;
+    if (state.approval) {
+        // A tool call is waiting for an answer: the whole bar turns orange so it
+        // cannot be missed while the agent sits paused mid-turn.
+        const bg = C.orange;
+        buf.fillRect(0, 0, w, 1, { bg });
+        buf.centerText(0, "Request Approval", { fg: C.black, bg, bold: true });
+        return;
+    }
     if (state.isThinking) {
         // Flashing indicator: the whole bar alternates between highlighted and
         // dark while the agent is working, so the user always notices it.