reasonix 0.3.0-alpha.6 → 0.3.2

package/dist/index.d.ts

@@ -244,6 +244,14 @@ declare class AppendOnlyLog {
     private _entries;
     append(message: ChatMessage): void;
     extend(messages: ChatMessage[]): void;
+    /**
+     * Bulk-replace entries. Intentionally named to be hard to reach for —
+     * this is the one mutation path that breaks the log's append-only
+     * spirit, reserved for compaction flows (`/compact`) and recovery
+     * where the caller has consciously decided to drop old history. Any
+     * other use is almost certainly wrong; append() is what you want.
+     */
+    compactInPlace(replacement: ChatMessage[]): void;
     get entries(): readonly ChatMessage[];
     toMessages(): ChatMessage[];
     get length(): number;
@@ -379,6 +387,13 @@ interface SessionSummary {
     claudeEquivalentUsd: number;
     savingsVsClaudePct: number;
     cacheHitRatio: number;
+    /**
+     * Most recent turn's prompt-token count. Used by the TUI's context
+     * gauge: we can't know the next call's cost without making it, but
+     * the last turn's prompt tokens is the floor (next call is last
+     * prompt + user delta + any new tool outputs).
+     */
+    lastPromptTokens: number;
 }
 declare class SessionStats {
     readonly turns: TurnStats[];
@@ -418,7 +433,7 @@ declare class ToolRegistry {
     dispatch(name: string, argumentsRaw: string | Record<string, unknown>): Promise<string>;
 }
 
-type EventRole = "assistant_delta" | "assistant_final" | "tool" | "done" | "error" | "branch_start" | "branch_progress" | "branch_done";
+type EventRole = "assistant_delta" | "assistant_final" | "tool" | "done" | "error" | "warning" | "branch_start" | "branch_progress" | "branch_done";
 interface BranchSummary {
     budget: number;
     chosenIndex: number;
@@ -513,7 +528,28 @@ declare class CacheFirstLoop {
     readonly resumedMessageCount: number;
     private _turn;
     private _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.
+     */
+    private _aborted;
     constructor(opts: CacheFirstLoopOptions);
+    /**
+     * Shrink the log by re-truncating oversized tool results to a tighter
+     * cap, and persist the result back to disk so the next launch doesn't
+     * re-inherit a fat session file. Returns a summary the TUI can
+     * display.
+     *
+     * Only tool-role messages are touched (same rationale as
+     * {@link healLoadedMessages}). User and assistant messages carry
+     * authored intent we can't mechanically shrink without losing
+     * meaning.
+     */
+    compact(tightCapChars?: number): {
+        healedCount: number;
+        charsSaved: number;
+    };
     private appendAndPersist;
     /**
      * Reconfigure model/harvest/branch/stream mid-session. The loop's log,
@@ -523,7 +559,16 @@ declare class CacheFirstLoop {
      */
     configure(opts: ReconfigurableOptions): void;
     private buildMessages;
+    /**
+     * 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(): void;
     step(userInput: string): AsyncGenerator<LoopEvent>;
+    private forceSummaryAfterIterLimit;
     run(userInput: string, onEvent?: (ev: LoopEvent) => void): Promise<string>;
     private assistantMessage;
 }
@@ -1246,6 +1291,6 @@ declare function redactKey(key: string): string;
 
 /** Reasonix — DeepSeek-native agent framework. Library entry point. */
 
-declare const VERSION = "0.3.0-alpha.6";
+declare const VERSION = "0.3.2";
 
 export { AppendOnlyLog, type BranchOptions, type BranchProgress, type BranchResult, type BranchSample, type BranchSelector, type BranchSummary, type BridgeOptions, type BridgeResult, CacheFirstLoop, type CacheFirstLoopOptions, type CallToolResult, type ChatMessage, type ChatResponse, DEFAULT_MAX_RESULT_CHARS, DeepSeekClient, type DeepSeekClientOptions, type RenderOptions as DiffRenderOptions, type DiffReport, type DiffSide, type EventRole, type FlattenDecision, type FlattenOptions, type HarvestOptions, ImmutablePrefix, type ImmutablePrefixOptions, type InitializeResult, type JSONSchema, type JsonRpcMessage, type JsonRpcRequest, type JsonRpcResponse, type ListToolsResult, type LoopEvent, MCP_PROTOCOL_VERSION, McpClient, type McpClientOptions, type McpContentBlock, type McpSpec, type McpTool, type McpToolSchema, type McpTransport, type ReadTranscriptResult, type ReasonixConfig, type ReconfigurableOptions, type RepairReport, type ReplayStats, type RetryInfo, type RetryOptions, type Role, type ScavengeOptions, type ScavengeResult, type SessionInfo, SessionStats, type SessionSummary, type SseMcpSpec, SseTransport, type SseTransportOptions, type StdioMcpSpec, StdioTransport, type StdioTransportOptions, StormBreaker, type StreamChunk, type ToolCall, ToolCallRepair, type ToolCallRepairOptions, type ToolDefinition, type ToolFunctionSpec, ToolRegistry, type ToolSpec, type TranscriptMeta, type TranscriptRecord, type TruncationRepairResult, type TurnPair, type TurnStats, type TypedPlanState, Usage, VERSION, VolatileScratch, aggregateBranchUsage, analyzeSchema, appendSessionMessage, bridgeMcpTools, claudeEquivalentCost, computeReplayStats, costUsd, defaultConfigPath, defaultSelector, deleteSession, diffTranscripts, emptyPlanState, fetchWithRetry, flattenMcpResult, flattenSchema, formatLoopError, harvest, healLoadedMessages, isJsonRpcError, isPlanStateEmpty, isPlausibleKey, listSessions, loadApiKey, loadDotenv, loadSessionMessages, nestArguments, openTranscriptFile, parseMcpSpec, parseTranscript, readConfig, readTranscript, recordFromLoopEvent, redactKey, renderMarkdown as renderDiffMarkdown, renderSummaryTable as renderDiffSummary, repairTruncatedJson, replayFromFile, runBranches, sanitizeName as sanitizeSessionName, saveApiKey, scavengeToolCalls, sessionPath, sessionsDir, similarity, truncateForModel, writeConfig, writeMeta, writeRecord };

package/dist/index.js

@@ -636,6 +636,16 @@ var AppendOnlyLog = class {
   extend(messages) {
     for (const m of messages) this.append(m);
   }
+  /**
+   * Bulk-replace entries. Intentionally named to be hard to reach for —
+   * this is the one mutation path that breaks the log's append-only
+   * spirit, reserved for compaction flows (`/compact`) and recovery
+   * where the caller has consciously decided to drop old history. Any
+   * other use is almost certainly wrong; append() is what you want.
+   */
+  compactInPlace(replacement) {
+    this._entries = [...replacement];
+  }
   get entries() {
     return this._entries;
   }
@@ -914,7 +924,8 @@ import {
   readFileSync,
   readdirSync,
   statSync,
-  unlinkSync
+  unlinkSync,
+  writeFileSync
 } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
@@ -983,6 +994,17 @@ function deleteSession(name) {
     return false;
   }
 }
+function rewriteSession(name, messages) {
+  const path = sessionPath(name);
+  mkdirSync(dirname(path), { recursive: true });
+  const body = messages.map((m) => JSON.stringify(m)).join("\n");
+  writeFileSync(path, body ? `${body}
+` : "", "utf8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
 function countLines(path) {
   try {
     const raw = readFileSync(path, "utf8");
@@ -1041,12 +1063,14 @@ var SessionStats = class {
     return denom > 0 ? hit / denom : 0;
   }
   summary() {
+    const last = this.turns[this.turns.length - 1];
     return {
       turns: this.turns.length,
       totalCostUsd: round(this.totalCost, 6),
       claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
       savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
-      cacheHitRatio: round(this.aggregateCacheHitRatio, 4)
+      cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
+      lastPromptTokens: last?.usage.promptTokens ?? 0
     };
   }
 };
@@ -1078,12 +1102,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 ?? 8;
+    this.maxToolIters = opts.maxToolIters ?? 24;
     if (typeof opts.branch === "number") {
       this.branchOptions = { budget: opts.branch };
     } else if (opts.branch && typeof opts.branch === "object") {
@@ -1118,6 +1148,33 @@ var CacheFirstLoop = class {
       this.resumedMessageCount = 0;
     }
   }
+  /**
+   * Shrink the log by re-truncating oversized tool results to a tighter
+   * cap, and persist the result back to disk so the next launch doesn't
+   * re-inherit a fat session file. Returns a summary the TUI can
+   * display.
+   *
+   * Only tool-role messages are touched (same rationale as
+   * {@link healLoadedMessages}). User and assistant messages carry
+   * authored intent we can't mechanically shrink without losing
+   * meaning.
+   */
+  compact(tightCapChars = 4e3) {
+    const before = this.log.toMessages();
+    const { messages, healedCount, healedFrom } = healLoadedMessages(before, tightCapChars);
+    const afterBytes = messages.filter((m) => m.role === "tool").reduce((s, m) => s + (typeof m.content === "string" ? m.content.length : 0), 0);
+    const charsSaved = healedFrom - afterBytes;
+    if (healedCount > 0) {
+      this.log.compactInPlace(messages);
+      if (this.sessionName) {
+        try {
+          rewriteSession(this.sessionName, messages);
+        } catch {
+        }
+      }
+    }
+    return { healedCount, charsSaved };
+  }
   appendAndPersist(message) {
     this.log.append(message);
     if (this.sessionName) {
@@ -1162,12 +1219,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 = "";
@@ -1355,7 +1442,40 @@ var CacheFirstLoop = class {
         };
       }
     }
-    yield { turn: this._turn, role: "done", content: "[max_tool_iters reached]" };
+    yield* this.forceSummaryAfterIterLimit({ reason: "budget" });
+  }
+  async *forceSummaryAfterIterLimit(opts = { reason: "budget" }) {
+    try {
+      const messages = this.buildMessages(null);
+      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 annotated = `${reasonPrefix}
+
+${summary}`;
+      const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
+      this.appendAndPersist({ role: "assistant", content: summary });
+      yield {
+        turn: this._turn,
+        role: "assistant_final",
+        content: annotated,
+        stats: summaryStats
+      };
+      yield { turn: this._turn, role: "done", content: summary };
+    } catch (err) {
+      const label = opts.reason === "aborted" ? "aborted by user" : `tool-call budget (${this.maxToolIters}) reached`;
+      yield {
+        turn: this._turn,
+        role: "error",
+        content: "",
+        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: "" };
+    }
   }
   async run(userInput, onEvent) {
     let final = "";
@@ -1578,12 +1698,14 @@ function summarizeTurns(turns) {
   }
   const cacheHitRatio = hit + miss > 0 ? hit / (hit + miss) : 0;
   const savingsVsClaude = totalClaude > 0 ? 1 - totalCost / totalClaude : 0;
+  const lastTurn = turns[turns.length - 1];
   return {
     turns: turns.length,
     totalCostUsd: round2(totalCost, 6),
     claudeEquivalentUsd: round2(totalClaude, 6),
     savingsVsClaudePct: round2(savingsVsClaude * 100, 2),
-    cacheHitRatio: round2(cacheHitRatio, 4)
+    cacheHitRatio: round2(cacheHitRatio, 4),
+    lastPromptTokens: lastTurn?.usage.promptTokens ?? 0
   };
 }
 function round2(n, digits) {
@@ -2365,7 +2487,7 @@ function parseMcpSpec(input) {
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 function defaultConfigPath() {
@@ -2382,7 +2504,7 @@ function readConfig(path = defaultConfigPath()) {
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
   mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(cfg, null, 2), "utf8");
+  writeFileSync2(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
     chmodSync2(path, 384);
   } catch {
@@ -2408,7 +2530,7 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0-alpha.6";
+var VERSION = "0.3.2";
 export {
   AppendOnlyLog,
   CacheFirstLoop,