reasonix 0.3.1 → 0.4.1

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((resolve2, reject) => {
-    const timer = setTimeout(resolve2, ms);
+  return new Promise((resolve3, reject) => {
+    const timer = setTimeout(resolve3, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -1020,6 +1020,11 @@ var DEEPSEEK_PRICING = {
   "deepseek-reasoner": { inputCacheHit: 0.14, inputCacheMiss: 0.55, output: 2.19 }
 };
 var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
+var DEEPSEEK_CONTEXT_TOKENS = {
+  "deepseek-chat": 131072,
+  "deepseek-reasoner": 131072
+};
+var DEFAULT_CONTEXT_TOKENS = 131072;
 function costUsd(model, usage) {
   const p = DEEPSEEK_PRICING[model];
   if (!p) return 0;
@@ -1102,12 +1107,18 @@ var CacheFirstLoop = class {
   resumedMessageCount;
   _turn = 0;
   _streamPreference;
+  /**
+   * Set by {@link abort} to short-circuit the tool-call loop after the
+   * current iteration. Reset at the start of each `step()` so an Esc
+   * during one turn doesn't poison the next.
+   */
+  _aborted = false;
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-chat";
-    this.maxToolIters = opts.maxToolIters ?? 24;
+    this.maxToolIters = opts.maxToolIters ?? 64;
     if (typeof opts.branch === "number") {
       this.branchOptions = { budget: opts.branch };
     } else if (opts.branch && typeof opts.branch === "object") {
@@ -1213,12 +1224,42 @@ var CacheFirstLoop = class {
     if (pendingUser !== null) msgs.push({ role: "user", content: pendingUser });
     return msgs;
   }
+  /**
+   * Signal the currently-running {@link step} that the user wants to
+   * stop exploring. Takes effect at the next iteration boundary — if a
+   * tool call is mid-flight it will be allowed to finish, then the
+   * loop diverts to the forced-summary path so the user gets an
+   * answer instead of a cliff. Called by the TUI on Esc.
+   */
+  abort() {
+    this._aborted = true;
+  }
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
+    this._aborted = false;
     let pendingUser = userInput;
     const toolSpecs = this.prefix.tools();
+    const warnAt = Math.max(1, Math.floor(this.maxToolIters * 0.7));
+    let warnedForIterBudget = false;
     for (let iter = 0; iter < this.maxToolIters; iter++) {
+      if (this._aborted) {
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 forcing summary from what was gathered`
+        };
+        yield* this.forceSummaryAfterIterLimit({ reason: "aborted" });
+        return;
+      }
+      if (!warnedForIterBudget && iter >= warnAt) {
+        warnedForIterBudget = true;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `${iter}/${this.maxToolIters} tool calls used \u2014 approaching budget. Press Esc to force a summary now.`
+        };
+      }
       const messages = this.buildMessages(pendingUser);
       let assistantContent = "";
       let reasoningContent = "";
@@ -1266,8 +1307,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve2) => {
-              waiter = resolve2;
+            const sample = queue.shift() ?? await new Promise((resolve3) => {
+              waiter = resolve3;
             });
             yield {
               turn: this._turn,
@@ -1387,9 +1428,28 @@ var CacheFirstLoop = class {
         yield { turn: this._turn, role: "done", content: assistantContent };
         return;
       }
+      const ctxMax = DEEPSEEK_CONTEXT_TOKENS[this.model] ?? DEFAULT_CONTEXT_TOKENS;
+      if (usage && usage.promptTokens / ctxMax > 0.8) {
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `context ${usage.promptTokens}/${ctxMax} (${Math.round(
+            usage.promptTokens / ctxMax * 100
+          )}%) \u2014 more tools would overflow. Forcing summary from what was gathered.`
+        };
+        yield* this.forceSummaryAfterIterLimit({ reason: "context-guard" });
+        return;
+      }
       for (const call of repairedCalls) {
         const name = call.function?.name ?? "";
         const args = call.function?.arguments ?? "{}";
+        yield {
+          turn: this._turn,
+          role: "tool_start",
+          content: "",
+          toolName: name,
+          toolArgs: args
+        };
         const result = await this.tools.dispatch(name, args);
         this.appendAndPersist({
           role: "tool",
@@ -1406,9 +1466,9 @@ var CacheFirstLoop = class {
         };
       }
     }
-    yield* this.forceSummaryAfterIterLimit();
+    yield* this.forceSummaryAfterIterLimit({ reason: "budget" });
   }
-  async *forceSummaryAfterIterLimit() {
+  async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
     try {
       const messages = this.buildMessages(null);
       const resp = await this.client.chat({
@@ -1417,7 +1477,8 @@ var CacheFirstLoop = class {
         // no tools → model is forced to answer in text
       });
       const summary = resp.content?.trim() || "(model returned no text; try a narrower question or raise --max-tool-iters)";
-      const annotated = `[tool-call budget (${this.maxToolIters}) reached \u2014 forcing summary from what I found]
+      const reasonPrefix = reasonPrefixFor(opts.reason, this.maxToolIters);
+      const annotated = `${reasonPrefix}
 
 ${summary}`;
       const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
@@ -1426,15 +1487,17 @@ ${summary}`;
         turn: this._turn,
         role: "assistant_final",
         content: annotated,
-        stats: summaryStats
+        stats: summaryStats,
+        forcedSummary: true
       };
       yield { turn: this._turn, role: "done", content: summary };
     } catch (err) {
+      const label = errorLabelFor(opts.reason, this.maxToolIters);
       yield {
         turn: this._turn,
         role: "error",
         content: "",
-        error: `tool-call budget (${this.maxToolIters}) reached and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or pass --max-tool-iters higher.`
+        error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
       };
       yield { turn: this._turn, role: "done", content: "" };
     }
@@ -1454,6 +1517,18 @@ ${summary}`;
     return msg;
   }
 };
+function reasonPrefixFor(reason, iterCap) {
+  if (reason === "aborted") return "[aborted by user (Esc) \u2014 summarizing what I found so far]";
+  if (reason === "context-guard") {
+    return "[context budget running low \u2014 summarizing before the next call would overflow]";
+  }
+  return `[tool-call budget (${iterCap}) reached \u2014 forcing summary from what I found]`;
+}
+function errorLabelFor(reason, iterCap) {
+  if (reason === "aborted") return "aborted by user";
+  if (reason === "context-guard") return "context-guard triggered (prompt > 80% of window)";
+  return `tool-call budget (${iterCap}) reached`;
+}
 function summarizeBranch(chosen, samples) {
   return {
     budget: samples.length,
@@ -2076,7 +2151,7 @@ var McpClient = class {
   async request(method, params) {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
-    const promise = new Promise((resolve2, reject) => {
+    const promise = new Promise((resolve3, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(
@@ -2084,7 +2159,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         timeout
       });
@@ -2168,12 +2243,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve2();
+        else resolve3();
       });
     });
   }
@@ -2184,8 +2259,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve2) => {
-        this.waiters.push(resolve2);
+      const next = await new Promise((resolve3) => {
+        this.waiters.push(resolve3);
       });
       if (next === null) return;
       yield next;
@@ -2251,8 +2326,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve2, reject) => {
-      this.resolveEndpoint = resolve2;
+    this.endpointReady = new Promise((resolve3, reject) => {
+      this.resolveEndpoint = resolve3;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -2279,8 +2354,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve2) => {
-        this.waiters.push(resolve2);
+      const next = await new Promise((resolve3) => {
+        this.waiters.push(resolve3);
       });
       if (next === null) return;
       yield next;
@@ -2448,16 +2523,215 @@ function parseMcpSpec(input) {
   return { transport: "stdio", name, command, args };
 }
 
+// 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 dirname2, resolve as resolve2 } 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 = [];
+  BLOCK_RE.lastIndex = 0;
+  let m = BLOCK_RE.exec(text);
+  while (m !== null) {
+    out.push({
+      path: m[1].trim(),
+      search: m[2],
+      replace: m[3],
+      offset: m.index
+    });
+    m = BLOCK_RE.exec(text);
+  }
+  return out;
+}
+function applyEditBlock(block, rootDir) {
+  const absRoot = resolve2(rootDir);
+  const absTarget = resolve2(absRoot, block.path);
+  if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
+    return {
+      path: block.path,
+      status: "path-escape",
+      message: `resolved path ${absTarget} is outside rootDir ${absRoot}`
+    };
+  }
+  const searchEmpty = block.search.length === 0;
+  const exists = existsSync2(absTarget);
+  try {
+    if (!exists) {
+      if (!searchEmpty) {
+        return {
+          path: block.path,
+          status: "file-missing",
+          message: "file does not exist; to create it, use an empty SEARCH block"
+        };
+      }
+      mkdirSync2(dirname2(absTarget), { recursive: true });
+      writeFileSync2(absTarget, block.replace, "utf8");
+      return { path: block.path, status: "created" };
+    }
+    const content = readFileSync4(absTarget, "utf8");
+    if (searchEmpty) {
+      return {
+        path: block.path,
+        status: "not-found",
+        message: "empty SEARCH only creates new files \u2014 this file already exists"
+      };
+    }
+    const idx = content.indexOf(block.search);
+    if (idx === -1) {
+      return {
+        path: block.path,
+        status: "not-found",
+        message: "SEARCH text does not match the current file content exactly"
+      };
+    }
+    const replaced = `${content.slice(0, idx)}${block.replace}${content.slice(idx + block.search.length)}`;
+    writeFileSync2(absTarget, replaced, "utf8");
+    return { path: block.path, status: "applied" };
+  } catch (err) {
+    return { path: block.path, status: "error", message: err.message };
+  }
+}
+function applyEditBlocks(blocks, rootDir) {
+  return blocks.map((b) => applyEditBlock(b, rootDir));
+}
+function snapshotBeforeEdits(blocks, rootDir) {
+  const absRoot = resolve2(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 = resolve2(absRoot, b.path);
+    if (!existsSync2(abs)) {
+      snapshots.push({ path: b.path, prevContent: null });
+      continue;
+    }
+    try {
+      snapshots.push({ path: b.path, prevContent: readFileSync4(abs, "utf8") });
+    } catch {
+      snapshots.push({ path: b.path, prevContent: null });
+    }
+  }
+  return snapshots;
+}
+function restoreSnapshots(snapshots, rootDir) {
+  const absRoot = resolve2(rootDir);
+  return snapshots.map((snap) => {
+    const abs = resolve2(absRoot, snap.path);
+    if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
+      return {
+        path: snap.path,
+        status: "path-escape",
+        message: "snapshot path escapes rootDir \u2014 refusing to restore"
+      };
+    }
+    try {
+      if (snap.prevContent === null) {
+        if (existsSync2(abs)) unlinkSync2(abs);
+        return {
+          path: snap.path,
+          status: "applied",
+          message: "removed (the edit had created it)"
+        };
+      }
+      writeFileSync2(abs, snap.prevContent, "utf8");
+      return {
+        path: snap.path,
+        status: "applied",
+        message: "restored to pre-edit content"
+      };
+    } catch (err) {
+      return { path: snap.path, status: "error", message: err.message };
+    }
+  });
+}
+function sep() {
+  return process.platform === "win32" ? "\\" : "/";
+}
+
+// src/code/prompt.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { join as join2 } 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
+
+Only propose edits when the user explicitly asks you to change, fix, add, remove, refactor, or write something. Do NOT propose edits when the user asks you to:
+- analyze, read, explore, describe, or summarize a project
+- explain how something works
+- answer a question about the code
+
+In those cases, use tools to gather what you need, then reply in prose. No SEARCH/REPLACE blocks, no file changes. If you're unsure what the user wants, ask.
+
+When you do propose edits, the user will review them and decide whether to \`/apply\` or \`/discard\`. Don't assume they'll accept \u2014 write as if each edit will be audited, because it will.
+
+# Editing files
+
+When you've been asked to change a file, output one or more SEARCH/REPLACE blocks in this exact format:
+
+path/to/file.ext
+<<<<<<< SEARCH
+exact existing lines from the file, including whitespace
+=======
+the new lines
+>>>>>>> REPLACE
+
+Rules:
+- Always read_file first so your SEARCH matches byte-for-byte. If it doesn't match, the edit is rejected and you'll have to retry with the exact current content.
+- One edit per block. Multiple blocks in one response are fine.
+- To create a new file, leave SEARCH empty:
+    path/to/new.ts
+    <<<<<<< SEARCH
+    =======
+    (whole file content here)
+    >>>>>>> REPLACE
+- Do NOT use write_file to change existing files \u2014 the user reviews your edits as SEARCH/REPLACE. write_file is only for files you explicitly want to overwrite wholesale (rare).
+- Paths are relative to the working directory. Don't use absolute paths.
+
+# Exploration
+
+- Avoid listing or reading inside these common dependency / build directories unless the user explicitly asks about them: node_modules, dist, build, out, .next, .nuxt, .svelte-kit, .git, .venv, venv, __pycache__, target, coverage, .turbo, .cache. They're expensive and usually irrelevant.
+- Prefer search_files / grep over list_directory when you know roughly what you're looking for \u2014 it saves context and avoids enumerating huge trees.
+
+# Style
+
+- Show edits; don't narrate them in prose. "Here's the fix:" is enough.
+- One short paragraph explaining *why*, then the blocks.
+- 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 = join2(rootDir, ".gitignore");
+  if (!existsSync3(gitignorePath)) return CODE_SYSTEM_PROMPT;
+  let content;
+  try {
+    content = readFileSync5(gitignorePath, "utf8");
+  } catch {
+    return CODE_SYSTEM_PROMPT;
+  }
+  const MAX = 2e3;
+  const truncated = content.length > MAX ? `${content.slice(0, MAX)}
+\u2026 (truncated ${content.length - MAX} chars)` : content;
+  return `${CODE_SYSTEM_PROMPT}
+
+# Project .gitignore
+
+The user's repo ships this .gitignore \u2014 treat every pattern as "don't traverse or edit inside these paths unless explicitly asked":
+
+\`\`\`
+${truncated}
+\`\`\`
+`;
+}
+
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname3, join as join3 } from "path";
 function defaultConfigPath() {
-  return join2(homedir2(), ".reasonix", "config.json");
+  return join3(homedir2(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync4(path, "utf8");
+    const raw = readFileSync6(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -2465,8 +2739,8 @@ function readConfig(path = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, JSON.stringify(cfg, null, 2), "utf8");
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path, 384);
   } catch {
@@ -2492,9 +2766,10 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.3.1";
+var VERSION = "0.4.1";
 export {
   AppendOnlyLog,
+  CODE_SYSTEM_PROMPT,
   CacheFirstLoop,
   DEFAULT_MAX_RESULT_CHARS,
   DeepSeekClient,
@@ -2513,8 +2788,11 @@ export {
   aggregateBranchUsage,
   analyzeSchema,
   appendSessionMessage,
+  applyEditBlock,
+  applyEditBlocks,
   bridgeMcpTools,
   claudeEquivalentCost,
+  codeSystemPrompt,
   computeReplayStats,
   costUsd,
   defaultConfigPath,
@@ -2537,6 +2815,7 @@ export {
   loadSessionMessages,
   nestArguments,
   openTranscriptFile,
+  parseEditBlocks,
   parseMcpSpec,
   parseTranscript,
   readConfig,
@@ -2547,6 +2826,7 @@ export {
   renderSummaryTable as renderDiffSummary,
   repairTruncatedJson,
   replayFromFile,
+  restoreSnapshots,
   runBranches,
   sanitizeName as sanitizeSessionName,
   saveApiKey,
@@ -2554,6 +2834,7 @@ export {
   sessionPath,
   sessionsDir,
   similarity,
+  snapshotBeforeEdits,
   truncateForModel,
   writeConfig,
   writeMeta,