@xingjisoft/neutrino 0.1.4 → 0.1.5

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,9 +56,16 @@ export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
     default_intensity: "High",
-    // Estimated prompt tokens above which the conversation is auto-compressed.
-    // 0 disables auto-compression.
-    context_compress_threshold: 32000,
+    // 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 = {
@@ -48,32 +75,28 @@ export const INTENSITY_PARAMS = {
     Max: { temperature: 1.0, top_p: 1.0 },
     Ultra: { temperature: 1.5, top_p: 1.0 },
 };
-/**
- * Selectable auto-compression thresholds, in estimated prompt tokens.
- * `0` turns the feature off. Rendered as-is in the settings screen.
- */
-export const COMPRESS_THRESHOLD_OPTIONS = [
-    { value: 0, label: "Off" },
-    { value: 8000, label: "8K tokens" },
-    { value: 16000, label: "16K tokens" },
-    { value: 32000, label: "32K tokens" },
-    { value: 64000, label: "64K tokens" },
-    { value: 128000, label: "128K tokens" },
-];
+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;
     }
 }
@@ -82,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 };
     }
 }
@@ -98,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 = {};
@@ -106,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 = "";
@@ -130,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) {
@@ -186,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.