reasonix 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,1089 @@
+#!/usr/bin/env node
+import {
+  DeepSeekClient
+} from "./chunk-OSNTDDD6.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/harvest.ts
+function emptyPlanState() {
+  return { subgoals: [], hypotheses: [], uncertainties: [], rejectedPaths: [] };
+}
+async function harvest(_reasoningContent) {
+  return emptyPlanState();
+}
+
+// src/memory.ts
+import { createHash } from "crypto";
+var ImmutablePrefix = class {
+  system;
+  toolSpecs;
+  fewShots;
+  constructor(opts) {
+    this.system = opts.system;
+    this.toolSpecs = Object.freeze([...opts.toolSpecs ?? []]);
+    this.fewShots = Object.freeze([...opts.fewShots ?? []]);
+  }
+  toMessages() {
+    return [{ role: "system", content: this.system }, ...this.fewShots.map((m) => ({ ...m }))];
+  }
+  tools() {
+    return this.toolSpecs.map((t) => structuredClone(t));
+  }
+  get fingerprint() {
+    const blob = JSON.stringify({
+      system: this.system,
+      tools: this.toolSpecs,
+      shots: this.fewShots
+    });
+    return createHash("sha256").update(blob).digest("hex").slice(0, 16);
+  }
+};
+var AppendOnlyLog = class {
+  _entries = [];
+  append(message) {
+    if (!message || typeof message !== "object" || !("role" in message)) {
+      throw new Error(`invalid log entry: ${JSON.stringify(message)}`);
+    }
+    this._entries.push(message);
+  }
+  extend(messages) {
+    for (const m of messages) this.append(m);
+  }
+  get entries() {
+    return this._entries;
+  }
+  toMessages() {
+    return this._entries.map((e) => ({ ...e }));
+  }
+  get length() {
+    return this._entries.length;
+  }
+};
+var VolatileScratch = class {
+  reasoning = null;
+  planState = null;
+  notes = [];
+  reset() {
+    this.reasoning = null;
+    this.planState = null;
+    this.notes = [];
+  }
+};
+
+// src/repair/scavenge.ts
+function scavengeToolCalls(reasoningContent, opts) {
+  if (!reasoningContent) return { calls: [], notes: [] };
+  const max = opts.maxCalls ?? 4;
+  const notes = [];
+  const out = [];
+  for (const candidate of iterateJsonObjects(reasoningContent)) {
+    if (out.length >= max) break;
+    const call = coerceToToolCall(candidate, opts.allowedNames);
+    if (call) {
+      out.push(call);
+      notes.push(`scavenged call: ${call.function.name}`);
+    }
+  }
+  return { calls: out, notes };
+}
+function* iterateJsonObjects(text) {
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let j = i; j < text.length; j++) {
+      const c = text[j];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (inString) {
+        if (c === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (c === '"') inString = false;
+        continue;
+      }
+      if (c === '"') inString = true;
+      else if (c === "{") depth++;
+      else if (c === "}") {
+        depth--;
+        if (depth === 0) {
+          yield text.slice(i, j + 1);
+          i = j;
+          break;
+        }
+      }
+    }
+  }
+}
+function coerceToToolCall(candidateJson, allowedNames) {
+  let parsed;
+  try {
+    parsed = JSON.parse(candidateJson);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  if (typeof parsed.name === "string" && allowedNames.has(parsed.name)) {
+    const args = parsed.arguments;
+    return {
+      function: {
+        name: parsed.name,
+        arguments: typeof args === "string" ? args : JSON.stringify(args ?? {})
+      }
+    };
+  }
+  if (parsed.type === "function" && parsed.function && typeof parsed.function.name === "string" && allowedNames.has(parsed.function.name)) {
+    const args = parsed.function.arguments;
+    return {
+      type: "function",
+      function: {
+        name: parsed.function.name,
+        arguments: typeof args === "string" ? args : JSON.stringify(args ?? {})
+      }
+    };
+  }
+  if (typeof parsed.tool_name === "string" && allowedNames.has(parsed.tool_name)) {
+    return {
+      function: {
+        name: parsed.tool_name,
+        arguments: JSON.stringify(parsed.tool_args ?? {})
+      }
+    };
+  }
+  return null;
+}
+
+// src/repair/storm.ts
+var StormBreaker = class {
+  windowSize;
+  threshold;
+  recent = [];
+  constructor(windowSize = 6, threshold = 3) {
+    this.windowSize = windowSize;
+    this.threshold = threshold;
+  }
+  inspect(call) {
+    const sig = signature(call);
+    if (!sig) return { suppress: false };
+    const count = this.recent.reduce(
+      (n, [name, args]) => name === sig[0] && args === sig[1] ? n + 1 : n,
+      0
+    );
+    if (count >= this.threshold - 1) {
+      return {
+        suppress: true,
+        reason: `call-storm suppressed: ${sig[0]} called with identical args ${count + 1} times within window=${this.windowSize}`
+      };
+    }
+    this.recent.push(sig);
+    while (this.recent.length > this.windowSize) this.recent.shift();
+    return { suppress: false };
+  }
+  reset() {
+    this.recent.length = 0;
+  }
+};
+function signature(call) {
+  const name = call.function?.name;
+  if (!name) return null;
+  return [name, call.function?.arguments ?? ""];
+}
+
+// src/repair/truncation.ts
+function repairTruncatedJson(input) {
+  const notes = [];
+  if (!input || !input.trim()) {
+    return { repaired: "{}", changed: input !== "{}", notes: ["empty input \u2192 {}"] };
+  }
+  try {
+    JSON.parse(input);
+    return { repaired: input, changed: false, notes: [] };
+  } catch {
+  }
+  const stack = [];
+  let escaped = false;
+  let inString = false;
+  let lastSignificant = -1;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (!/\s/.test(c)) lastSignificant = i;
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString) {
+      if (c === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (c === '"') {
+        inString = false;
+        stack.pop();
+      }
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      stack.push('"');
+      continue;
+    }
+    if (c === "{" || c === "[") stack.push(c);
+    else if (c === "}" || c === "]") stack.pop();
+  }
+  let s = input.slice(0, lastSignificant + 1);
+  if (/,$/.test(s)) {
+    s = s.replace(/,$/, "");
+    notes.push("trimmed trailing comma");
+  }
+  if (/"\s*:\s*$/.test(s)) {
+    s += " null";
+    notes.push("filled dangling key with null");
+  }
+  if (inString) {
+    s += '"';
+    stack.pop();
+    notes.push("closed unterminated string");
+  }
+  while (stack.length > 0) {
+    const top = stack.pop();
+    if (top === "{") s += "}";
+    else if (top === "[") s += "]";
+    else if (top === '"') s += '"';
+  }
+  try {
+    JSON.parse(s);
+    return { repaired: s, changed: true, notes };
+  } catch (err) {
+    notes.push(`fallback to {}: ${err.message}`);
+    return { repaired: "{}", changed: true, notes };
+  }
+}
+
+// src/repair/index.ts
+var ToolCallRepair = class {
+  storm;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3);
+  }
+  process(declaredCalls, reasoningContent) {
+    const report = {
+      scavenged: 0,
+      truncationsFixed: 0,
+      stormsBroken: 0,
+      notes: []
+    };
+    const scavenged = scavengeToolCalls(reasoningContent, {
+      allowedNames: this.opts.allowedToolNames,
+      maxCalls: this.opts.maxScavenge ?? 4
+    });
+    const seenSignatures = new Set(declaredCalls.map(signature2));
+    const merged = [...declaredCalls];
+    for (const sc of scavenged.calls) {
+      if (!seenSignatures.has(signature2(sc))) {
+        merged.push(sc);
+        report.scavenged++;
+        seenSignatures.add(signature2(sc));
+      }
+    }
+    report.notes.push(...scavenged.notes);
+    for (const call of merged) {
+      const args = call.function?.arguments ?? "";
+      const r = repairTruncatedJson(args);
+      if (r.changed) {
+        call.function.arguments = r.repaired;
+        report.truncationsFixed++;
+        report.notes.push(...r.notes.map((n) => `[${call.function.name}] ${n}`));
+      }
+    }
+    const filtered = [];
+    for (const call of merged) {
+      const verdict = this.storm.inspect(call);
+      if (verdict.suppress) {
+        report.stormsBroken++;
+        if (verdict.reason) report.notes.push(verdict.reason);
+        continue;
+      }
+      filtered.push(call);
+    }
+    return { calls: filtered, report };
+  }
+};
+function signature2(call) {
+  return `${call.function?.name ?? ""}::${call.function?.arguments ?? ""}`;
+}
+
+// src/telemetry.ts
+var DEEPSEEK_PRICING = {
+  "deepseek-chat": { inputCacheHit: 0.07, inputCacheMiss: 0.27, output: 1.1 },
+  "deepseek-reasoner": { inputCacheHit: 0.14, inputCacheMiss: 0.55, output: 2.19 }
+};
+var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
+function costUsd(model, usage) {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss + usage.completionTokens * p.output) / 1e6;
+}
+function claudeEquivalentCost(usage) {
+  return (usage.promptTokens * CLAUDE_SONNET_PRICING.input + usage.completionTokens * CLAUDE_SONNET_PRICING.output) / 1e6;
+}
+var SessionStats = class {
+  turns = [];
+  record(turn, model, usage) {
+    const cost = costUsd(model, usage);
+    const stats = {
+      turn,
+      model,
+      usage,
+      cost,
+      cacheHitRatio: usage.cacheHitRatio
+    };
+    this.turns.push(stats);
+    return stats;
+  }
+  get totalCost() {
+    return this.turns.reduce((sum, t) => sum + t.cost, 0);
+  }
+  get totalClaudeEquivalent() {
+    return this.turns.reduce((sum, t) => sum + claudeEquivalentCost(t.usage), 0);
+  }
+  get savingsVsClaude() {
+    const c = this.totalClaudeEquivalent;
+    return c > 0 ? 1 - this.totalCost / c : 0;
+  }
+  get aggregateCacheHitRatio() {
+    let hit = 0;
+    let miss = 0;
+    for (const t of this.turns) {
+      hit += t.usage.promptCacheHitTokens;
+      miss += t.usage.promptCacheMissTokens;
+    }
+    const denom = hit + miss;
+    return denom > 0 ? hit / denom : 0;
+  }
+  summary() {
+    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)
+    };
+  }
+};
+function round(n, digits) {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+}
+
+// src/tools.ts
+var ToolRegistry = class {
+  _tools = /* @__PURE__ */ new Map();
+  register(def) {
+    if (!def.name) throw new Error("tool requires a name");
+    this._tools.set(def.name, def);
+    return this;
+  }
+  has(name) {
+    return this._tools.has(name);
+  }
+  get(name) {
+    return this._tools.get(name);
+  }
+  get size() {
+    return this._tools.size;
+  }
+  specs() {
+    return [...this._tools.values()].map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.parameters ?? { type: "object", properties: {} }
+      }
+    }));
+  }
+  async dispatch(name, argumentsRaw) {
+    const tool = this._tools.get(name);
+    if (!tool) {
+      return JSON.stringify({ error: `unknown tool: ${name}` });
+    }
+    let args;
+    try {
+      args = typeof argumentsRaw === "string" ? argumentsRaw.trim() ? JSON.parse(argumentsRaw) : {} : argumentsRaw ?? {};
+    } catch (err) {
+      return JSON.stringify({
+        error: `invalid tool arguments JSON: ${err.message}`
+      });
+    }
+    try {
+      const result = await tool.fn(args);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (err) {
+      return JSON.stringify({
+        error: `${err.name}: ${err.message}`
+      });
+    }
+  }
+};
+
+// src/loop.ts
+var CacheFirstLoop = class {
+  client;
+  prefix;
+  tools;
+  model;
+  maxToolIters;
+  stream;
+  log = new AppendOnlyLog();
+  scratch = new VolatileScratch();
+  stats = new SessionStats();
+  repair;
+  _turn = 0;
+  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.stream = opts.stream ?? true;
+    const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
+    this.repair = new ToolCallRepair({ allowedToolNames: allowedNames });
+  }
+  buildMessages(pendingUser) {
+    const msgs = [...this.prefix.toMessages(), ...this.log.toMessages()];
+    if (pendingUser !== null) msgs.push({ role: "user", content: pendingUser });
+    return msgs;
+  }
+  async *step(userInput) {
+    this._turn++;
+    this.scratch.reset();
+    let pendingUser = userInput;
+    const toolSpecs = this.prefix.tools();
+    for (let iter = 0; iter < this.maxToolIters; iter++) {
+      const messages = this.buildMessages(pendingUser);
+      let assistantContent = "";
+      let reasoningContent = "";
+      let toolCalls = [];
+      let usage = null;
+      try {
+        if (this.stream) {
+          const callBuf = /* @__PURE__ */ new Map();
+          for await (const chunk of this.client.stream({
+            model: this.model,
+            messages,
+            tools: toolSpecs.length ? toolSpecs : void 0
+          })) {
+            if (chunk.contentDelta) {
+              assistantContent += chunk.contentDelta;
+              yield {
+                turn: this._turn,
+                role: "assistant_delta",
+                content: chunk.contentDelta
+              };
+            }
+            if (chunk.reasoningDelta) {
+              reasoningContent += chunk.reasoningDelta;
+              yield {
+                turn: this._turn,
+                role: "assistant_delta",
+                content: "",
+                reasoningDelta: chunk.reasoningDelta
+              };
+            }
+            if (chunk.toolCallDelta) {
+              const d = chunk.toolCallDelta;
+              const cur = callBuf.get(d.index) ?? {
+                id: d.id,
+                type: "function",
+                function: { name: "", arguments: "" }
+              };
+              if (d.id) cur.id = d.id;
+              if (d.name) cur.function.name = (cur.function.name ?? "") + d.name;
+              if (d.argumentsDelta)
+                cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
+              callBuf.set(d.index, cur);
+            }
+            if (chunk.usage) usage = chunk.usage;
+          }
+          toolCalls = [...callBuf.values()];
+        } else {
+          const resp = await this.client.chat({
+            model: this.model,
+            messages,
+            tools: toolSpecs.length ? toolSpecs : void 0
+          });
+          assistantContent = resp.content;
+          reasoningContent = resp.reasoningContent ?? "";
+          toolCalls = resp.toolCalls;
+          usage = resp.usage;
+        }
+      } catch (err) {
+        yield {
+          turn: this._turn,
+          role: "error",
+          content: "",
+          error: err.message
+        };
+        return;
+      }
+      const turnStats = this.stats.record(
+        this._turn,
+        this.model,
+        usage ?? new (await import("./client-OWZXRMOE.js")).Usage()
+      );
+      if (pendingUser !== null) {
+        this.log.append({ role: "user", content: pendingUser });
+        pendingUser = null;
+      }
+      this.scratch.reasoning = reasoningContent || null;
+      const planState = await harvest(reasoningContent || null);
+      const { calls: repairedCalls, report } = this.repair.process(
+        toolCalls,
+        reasoningContent || null
+      );
+      this.log.append(this.assistantMessage(assistantContent, repairedCalls));
+      yield {
+        turn: this._turn,
+        role: "assistant_final",
+        content: assistantContent,
+        stats: turnStats,
+        planState,
+        repair: report
+      };
+      if (repairedCalls.length === 0) {
+        yield { turn: this._turn, role: "done", content: assistantContent };
+        return;
+      }
+      for (const call of repairedCalls) {
+        const name = call.function?.name ?? "";
+        const args = call.function?.arguments ?? "{}";
+        const result = await this.tools.dispatch(name, args);
+        this.log.append({
+          role: "tool",
+          tool_call_id: call.id ?? "",
+          name,
+          content: result
+        });
+        yield { turn: this._turn, role: "tool", content: result, toolName: name };
+      }
+    }
+    yield { turn: this._turn, role: "done", content: "[max_tool_iters reached]" };
+  }
+  async run(userInput, onEvent) {
+    let final = "";
+    for await (const ev of this.step(userInput)) {
+      onEvent?.(ev);
+      if (ev.role === "assistant_final") final = ev.content;
+      if (ev.role === "done") break;
+    }
+    return final;
+  }
+  assistantMessage(content, toolCalls) {
+    const msg = { role: "assistant", content };
+    if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+    return msg;
+  }
+};
+
+// src/env.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function loadDotenv(path = ".env") {
+  let raw;
+  try {
+    raw = readFileSync(resolve(process.cwd(), path), "utf8");
+  } catch {
+    return;
+  }
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (process.env[key] === void 0) process.env[key] = value;
+  }
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+
+// src/cli/commands/chat.tsx
+import { render } from "ink";
+import React6 from "react";
+
+// src/cli/ui/App.tsx
+import { createWriteStream } from "fs";
+import { Box as Box5, Static, useApp } from "ink";
+import React5, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/cli/ui/EventLog.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import React2 from "react";
+
+// src/cli/ui/markdown.tsx
+import { Box, Text } from "ink";
+import React from "react";
+function stripMath(s) {
+  return s.replace(/\\\(\s*/g, "").replace(/\s*\\\)/g, "").replace(/\\\[\s*/g, "\n").replace(/\s*\\\]/g, "\n").replace(/\\boxed\{([^}]+)\}/g, "\u3010$1\u3011").replace(/\\sqrt\{([^}]+)\}/g, "\u221A($1)").replace(/\\frac\{([^}]+)\}\{([^}]+)\}/g, "($1)/($2)").replace(/\\text\{([^}]+)\}/g, "$1").replace(/\\cdot/g, "\xB7").replace(/\\times/g, "\xD7").replace(/\\div/g, "\xF7").replace(/\\pm/g, "\xB1").replace(/\\mp/g, "\u2213").replace(/\\leq/g, "\u2264").replace(/\\geq/g, "\u2265").replace(/\\neq/g, "\u2260").replace(/\\approx/g, "\u2248").replace(/\\in\b/g, "\u2208").replace(/\\notin\b/g, "\u2209").replace(/\\infty/g, "\u221E").replace(/\\sum\b/g, "\u03A3").replace(/\\prod\b/g, "\u03A0").replace(/\\int\b/g, "\u222B").replace(/\\alpha/g, "\u03B1").replace(/\\beta/g, "\u03B2").replace(/\\gamma/g, "\u03B3").replace(/\\delta/g, "\u03B4").replace(/\\theta/g, "\u03B8").replace(/\\lambda/g, "\u03BB").replace(/\\mu/g, "\u03BC").replace(/\\pi/g, "\u03C0").replace(/\\sigma/g, "\u03C3").replace(/\\phi/g, "\u03C6").replace(/\\omega/g, "\u03C9").replace(/\\implies\b/g, "\u21D2").replace(/\\iff\b/g, "\u21D4").replace(/\\to\b/g, "\u2192").replace(/\\rightarrow/g, "\u2192").replace(/\\Rightarrow/g, "\u21D2").replace(/\\leftarrow/g, "\u2190").replace(/\\Leftarrow/g, "\u21D0").replace(/\\ldots/g, "\u2026").replace(/\\cdots/g, "\u22EF").replace(/\\quad/g, "  ").replace(/\\qquad/g, "    ").replace(/\\,/g, " ").replace(/\\;/g, " ").replace(/\\!/g, "").replace(/\\\\/g, "\n").replace(/[ \t]{2,}/g, " ");
+}
+var INLINE_RE = /(\*\*([^*\n]+?)\*\*|`([^`\n]+?)`|(?<![*\w])\*([^*\n]+?)\*(?!\w))/g;
+function InlineMd({ text }) {
+  const parts = [];
+  let last = 0;
+  let idx = 0;
+  for (const m of text.matchAll(INLINE_RE)) {
+    const start = m.index ?? 0;
+    if (start > last) {
+      parts.push(/* @__PURE__ */ React.createElement(Text, { key: `t${idx++}` }, text.slice(last, start)));
+    }
+    if (m[2] !== void 0) {
+      parts.push(
+        /* @__PURE__ */ React.createElement(Text, { key: `b${idx++}`, bold: true }, m[2])
+      );
+    } else if (m[3] !== void 0) {
+      parts.push(
+        /* @__PURE__ */ React.createElement(Text, { key: `c${idx++}`, color: "yellow" }, m[3])
+      );
+    } else if (m[4] !== void 0) {
+      parts.push(
+        /* @__PURE__ */ React.createElement(Text, { key: `i${idx++}`, italic: true }, m[4])
+      );
+    }
+    last = start + m[0].length;
+  }
+  if (last < text.length) {
+    parts.push(/* @__PURE__ */ React.createElement(Text, { key: `t${idx++}` }, text.slice(last)));
+  }
+  return /* @__PURE__ */ React.createElement(Text, null, parts);
+}
+function parseBlocks(raw) {
+  const lines = raw.split(/\r?\n/);
+  const out = [];
+  let para = [];
+  let inCode = false;
+  let codeLang = "";
+  let codeBuf = [];
+  let listBuf = null;
+  const flushPara = () => {
+    if (para.length) {
+      out.push({ kind: "paragraph", text: para.join(" ") });
+      para = [];
+    }
+  };
+  const flushList = () => {
+    if (listBuf) {
+      out.push(listBuf);
+      listBuf = null;
+    }
+  };
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+$/g, "");
+    const fence = line.match(/^```(\w*)/);
+    if (fence) {
+      if (inCode) {
+        out.push({ kind: "code", lang: codeLang, text: codeBuf.join("\n") });
+        codeBuf = [];
+        codeLang = "";
+        inCode = false;
+      } else {
+        flushPara();
+        flushList();
+        inCode = true;
+        codeLang = fence[1] ?? "";
+      }
+      continue;
+    }
+    if (inCode) {
+      codeBuf.push(rawLine);
+      continue;
+    }
+    if (line.trim() === "") {
+      flushPara();
+      flushList();
+      continue;
+    }
+    if (/^[-*_]{3,}\s*$/.test(line)) {
+      flushPara();
+      flushList();
+      out.push({ kind: "hr" });
+      continue;
+    }
+    const hm = line.match(/^(#{1,6})\s+(.+)$/);
+    if (hm) {
+      flushPara();
+      flushList();
+      out.push({ kind: "heading", level: hm[1].length, text: hm[2].trim() });
+      continue;
+    }
+    const bm = line.match(/^\s*[-*+]\s+(.+)$/);
+    if (bm) {
+      flushPara();
+      if (!listBuf || listBuf.ordered) {
+        flushList();
+        listBuf = { kind: "bullet", items: [], ordered: false, start: 1 };
+      }
+      listBuf.items.push(bm[1]);
+      continue;
+    }
+    const om = line.match(/^\s*(\d+)\.\s+(.+)$/);
+    if (om) {
+      flushPara();
+      if (!listBuf || !listBuf.ordered) {
+        flushList();
+        listBuf = { kind: "bullet", items: [], ordered: true, start: Number(om[1]) };
+      }
+      listBuf.items.push(om[2]);
+      continue;
+    }
+    flushList();
+    para.push(line);
+  }
+  if (inCode && codeBuf.length) {
+    out.push({ kind: "code", lang: codeLang, text: codeBuf.join("\n") });
+  }
+  flushPara();
+  flushList();
+  return out;
+}
+function BlockView({ block }) {
+  switch (block.kind) {
+    case "heading":
+      return /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, /* @__PURE__ */ React.createElement(InlineMd, { text: block.text }));
+    case "paragraph":
+      return /* @__PURE__ */ React.createElement(InlineMd, { text: block.text });
+    case "bullet":
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, block.items.map((item, i) => /* @__PURE__ */ React.createElement(Box, { key: `${i}-${item.slice(0, 24)}` }, /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, block.ordered ? ` ${block.start + i}. ` : "  \u2022 "), /* @__PURE__ */ React.createElement(InlineMd, { text: item }))));
+    case "code":
+      return /* @__PURE__ */ React.createElement(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, block.text));
+    case "hr":
+      return /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  }
+}
+function Markdown({ text }) {
+  const cleaned = stripMath(text);
+  const blocks = React.useMemo(() => parseBlocks(cleaned), [cleaned]);
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", gap: 1 }, blocks.map((b, i) => /* @__PURE__ */ React.createElement(BlockView, { key: `${i}-${b.kind}`, block: b })));
+}
+
+// src/cli/ui/EventLog.tsx
+var EventRow = React2.memo(function EventRow2({ event }) {
+  if (event.role === "user") {
+    return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "you \u203A", " "), /* @__PURE__ */ React2.createElement(Text2, null, event.text));
+  }
+  if (event.role === "assistant") {
+    if (event.streaming) return /* @__PURE__ */ React2.createElement(StreamingAssistant, { event });
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant")), event.reasoning ? /* @__PURE__ */ React2.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, event.text ? /* @__PURE__ */ React2.createElement(Markdown, { text: event.text }) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React2.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React2.createElement(Text2, { color: "magenta" }, event.repair) : null);
+  }
+  if (event.role === "tool") {
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, `tool<${event.toolName ?? "?"}>  \u2192`), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " ", truncate(event.text, 400)));
+  }
+  if (event.role === "error") {
+    return /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, event.text));
+  }
+  if (event.role === "info") {
+    return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, event.text));
+  }
+  return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, null, event.text));
+});
+function ReasoningBlock({ reasoning }) {
+  const max = 220;
+  const flat = reasoning.replace(/\s+/g, " ").trim();
+  const preview = flat.length <= max ? flat : `${flat.slice(0, max)}\u2026 (+${flat.length - max} chars)`;
+  return /* @__PURE__ */ React2.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "\u21B3 thinking: ", preview));
+}
+function StreamingAssistant({ event }) {
+  const tail = lastLine(event.text, 140);
+  const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(streaming \xB7 ", event.text.length, event.reasoning ? ` + think ${event.reasoning.length}` : "", " chars)")), reasoningTail ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "\u25B8 ", tail) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true, italic: true }, "  (waiting for first token\u2026)"));
+}
+function lastLine(s, maxChars) {
+  const flat = s.replace(/\s+/g, " ").trim();
+  if (!flat) return "";
+  return flat.length <= maxChars ? flat : `\u2026${flat.slice(-maxChars)}`;
+}
+function StatsLine({ stats }) {
+  const hit = (stats.cacheHitRatio * 100).toFixed(1);
+  return /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "  \u21B3 cache ", hit, "% \xB7 tokens ", stats.usage.promptTokens, "\u2192", stats.usage.completionTokens, " \xB7 $", stats.cost.toFixed(6));
+}
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max)}\u2026 (+${s.length - max} chars)`;
+}
+
+// src/cli/ui/PromptInput.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import TextInput from "ink-text-input";
+import React3 from "react";
+function PromptInput({
+  value,
+  onChange,
+  onSubmit,
+  disabled,
+  placeholder
+}) {
+  return /* @__PURE__ */ React3.createElement(Box3, { borderStyle: "round", borderColor: disabled ? "gray" : "cyan", paddingX: 1 }, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: disabled ? "gray" : "cyan" }, "you \u203A", " "), disabled ? /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, placeholder ?? "\u2026waiting for response\u2026") : /* @__PURE__ */ React3.createElement(
+    TextInput,
+    {
+      value,
+      onChange,
+      onSubmit,
+      placeholder: placeholder ?? 'type a message, or "/exit"'
+    }
+  ));
+}
+
+// src/cli/ui/StatsPanel.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import React4 from "react";
+function StatsPanel({ summary, model, prefixHash }) {
+  const hitPct = (summary.cacheHitRatio * 100).toFixed(1);
+  const hitColor = summary.cacheHitRatio >= 0.7 ? "green" : summary.cacheHitRatio >= 0.4 ? "yellow" : "red";
+  return /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Box4, { justifyContent: "space-between" }, /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "Reasonix"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " \xB7 model "), /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, model), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " \xB7 prefix "), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, prefixHash)), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "turns ", summary.turns)), /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "cache hit "), /* @__PURE__ */ React4.createElement(Text4, { color: hitColor, bold: true }, hitPct, "%")), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "cost "), /* @__PURE__ */ React4.createElement(Text4, { color: "green" }, "$", summary.totalCostUsd.toFixed(6))), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "vs Claude "), /* @__PURE__ */ React4.createElement(Text4, null, "$", summary.claudeEquivalentUsd.toFixed(6))), /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "saving "), /* @__PURE__ */ React4.createElement(Text4, { color: "green", bold: true }, summary.savingsVsClaudePct.toFixed(1), "%"))));
+}
+
+// src/cli/ui/App.tsx
+var FLUSH_INTERVAL_MS = 60;
+function App({ model, system, transcript }) {
+  const { exit } = useApp();
+  const [historical, setHistorical] = useState([]);
+  const [streaming, setStreaming] = useState(null);
+  const [input, setInput] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [summary, setSummary] = useState({
+    turns: 0,
+    totalCostUsd: 0,
+    claudeEquivalentUsd: 0,
+    savingsVsClaudePct: 0,
+    cacheHitRatio: 0
+  });
+  const transcriptRef = useRef(null);
+  if (transcript && !transcriptRef.current) {
+    transcriptRef.current = createWriteStream(transcript, { flags: "a" });
+  }
+  useEffect(() => {
+    return () => {
+      transcriptRef.current?.end();
+    };
+  }, []);
+  const loopRef = useRef(null);
+  const loop = useMemo(() => {
+    if (loopRef.current) return loopRef.current;
+    const client = new DeepSeekClient();
+    const prefix = new ImmutablePrefix({ system });
+    const l = new CacheFirstLoop({ client, prefix, model });
+    loopRef.current = l;
+    return l;
+  }, [model, system]);
+  const prefixHash = loop.prefix.fingerprint;
+  const writeTranscript = useCallback((ev) => {
+    transcriptRef.current?.write(
+      `${JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        turn: ev.turn,
+        role: ev.role,
+        content: ev.content,
+        tool: ev.toolName
+      })}
+`
+    );
+  }, []);
+  const handleSubmit = useCallback(
+    async (raw) => {
+      const text = raw.trim();
+      if (!text || busy) return;
+      setInput("");
+      if (text === "/exit" || text === "/quit") {
+        transcriptRef.current?.end();
+        exit();
+        return;
+      }
+      if (text === "/clear") {
+        setHistorical([]);
+        return;
+      }
+      setHistorical((prev) => [...prev, { id: `u-${Date.now()}`, role: "user", text }]);
+      const assistantId = `a-${Date.now()}`;
+      const streamRef = { id: assistantId, text: "", reasoning: "" };
+      const contentBuf = { current: "" };
+      const reasoningBuf = { current: "" };
+      setStreaming({ id: assistantId, role: "assistant", text: "", streaming: true });
+      setBusy(true);
+      const flush = () => {
+        if (!contentBuf.current && !reasoningBuf.current) return;
+        streamRef.text += contentBuf.current;
+        streamRef.reasoning += reasoningBuf.current;
+        contentBuf.current = "";
+        reasoningBuf.current = "";
+        setStreaming({
+          id: assistantId,
+          role: "assistant",
+          text: streamRef.text,
+          reasoning: streamRef.reasoning || void 0,
+          streaming: true
+        });
+      };
+      const timer = setInterval(flush, FLUSH_INTERVAL_MS);
+      try {
+        for await (const ev of loop.step(text)) {
+          writeTranscript(ev);
+          if (ev.role === "assistant_delta") {
+            if (ev.content) contentBuf.current += ev.content;
+            if (ev.reasoningDelta) reasoningBuf.current += ev.reasoningDelta;
+          } else if (ev.role === "assistant_final") {
+            flush();
+            const repairNote = ev.repair ? describeRepair(ev.repair) : "";
+            setStreaming(null);
+            setHistorical((prev) => [
+              ...prev,
+              {
+                id: assistantId,
+                role: "assistant",
+                text: ev.content || streamRef.text,
+                reasoning: streamRef.reasoning || void 0,
+                stats: ev.stats,
+                repair: repairNote || void 0,
+                streaming: false
+              }
+            ]);
+          } else if (ev.role === "tool") {
+            flush();
+            setHistorical((prev) => [
+              ...prev,
+              {
+                id: `t-${Date.now()}-${Math.random()}`,
+                role: "tool",
+                text: ev.content,
+                toolName: ev.toolName
+              }
+            ]);
+          } else if (ev.role === "error") {
+            setHistorical((prev) => [
+              ...prev,
+              { id: `e-${Date.now()}`, role: "error", text: ev.error ?? ev.content }
+            ]);
+          }
+        }
+        flush();
+      } finally {
+        clearInterval(timer);
+        setStreaming(null);
+        setSummary(loop.stats.summary());
+        setBusy(false);
+      }
+    },
+    [busy, exit, loop, writeTranscript]
+  );
+  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React5.createElement(StatsPanel, { summary, model, prefixHash }), /* @__PURE__ */ React5.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React5.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React5.createElement(Box5, { marginY: 1 }, /* @__PURE__ */ React5.createElement(EventRow, { event: streaming })) : null, /* @__PURE__ */ React5.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }));
+}
+function describeRepair(repair) {
+  const parts = [];
+  if (repair.scavenged) parts.push(`scavenged ${repair.scavenged}`);
+  if (repair.truncationsFixed) parts.push(`repaired ${repair.truncationsFixed} truncation`);
+  if (repair.stormsBroken) parts.push(`broke ${repair.stormsBroken} storm`);
+  return parts.length ? `[repair] ${parts.join(", ")}` : "";
+}
+
+// src/cli/commands/chat.tsx
+async function chatCommand(opts) {
+  loadDotenv();
+  if (!process.env.DEEPSEEK_API_KEY) {
+    console.error("DEEPSEEK_API_KEY is not set. Copy .env.example to .env and fill it in.");
+    process.exit(1);
+  }
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ React6.createElement(App, { model: opts.model, system: opts.system, transcript: opts.transcript }),
+    { exitOnCtrlC: true }
+  );
+  await waitUntilExit();
+}
+
+// src/cli/commands/run.ts
+async function runCommand(opts) {
+  loadDotenv();
+  const client = new DeepSeekClient();
+  const prefix = new ImmutablePrefix({ system: opts.system });
+  const loop = new CacheFirstLoop({ client, prefix, model: opts.model });
+  for await (const ev of loop.step(opts.task)) {
+    if (ev.role === "assistant_delta" && ev.content) process.stdout.write(ev.content);
+    if (ev.role === "tool") process.stdout.write(`
+[tool ${ev.toolName}] ${ev.content}
+`);
+    if (ev.role === "error") process.stderr.write(`
+[error] ${ev.error}
+`);
+    if (ev.role === "done") process.stdout.write("\n");
+  }
+  const s = loop.stats.summary();
+  process.stdout.write(
+    `
+\u2014 turns:${s.turns} cache:${(s.cacheHitRatio * 100).toFixed(1)}% cost:$${s.totalCostUsd.toFixed(6)} save-vs-claude:${s.savingsVsClaudePct.toFixed(1)}%
+`
+  );
+}
+
+// src/cli/commands/stats.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+function statsCommand(opts) {
+  if (!existsSync(opts.transcript)) {
+    console.error(`no such transcript: ${opts.transcript}`);
+    process.exit(1);
+  }
+  const lines = readFileSync2(opts.transcript, "utf8").split(/\r?\n/).filter(Boolean);
+  let assistantTurns = 0;
+  let toolCalls = 0;
+  let lastTurn = 0;
+  for (const line of lines) {
+    try {
+      const rec = JSON.parse(line);
+      if (rec.role === "assistant_final") assistantTurns++;
+      if (rec.role === "tool") toolCalls++;
+      if (typeof rec.turn === "number") lastTurn = Math.max(lastTurn, rec.turn);
+    } catch {
+    }
+  }
+  console.log(`transcript:       ${opts.transcript}`);
+  console.log(`assistant turns:  ${assistantTurns}`);
+  console.log(`tool invocations: ${toolCalls}`);
+  console.log(`last turn index:  ${lastTurn}`);
+}
+
+// src/cli/commands/version.ts
+function versionCommand() {
+  console.log(`reasonix ${VERSION}`);
+}
+
+// src/cli/index.ts
+var DEFAULT_SYSTEM = "You are Reasonix, a helpful DeepSeek-powered assistant. Be concise and accurate. Use tools when available.";
+var program = new Command();
+program.name("reasonix").description("DeepSeek-native agent framework \u2014 built for cache hits and cheap tokens.").version(VERSION);
+program.command("chat").description("Interactive Ink TUI with live cache/cost panel.").option("-m, --model <id>", "DeepSeek model id", "deepseek-chat").option("-s, --system <prompt>", "System prompt (pinned in the immutable prefix)", DEFAULT_SYSTEM).option("--transcript <path>", "Write a JSONL transcript to this path").action(async (opts) => {
+  await chatCommand({
+    model: opts.model,
+    system: opts.system,
+    transcript: opts.transcript
+  });
+});
+program.command("run <task>").description("Run a single task non-interactively, streaming output.").option("-m, --model <id>", "DeepSeek model id", "deepseek-chat").option("-s, --system <prompt>", "System prompt", DEFAULT_SYSTEM).action(async (task, opts) => {
+  await runCommand({ task, model: opts.model, system: opts.system });
+});
+program.command("stats <transcript>").description("Summarize a JSONL transcript produced by `reasonix chat --transcript`.").action((transcript) => {
+  statsCommand({ transcript });
+});
+program.command("version").description("Print Reasonix version.").action(versionCommand);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map