reasonix 0.3.2 → 0.4.3

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;
@@ -1113,7 +1118,7 @@ var CacheFirstLoop = class {
     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") {
@@ -1229,6 +1234,39 @@ var CacheFirstLoop = class {
   abort() {
     this._aborted = true;
   }
+  /**
+   * Drop everything in the log after (and including) the most recent
+   * user message. Used by `/retry` so the caller can re-send that
+   * message with a fresh turn instead of layering another response on
+   * top of the prior exchange. Returns the content of the dropped user
+   * message, or `null` if there isn't one yet.
+   *
+   * Persists by rewriting the session file — otherwise the next
+   * launch would rehydrate the old exchange and `/retry` would seem
+   * to have done nothing.
+   */
+  retryLastUser() {
+    const entries = this.log.entries;
+    let lastUserIdx = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      if (entries[i].role === "user") {
+        lastUserIdx = i;
+        break;
+      }
+    }
+    if (lastUserIdx < 0) return null;
+    const raw = entries[lastUserIdx].content;
+    const userText = typeof raw === "string" ? raw : "";
+    const preserved = entries.slice(0, lastUserIdx).map((m) => ({ ...m }));
+    this.log.compactInPlace(preserved);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, preserved);
+      } catch {
+      }
+    }
+    return userText;
+  }
   async *step(userInput) {
     this._turn++;
     this.scratch.reset();
@@ -1242,9 +1280,17 @@ var CacheFirstLoop = class {
         yield {
           turn: this._turn,
           role: "warning",
-          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 forcing summary from what was gathered`
+          content: `aborted at iter ${iter}/${this.maxToolIters} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)`
         };
-        yield* this.forceSummaryAfterIterLimit({ reason: "aborted" });
+        const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
+        this.appendAndPersist({ role: "assistant", content: stoppedMsg });
+        yield {
+          turn: this._turn,
+          role: "assistant_final",
+          content: stoppedMsg,
+          forcedSummary: true
+        };
+        yield { turn: this._turn, role: "done", content: stoppedMsg };
         return;
       }
       if (!warnedForIterBudget && iter >= warnAt) {
@@ -1302,8 +1348,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,
@@ -1423,9 +1469,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",
@@ -1447,13 +1512,19 @@ var CacheFirstLoop = class {
   async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
     try {
       const messages = this.buildMessages(null);
+      messages.push({
+        role: "user",
+        content: "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
+      });
       const resp = await this.client.chat({
         model: this.model,
         messages
         // 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 reasonPrefix = opts.reason === "aborted" ? "[aborted by user (Esc) \u2014 summarizing what I found so far]" : `[tool-call budget (${this.maxToolIters}) reached \u2014 forcing summary from what I found]`;
+      const rawContent = resp.content?.trim() ?? "";
+      const cleaned = stripHallucinatedToolMarkup(rawContent);
+      const summary = cleaned || "(model emitted fake tool-call markup instead of a prose summary \u2014 try /retry with a narrower question, or /think to inspect R1's reasoning)";
+      const reasonPrefix = reasonPrefixFor(opts.reason, this.maxToolIters);
       const annotated = `${reasonPrefix}
 
 ${summary}`;
@@ -1463,11 +1534,12 @@ ${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 = opts.reason === "aborted" ? "aborted by user" : `tool-call budget (${this.maxToolIters}) reached`;
+      const label = errorLabelFor(opts.reason, this.maxToolIters);
       yield {
         turn: this._turn,
         role: "error",
@@ -1492,6 +1564,26 @@ ${summary}`;
     return msg;
   }
 };
+function stripHallucinatedToolMarkup(s) {
+  let out = s;
+  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
+  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
+  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
+  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
+  return out.trim();
+}
+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,
@@ -2114,7 +2206,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(
@@ -2122,7 +2214,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         timeout
       });
@@ -2206,12 +2298,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();
       });
     });
   }
@@ -2222,8 +2314,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;
@@ -2289,8 +2381,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);
@@ -2317,8 +2409,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;
@@ -2486,16 +2578,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 {
@@ -2503,8 +2794,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 {
@@ -2530,9 +2821,10 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.3.2";
+var VERSION = "0.4.3";
 export {
   AppendOnlyLog,
+  CODE_SYSTEM_PROMPT,
   CacheFirstLoop,
   DEFAULT_MAX_RESULT_CHARS,
   DeepSeekClient,
@@ -2551,8 +2843,11 @@ export {
   aggregateBranchUsage,
   analyzeSchema,
   appendSessionMessage,
+  applyEditBlock,
+  applyEditBlocks,
   bridgeMcpTools,
   claudeEquivalentCost,
+  codeSystemPrompt,
   computeReplayStats,
   costUsd,
   defaultConfigPath,
@@ -2575,6 +2870,7 @@ export {
   loadSessionMessages,
   nestArguments,
   openTranscriptFile,
+  parseEditBlocks,
   parseMcpSpec,
   parseTranscript,
   readConfig,
@@ -2585,6 +2881,7 @@ export {
   renderSummaryTable as renderDiffSummary,
   repairTruncatedJson,
   replayFromFile,
+  restoreSnapshots,
   runBranches,
   sanitizeName as sanitizeSessionName,
   saveApiKey,
@@ -2592,6 +2889,8 @@ export {
   sessionPath,
   sessionsDir,
   similarity,
+  snapshotBeforeEdits,
+  stripHallucinatedToolMarkup,
   truncateForModel,
   writeConfig,
   writeMeta,