reasonix 0.4.15 → 0.4.17

package/dist/index.js

@@ -47,8 +47,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve4, reject) => {
-    const timer = setTimeout(resolve4, ms);
+  return new Promise((resolve5, reject) => {
+    const timer = setTimeout(resolve5, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -1488,8 +1488,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve4) => {
-              waiter = resolve4;
+            const sample = queue.shift() ?? await new Promise((resolve5) => {
+              waiter = resolve5;
             });
             yield {
               turn: this._turn,
@@ -1848,6 +1848,49 @@ function formatLoopError(err) {
   return msg;
 }
 
+// src/project-memory.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var PROJECT_MEMORY_FILE = "REASONIX.md";
+var PROJECT_MEMORY_MAX_CHARS = 8e3;
+function readProjectMemory(rootDir) {
+  const path = join2(rootDir, PROJECT_MEMORY_FILE);
+  if (!existsSync2(path)) return null;
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const originalChars = trimmed.length;
+  const truncated = originalChars > PROJECT_MEMORY_MAX_CHARS;
+  const content = truncated ? `${trimmed.slice(0, PROJECT_MEMORY_MAX_CHARS)}
+\u2026 (truncated ${originalChars - PROJECT_MEMORY_MAX_CHARS} chars)` : trimmed;
+  return { path, content, originalChars, truncated };
+}
+function memoryEnabled() {
+  const env = process.env.REASONIX_MEMORY;
+  if (env === "off" || env === "false" || env === "0") return false;
+  return true;
+}
+function applyProjectMemory(basePrompt, rootDir) {
+  if (!memoryEnabled()) return basePrompt;
+  const mem = readProjectMemory(rootDir);
+  if (!mem) return basePrompt;
+  return `${basePrompt}
+
+# Project memory (REASONIX.md)
+
+The user pinned these notes about this project \u2014 treat them as authoritative context for every turn:
+
+\`\`\`
+${mem.content}
+\`\`\`
+`;
+}
+
 // src/tools/filesystem.ts
 import { promises as fs } from "fs";
 import * as pathMod from "path";
@@ -2183,6 +2226,221 @@ function lineDiff(a, b) {
   return out;
 }
 
+// src/tools/shell.ts
+import { spawn } from "child_process";
+import * as pathMod2 from "path";
+var DEFAULT_TIMEOUT_SEC = 60;
+var DEFAULT_MAX_OUTPUT_CHARS = 32e3;
+var BUILTIN_ALLOWLIST = [
+  // Repo inspection
+  "git status",
+  "git diff",
+  "git log",
+  "git show",
+  "git blame",
+  "git branch",
+  "git remote",
+  "git rev-parse",
+  "git config --get",
+  // Filesystem inspection
+  "ls",
+  "pwd",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "file",
+  "tree",
+  "find",
+  "grep",
+  "rg",
+  // Language version probes
+  "node --version",
+  "node -v",
+  "npm --version",
+  "npx --version",
+  "python --version",
+  "python3 --version",
+  "cargo --version",
+  "go version",
+  "rustc --version",
+  "deno --version",
+  "bun --version",
+  // Test runners (non-destructive by convention)
+  "npm test",
+  "npm run test",
+  "npx vitest run",
+  "npx vitest",
+  "npx jest",
+  "pytest",
+  "python -m pytest",
+  "cargo test",
+  "cargo check",
+  "cargo clippy",
+  "go test",
+  "go vet",
+  "deno test",
+  "bun test",
+  // Linters / typecheckers (read-only by convention)
+  "npm run lint",
+  "npm run typecheck",
+  "npx tsc --noEmit",
+  "npx biome check",
+  "npx eslint",
+  "npx prettier --check",
+  "ruff",
+  "mypy"
+];
+function tokenizeCommand(cmd) {
+  const out = [];
+  let cur = "";
+  let quote = null;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else if (ch === "\\" && quote === '"' && i + 1 < cmd.length) {
+        cur += cmd[++i];
+      } else {
+        cur += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (cur.length > 0) {
+        out.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += ch;
+  }
+  if (quote) throw new Error(`unclosed ${quote} in command`);
+  if (cur.length > 0) out.push(cur);
+  return out;
+}
+function isAllowed(cmd, extra = []) {
+  const normalized = cmd.trim().replace(/\s+/g, " ");
+  const allowlist = [...BUILTIN_ALLOWLIST, ...extra];
+  for (const prefix of allowlist) {
+    if (normalized === prefix) return true;
+    if (normalized.startsWith(`${prefix} `)) return true;
+  }
+  return false;
+}
+async function runCommand(cmd, opts) {
+  const argv = tokenizeCommand(cmd);
+  if (argv.length === 0) throw new Error("run_command: empty command");
+  const timeoutMs = (opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC) * 1e3;
+  const maxChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+  const spawnOpts = {
+    cwd: opts.cwd,
+    shell: false,
+    // no shell-expansion — see header comment
+    windowsHide: true,
+    env: process.env
+  };
+  return await new Promise((resolve5, reject) => {
+    let child;
+    try {
+      child = spawn(argv[0], argv.slice(1), spawnOpts);
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    let buf = "";
+    let timedOut = false;
+    const killTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    const onAbort = () => child.kill("SIGKILL");
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      if (buf.length > maxChars * 2) buf = `${buf.slice(0, maxChars * 2)}`;
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("error", (err) => {
+      clearTimeout(killTimer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(killTimer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      const output = buf.length > maxChars ? `${buf.slice(0, maxChars)}
+
+[\u2026 truncated ${buf.length - maxChars} chars \u2026]` : buf;
+      resolve5({ exitCode: code, output, timedOut });
+    });
+  });
+}
+var NeedsConfirmationError = class extends Error {
+  command;
+  constructor(command) {
+    super(
+      `run_command: "${command}" needs the user's approval before it runs. STOP calling tools now \u2014 the TUI has already prompted the user to press y (run) or n (deny). Wait for their next message; it will either be the command's output (if they approved) or an instruction to continue without it (if they denied). Don't retry the command or call other shell commands in the meantime.`
+    );
+    this.name = "NeedsConfirmationError";
+    this.command = command;
+  }
+};
+function registerShellTools(registry, opts) {
+  const rootDir = pathMod2.resolve(opts.rootDir);
+  const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
+  const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+  const extraAllowed = opts.extraAllowed ?? [];
+  const allowAll = opts.allowAll ?? false;
+  registry.register({
+    name: "run_command",
+    description: "Run a shell command in the project root and return its combined stdout+stderr. Read-only and test commands (git status, ls, npm test, pytest, cargo test, grep, etc.) run immediately. Anything that could mutate state (npm install, git commit, rm, chmod) is refused and the user has to confirm in the TUI. Prefer this over asking the user to run a command manually \u2014 after edits, run the project's tests to verify.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "Full command line, e.g. 'npm test' or 'git diff src/foo.ts'. Tokenized with POSIX-ish quoting; no shell expansion, no pipes, no redirects."
+        },
+        timeoutSec: {
+          type: "integer",
+          description: `Override the default ${timeoutSec}s timeout for a single command.`
+        }
+      },
+      required: ["command"]
+    },
+    fn: async (args, ctx) => {
+      const cmd = args.command.trim();
+      if (!cmd) throw new Error("run_command: empty command");
+      if (!allowAll && !isAllowed(cmd, extraAllowed)) {
+        throw new NeedsConfirmationError(cmd);
+      }
+      const effectiveTimeout = Math.max(1, Math.min(600, args.timeoutSec ?? timeoutSec));
+      const result = await runCommand(cmd, {
+        cwd: rootDir,
+        timeoutSec: effectiveTimeout,
+        maxOutputChars,
+        signal: ctx?.signal
+      });
+      return formatCommandResult(cmd, result);
+    }
+  });
+  return registry;
+}
+function formatCommandResult(cmd, r) {
+  const header = r.timedOut ? `$ ${cmd}
+[killed after timeout]` : `$ ${cmd}
+[exit ${r.exitCode ?? "?"}]`;
+  return r.output ? `${header}
+${r.output}` : header;
+}
+
 // src/tools/web.ts
 var DEFAULT_FETCH_MAX_CHARS = 32e3;
 var DEFAULT_FETCH_TIMEOUT_MS = 15e3;
@@ -2365,12 +2623,12 @@ ${i + 1}. ${r.title}`);
 }
 
 // src/env.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync2(resolve2(process.cwd(), path), "utf8");
+    raw = readFileSync3(resolve3(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -2389,7 +2647,7 @@ function loadDotenv(path = ".env") {
 }
 
 // src/transcript.ts
-import { createWriteStream, readFileSync as readFileSync3 } from "fs";
+import { createWriteStream, readFileSync as readFileSync4 } from "fs";
 function recordFromLoopEvent(ev, extra) {
   const rec = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2440,7 +2698,7 @@ function openTranscriptFile(path, meta) {
   return stream;
 }
 function readTranscript(path) {
-  const raw = readFileSync3(path, "utf8");
+  const raw = readFileSync4(path, "utf8");
   return parseTranscript(raw);
 }
 function isPlanStateEmptyShape(s) {
@@ -3052,7 +3310,7 @@ var McpClient = class {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     let abortHandler = null;
-    const promise = new Promise((resolve4, reject) => {
+    const promise = new Promise((resolve5, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
@@ -3061,7 +3319,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve4,
+        resolve: resolve5,
         reject,
         timeout
       });
@@ -3143,7 +3401,7 @@ var McpClient = class {
 };
 
 // src/mcp/stdio.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var StdioTransport = class {
   child;
   queue = [];
@@ -3158,14 +3416,14 @@ var StdioTransport = class {
         opts.command,
         ...(opts.args ?? []).map((a) => quoteArg(a, process.platform === "win32"))
       ].join(" ");
-      this.child = spawn(line, [], {
+      this.child = spawn2(line, [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"],
         shell: true
       });
     } else {
-      this.child = spawn(opts.command, opts.args ?? [], {
+      this.child = spawn2(opts.command, opts.args ?? [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"]
@@ -3184,12 +3442,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve4();
+        else resolve5();
       });
     });
   }
@@ -3200,8 +3458,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve4) => {
-        this.waiters.push(resolve4);
+      const next = await new Promise((resolve5) => {
+        this.waiters.push(resolve5);
       });
       if (next === null) return;
       yield next;
@@ -3267,8 +3525,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve4, reject) => {
-      this.resolveEndpoint = resolve4;
+    this.endpointReady = new Promise((resolve5, reject) => {
+      this.resolveEndpoint = resolve5;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -3295,8 +3553,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve4) => {
-        this.waiters.push(resolve4);
+      const next = await new Promise((resolve5) => {
+        this.waiters.push(resolve5);
       });
       if (next === null) return;
       yield next;
@@ -3495,8 +3753,8 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, resolve as resolve3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, resolve as resolve4 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -3514,8 +3772,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve3(rootDir);
-  const absTarget = resolve3(absRoot, block.path);
+  const absRoot = resolve4(rootDir);
+  const absTarget = resolve4(absRoot, block.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block.path,
@@ -3524,7 +3782,7 @@ function applyEditBlock(block, rootDir) {
     };
   }
   const searchEmpty = block.search.length === 0;
-  const exists = existsSync2(absTarget);
+  const exists = existsSync3(absTarget);
   try {
     if (!exists) {
       if (!searchEmpty) {
@@ -3538,7 +3796,7 @@ function applyEditBlock(block, rootDir) {
       writeFileSync2(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync4(absTarget, "utf8");
+    const content = readFileSync5(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -3565,19 +3823,19 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve3(rootDir);
+  const absRoot = resolve4(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
-    const abs = resolve3(absRoot, b.path);
-    if (!existsSync2(abs)) {
+    const abs = resolve4(absRoot, b.path);
+    if (!existsSync3(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync4(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync5(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -3585,9 +3843,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve3(rootDir);
+  const absRoot = resolve4(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve3(absRoot, snap.path);
+    const abs = resolve4(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,
@@ -3597,7 +3855,7 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync2(abs)) unlinkSync2(abs);
+        if (existsSync3(abs)) unlinkSync2(abs);
         return {
           path: snap.path,
           status: "applied",
@@ -3620,8 +3878,8 @@ function sep() {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join4 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, list_directory, search_files, etc.) rooted at the user's working directory.
 
 # When to edit vs. when to explore
@@ -3670,18 +3928,19 @@ Rules:
 - If you need to explore first (list / grep / read), do it with tool calls before writing any prose \u2014 silence while exploring is fine.
 `;
 function codeSystemPrompt(rootDir) {
-  const gitignorePath = join3(rootDir, ".gitignore");
-  if (!existsSync3(gitignorePath)) return CODE_SYSTEM_PROMPT;
+  const withMemory = applyProjectMemory(CODE_SYSTEM_PROMPT, rootDir);
+  const gitignorePath = join4(rootDir, ".gitignore");
+  if (!existsSync4(gitignorePath)) return withMemory;
   let content;
   try {
-    content = readFileSync5(gitignorePath, "utf8");
+    content = readFileSync6(gitignorePath, "utf8");
   } catch {
-    return CODE_SYSTEM_PROMPT;
+    return withMemory;
   }
   const MAX = 2e3;
   const truncated = content.length > MAX ? `${content.slice(0, MAX)}
 \u2026 (truncated ${content.length - MAX} chars)` : content;
-  return `${CODE_SYSTEM_PROMPT}
+  return `${withMemory}
 
 # Project .gitignore
 
@@ -3694,15 +3953,15 @@ ${truncated}
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join4 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 function defaultConfigPath() {
-  return join4(homedir2(), ".reasonix", "config.json");
+  return join5(homedir2(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync6(path, "utf8");
+    const raw = readFileSync7(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -3737,7 +3996,7 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.4.15";
+var VERSION = "0.4.17";
 export {
   AppendOnlyLog,
   CODE_SYSTEM_PROMPT,
@@ -3747,6 +4006,9 @@ export {
   ImmutablePrefix,
   MCP_PROTOCOL_VERSION,
   McpClient,
+  NeedsConfirmationError,
+  PROJECT_MEMORY_FILE,
+  PROJECT_MEMORY_MAX_CHARS,
   SessionStats,
   SseTransport,
   StdioTransport,
@@ -3761,6 +4023,7 @@ export {
   appendSessionMessage,
   applyEditBlock,
   applyEditBlocks,
+  applyProjectMemory,
   bridgeMcpTools,
   claudeEquivalentCost,
   codeSystemPrompt,
@@ -3774,6 +4037,7 @@ export {
   fetchWithRetry,
   flattenMcpResult,
   flattenSchema,
+  formatCommandResult,
   formatLoopError,
   formatSearchResults,
   harvest,
@@ -3781,6 +4045,7 @@ export {
   htmlToText,
   inputCostUsd,
   inspectMcpServer,
+  isAllowed,
   isJsonRpcError,
   isPlanStateEmpty,
   isPlausibleKey,
@@ -3788,6 +4053,7 @@ export {
   loadApiKey,
   loadDotenv,
   loadSessionMessages,
+  memoryEnabled,
   nestArguments,
   openTranscriptFile,
   outputCostUsd,
@@ -3796,10 +4062,12 @@ export {
   parseMojeekResults,
   parseTranscript,
   readConfig,
+  readProjectMemory,
   readTranscript,
   recordFromLoopEvent,
   redactKey,
   registerFilesystemTools,
+  registerShellTools,
   registerWebTools,
   renderMarkdown as renderDiffMarkdown,
   renderSummaryTable as renderDiffSummary,
@@ -3807,6 +4075,7 @@ export {
   replayFromFile,
   restoreSnapshots,
   runBranches,
+  runCommand,
   sanitizeName as sanitizeSessionName,
   saveApiKey,
   scavengeToolCalls,
@@ -3815,6 +4084,7 @@ export {
   similarity,
   snapshotBeforeEdits,
   stripHallucinatedToolMarkup,
+  tokenizeCommand,
   truncateForModel,
   webFetch,
   webSearch,