indusagi 0.12.33 → 0.13.0

package/dist/cli.js

@@ -4637,6 +4637,7 @@ function runErrorThrowable(kind, message) {
 }
 
 // src/capabilities/kernel/spec.ts
+var READ_STATE_HANDLE_KEY = "readState";
 function coerceInput(raw) {
   if (typeof raw === "string") {
     const trimmed = raw.trim();
@@ -5090,7 +5091,7 @@ var standardBudget = {
 [${omitted} bytes elided to stay within the output ceiling]
 `
 };
-function makeNodeContext(cwd, signal, budget) {
+function makeNodeContext(cwd, signal, budget, framework) {
   if (typeof cwd !== "string" || cwd.length === 0) {
     throw new Error("makeNodeContext requires a non-empty working directory.");
   }
@@ -5099,10 +5100,60 @@ function makeNodeContext(cwd, signal, budget) {
     fs: nodeFs,
     shell: nodeShell,
     signal: signal ?? neverAborts(),
-    budget: budget ?? standardBudget
+    budget: budget ?? standardBudget,
+    ...framework ? { framework } : {}
   };
 }
 
+// src/capabilities/files/read-state-gate.ts
+var READ_BEFORE_EDIT_MESSAGE = "File has not been read yet. Read it first before writing to it.";
+var MODIFIED_SINCE_READ_MESSAGE = "File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.";
+function getReadStateHandle(ctx) {
+  const bag = ctx.framework;
+  if (!bag || typeof bag !== "object") return void 0;
+  const candidate = bag[READ_STATE_HANDLE_KEY];
+  if (!candidate || typeof candidate !== "object") return void 0;
+  const handle = candidate;
+  if (typeof handle.get !== "function" || typeof handle.set !== "function" || typeof handle.has !== "function") {
+    return void 0;
+  }
+  return handle;
+}
+async function recordReadState(ctx, absPath, handle) {
+  if (!handle) return;
+  try {
+    const info = await ctx.fs.stat(absPath);
+    const record = {
+      mtimeMs: Math.floor(info.modifiedMs),
+      size: info.size,
+      readAt: Date.now()
+    };
+    handle.set(absPath, record);
+  } catch {
+  }
+}
+async function enforceReadGate(ctx, absPath, handle) {
+  if (!handle) return { ok: true };
+  if (!handle.has(absPath)) {
+    return { ok: false, message: READ_BEFORE_EDIT_MESSAGE };
+  }
+  const recorded = handle.get(absPath);
+  if (!recorded) {
+    return { ok: false, message: READ_BEFORE_EDIT_MESSAGE };
+  }
+  let info;
+  try {
+    info = await ctx.fs.stat(absPath);
+  } catch {
+    return { ok: true };
+  }
+  const currentMtime = Math.floor(info.modifiedMs);
+  if (currentMtime > recorded.mtimeMs || info.size !== recorded.size) {
+    return { ok: false, message: MODIFIED_SINCE_READ_MESSAGE };
+  }
+  return { ok: true };
+}
+
 // src/capabilities/files/read.ts
 var GUTTER_WIDTH = 6;
 var DESCRIPTION = [
@@ -5205,6 +5256,7 @@ var readTool = defineTool({
       const detail = err instanceof Error ? err.message : String(err);
       return failure(`Could not read ${path2}: ${detail}`);
     }
+    await recordReadState(ctx, path2, getReadStateHandle(ctx));
     const allLines = toLines(text);
     const totalLines = allLines.length;
     if (totalLines === 0) {
@@ -5312,11 +5364,19 @@ var writeTool = defineTool({
   async run(input, ctx) {
     const path2 = readPath(input?.path);
     const content = readContent(input?.content);
+    const handle = getReadStateHandle(ctx);
+    if (handle && await ctx.fs.exists(path2)) {
+      const gate = await enforceReadGate(ctx, path2, handle);
+      if (!gate.ok) {
+        return asText(gate.message, true);
+      }
+    }
     const folder = parentDir(path2);
     if (folder.length > 0) {
       await ctx.fs.mkdir(folder, { recursive: true });
     }
     await ctx.fs.writeFile(path2, content, "utf8");
+    await recordReadState(ctx, path2, handle);
     const bytes = Buffer.byteLength(content, "utf8");
     const unit = bytes === 1 ? "byte" : "bytes";
     return asText(`Saved ${bytes} ${unit} to ${path2}.`);
@@ -5606,6 +5666,11 @@ async function runEdit(input, ctx) {
   if (!info.isFile) {
     return failure2(`${path2} is not a regular file, so it cannot be edited.`);
   }
+  const handle = getReadStateHandle(ctx);
+  const gate = await enforceReadGate(ctx, path2, handle);
+  if (!gate.ok) {
+    return failure2(gate.message);
+  }
   const before = await ctx.fs.readFile(path2, "utf8");
   const literalHits = countLiteral(before, oldText);
   if (literalHits > 0) {
@@ -5619,6 +5684,7 @@ async function runEdit(input, ctx) {
       return failure2(`The replacement left ${path2} unchanged.`);
     }
     await ctx.fs.writeFile(path2, after2, "utf8");
+    await recordReadState(ctx, path2, handle);
     return success(path2, before, after2, replaceAll ? literalHits : 1);
   }
   const spans = findFuzzySpans(before, oldText);
@@ -5642,6 +5708,7 @@ async function runEdit(input, ctx) {
     return failure2(`The fuzzy replacement left ${path2} unchanged.`);
   }
   await ctx.fs.writeFile(path2, after, "utf8");
+  await recordReadState(ctx, path2, handle);
   return success(path2, before, after, targets.length);
 }
 var editTool = defineTool({
@@ -8461,6 +8528,34 @@ var useInput = ink.useInput;
 // src/react-ink/theme-adapter.ts
 import chalk from "chalk";
 import stripAnsi from "strip-ansi";
+var DEFAULT_ROLE_KEYS = {
+  codeInline: "codeInline",
+  heading: "heading",
+  blockquoteBar: "blockquoteBar",
+  diffAddedBg: "diffAddedBg",
+  diffRemovedBg: "diffRemovedBg",
+  diffAddedText: "diffAddedText",
+  diffRemovedText: "diffRemovedText",
+  synKeyword: "synKeyword",
+  synString: "synString",
+  synNumber: "synNumber",
+  synComment: "synComment",
+  synType: "synType"
+};
+var ROLE_FALLBACK_KEYS = {
+  codeInline: "accent",
+  heading: "accent",
+  blockquoteBar: "muted",
+  diffAddedBg: "success",
+  diffRemovedBg: "error",
+  diffAddedText: "success",
+  diffRemovedText: "error",
+  synKeyword: "accent",
+  synString: "success",
+  synNumber: "warning",
+  synComment: "muted",
+  synType: "info"
+};
 function applyForeground(color, text) {
   if (!color) return text;
   try {
@@ -8487,15 +8582,27 @@ function applyBackground(background, foreground, text) {
     return applyForeground(foreground, text);
   }
 }
-function createThemeAdapter(themeName, colors) {
+function createThemeAdapter(themeName, colors, roleOverrides) {
   const fallback = colors.text ?? "#e5e5e7";
+  const roles = { ...DEFAULT_ROLE_KEYS, ...roleOverrides };
+  const resolveRoleColor = (role) => resolveColorToken(
+    colors[roles[role]],
+    resolveColorToken(colors[ROLE_FALLBACK_KEYS[role]], fallback)
+  );
   return {
     name: themeName,
     colors,
+    roles,
     color: (key, text) => applyForeground(resolveColorToken(colors[key], fallback), text),
     background: (key, text, textKey = "text") => applyBackground(resolveColorToken(colors[key]), resolveColorToken(colors[textKey], fallback), ` ${stripAnsi(text)} `),
     dim: (text) => applyForeground(resolveColorToken(colors.dim, "#666666"), text),
-    muted: (text) => applyForeground(resolveColorToken(colors.muted, "#808080"), text)
+    muted: (text) => applyForeground(resolveColorToken(colors.muted, "#808080"), text),
+    role: (role, text) => applyForeground(resolveRoleColor(role), text),
+    roleBackground: (role, text, foregroundRole) => applyBackground(
+      resolveRoleColor(role),
+      foregroundRole ? resolveRoleColor(foregroundRole) : void 0,
+      text
+    )
   };
 }
 
@@ -8880,8 +8987,1120 @@ function parseSkillInvocation(content) {
   };
 }
 
+// src/react-ink/markdown/format-token.ts
+import chalk2 from "chalk";
+import { marked } from "marked";
+import stripAnsi3 from "strip-ansi";
+
+// src/ui/utils.ts
+import { eastAsianWidth } from "get-east-asian-width";
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var TextWidthCalculator = class {
+  getWidth(text) {
+    return visibleWidth(text);
+  }
+  clearCache() {
+    widthCache.clear();
+  }
+};
+var textWidthCalculator = new TextWidthCalculator();
+function looksLikeEmojiCandidate(segment) {
+  const cp = segment.codePointAt(0);
+  return cp >= 126976 && cp <= 130047 || // pictographs and emoji proper
+  cp >= 8960 && cp <= 9215 || // miscellaneous technical glyphs
+  cp >= 9728 && cp <= 10175 || // assorted symbols and dingbats
+  cp >= 11088 && cp <= 11093 || // a few star/circle characters
+  segment.includes("\uFE0F") || // carries VS16, the emoji-presentation selector
+  segment.length > 2;
+}
+function createUnicodeRegex(vPattern, uFallback) {
+  try {
+    return new RegExp(vPattern, "v");
+  } catch {
+    return new RegExp(uFallback, "u");
+  }
+}
+var zeroWidthRegex = createUnicodeRegex(
+  "^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$",
+  "^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$"
+);
+var leadingNonPrintingRegex = createUnicodeRegex(
+  "^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+",
+  "^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+"
+);
+var rgiEmojiRegex = createUnicodeRegex("^\\p{RGI_Emoji}$", "^\\p{Extended_Pictographic}$");
+var AnsiStripper = {
+  strip(text) {
+    if (!text.includes("\x1B")) {
+      return text;
+    }
+    let cleaned = text;
+    cleaned = cleaned.replace(/\x1b\[[0-9;]*[mGKHJ]/g, "");
+    cleaned = cleaned.replace(/\x1b\]8;;[^\x07]*\x07/g, "");
+    cleaned = cleaned.replace(/\x1b_[^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
+    return cleaned;
+  }
+};
+var WIDTH_CACHE_SIZE = 512;
+var widthCache = /* @__PURE__ */ new Map();
+function measureClusterWidth(segment) {
+  if (zeroWidthRegex.test(segment)) {
+    return 0;
+  }
+  if (looksLikeEmojiCandidate(segment) && rgiEmojiRegex.test(segment)) {
+    return 2;
+  }
+  const base = segment.replace(leadingNonPrintingRegex, "");
+  const cp = base.codePointAt(0);
+  if (cp === void 0) {
+    return 0;
+  }
+  let width = eastAsianWidth(cp);
+  if (segment.length > 1) {
+    for (const char of segment.slice(1)) {
+      const c = char.codePointAt(0);
+      if (c >= 65280 && c <= 65519) {
+        width += eastAsianWidth(c);
+      }
+    }
+  }
+  return width;
+}
+function visibleWidth(str2) {
+  if (str2.length === 0) {
+    return 0;
+  }
+  let isPureAscii = true;
+  for (let i = 0; i < str2.length; i++) {
+    const code = str2.charCodeAt(i);
+    if (code < 32 || code > 126) {
+      isPureAscii = false;
+      break;
+    }
+  }
+  if (isPureAscii) {
+    return str2.length;
+  }
+  const cached = widthCache.get(str2);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let clean = str2;
+  if (str2.includes("	")) {
+    clean = clean.replace(/\t/g, "   ");
+  }
+  clean = AnsiStripper.strip(clean);
+  let width = 0;
+  for (const { segment } of segmenter.segment(clean)) {
+    width += measureClusterWidth(segment);
+  }
+  if (widthCache.size >= WIDTH_CACHE_SIZE) {
+    const firstKey = widthCache.keys().next().value;
+    if (firstKey !== void 0) {
+      widthCache.delete(firstKey);
+    }
+  }
+  widthCache.set(str2, width);
+  return width;
+}
+function extractAnsiCode(str2, pos) {
+  if (pos >= str2.length || str2[pos] !== "\x1B") return null;
+  const next = str2[pos + 1];
+  if (next === "[") {
+    let j = pos + 2;
+    while (j < str2.length && !/[mGKHJ]/.test(str2[j])) j++;
+    if (j < str2.length) return { code: str2.substring(pos, j + 1), length: j + 1 - pos };
+    return null;
+  }
+  if (next === "]") {
+    let j = pos + 2;
+    while (j < str2.length) {
+      if (str2[j] === "\x07") return { code: str2.substring(pos, j + 1), length: j + 1 - pos };
+      if (str2[j] === "\x1B" && str2[j + 1] === "\\") return { code: str2.substring(pos, j + 2), length: j + 2 - pos };
+      j++;
+    }
+    return null;
+  }
+  if (next === "_") {
+    let j = pos + 2;
+    while (j < str2.length) {
+      if (str2[j] === "\x07") return { code: str2.substring(pos, j + 1), length: j + 1 - pos };
+      if (str2[j] === "\x1B" && str2[j + 1] === "\\") return { code: str2.substring(pos, j + 2), length: j + 2 - pos };
+      j++;
+    }
+    return null;
+  }
+  return null;
+}
+var AnsiStateTracker = class {
+  // Each attribute is kept on its own flag, which lets us clear them one at a time.
+  _bold = false;
+  _dim = false;
+  italic = false;
+  underline = false;
+  blink = false;
+  inverse = false;
+  hidden = false;
+  strikethrough = false;
+  _colors = { fg: null, bg: null };
+  process(ansiCode) {
+    if (!ansiCode.endsWith("m")) {
+      return;
+    }
+    const match = ansiCode.match(/\x1b\[([\d;]*)m/);
+    if (!match) return;
+    const params = match[1];
+    if (params === "" || params === "0") {
+      this.reset();
+      return;
+    }
+    const parts = params.split(";");
+    let i = 0;
+    while (i < parts.length) {
+      const code = Number.parseInt(parts[i] ?? "", 10);
+      if (Number.isNaN(code)) {
+        i++;
+        continue;
+      }
+      const consumed = this.tryConsumeColorCode(parts, i, code);
+      if (consumed > 0) {
+        i += consumed;
+        continue;
+      }
+      this.applyStandardCode(code);
+      i++;
+    }
+  }
+  tryConsumeColorCode(parts, index, code) {
+    if (code !== 38 && code !== 48) {
+      return 0;
+    }
+    if (parts[index + 1] === "5" && parts[index + 2] !== void 0) {
+      const colorCode = `${parts[index]};${parts[index + 1]};${parts[index + 2]}`;
+      if (code === 38) {
+        this._colors.fg = colorCode;
+      } else {
+        this._colors.bg = colorCode;
+      }
+      return 3;
+    }
+    if (parts[index + 1] === "2" && parts[index + 4] !== void 0) {
+      const colorCode = `${parts[index]};${parts[index + 1]};${parts[index + 2]};${parts[index + 3]};${parts[index + 4]}`;
+      if (code === 38) {
+        this._colors.fg = colorCode;
+      } else {
+        this._colors.bg = colorCode;
+      }
+      return 5;
+    }
+    return 0;
+  }
+  applyStandardCode(code) {
+    switch (code) {
+      case 0:
+        this.reset();
+        return;
+      case 1:
+        this._bold = true;
+        return;
+      case 2:
+        this._dim = true;
+        return;
+      case 3:
+        this.italic = true;
+        return;
+      case 4:
+        this.underline = true;
+        return;
+      case 5:
+        this.blink = true;
+        return;
+      case 7:
+        this.inverse = true;
+        return;
+      case 8:
+        this.hidden = true;
+        return;
+      case 9:
+        this.strikethrough = true;
+        return;
+      case 21:
+        this._bold = false;
+        return;
+      case 22:
+        this._bold = false;
+        this._dim = false;
+        return;
+      case 23:
+        this.italic = false;
+        return;
+      case 24:
+        this.underline = false;
+        return;
+      case 25:
+        this.blink = false;
+        return;
+      case 27:
+        this.inverse = false;
+        return;
+      case 28:
+        this.hidden = false;
+        return;
+      case 29:
+        this.strikethrough = false;
+        return;
+      case 39:
+        this._colors.fg = null;
+        return;
+      case 49:
+        this._colors.bg = null;
+        return;
+      default:
+        if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+          this._colors.fg = String(code);
+          return;
+        }
+        if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+          this._colors.bg = String(code);
+        }
+    }
+  }
+  reset() {
+    this._bold = false;
+    this._dim = false;
+    this.italic = false;
+    this.underline = false;
+    this.blink = false;
+    this.inverse = false;
+    this.hidden = false;
+    this.strikethrough = false;
+    this._colors.fg = null;
+    this._colors.bg = null;
+  }
+  /** Wipe all tracked state so the instance can be reused. */
+  clear() {
+    this.reset();
+  }
+  getActiveCodes() {
+    const codes = [];
+    if (this._bold) codes.push("1");
+    if (this._dim) codes.push("2");
+    if (this.italic) codes.push("3");
+    if (this.underline) codes.push("4");
+    if (this.blink) codes.push("5");
+    if (this.inverse) codes.push("7");
+    if (this.hidden) codes.push("8");
+    if (this.strikethrough) codes.push("9");
+    if (this._colors.fg) codes.push(this._colors.fg);
+    if (this._colors.bg) codes.push(this._colors.bg);
+    if (codes.length === 0) return "";
+    return `\x1B[${codes.join(";")}m`;
+  }
+  hasActiveCodes() {
+    return this._bold || this._dim || this.italic || this.underline || this.blink || this.inverse || this.hidden || this.strikethrough || this._colors.fg !== null || this._colors.bg !== null;
+  }
+  /**
+   * Produce the escape code needed to switch off any attribute that would
+   * otherwise smear into the padding at the end of a line. In practice that
+   * is just underline. Yields an empty string when nothing needs disabling.
+   */
+  getLineEndReset() {
+    if (this.underline) {
+      return "\x1B[24m";
+    }
+    return "";
+  }
+};
+function mergeTextIntoTracker(text, tracker) {
+  let i = 0;
+  while (i < text.length) {
+    const ansiResult = extractAnsiCode(text, i);
+    if (ansiResult) {
+      tracker.process(ansiResult.code);
+      i += ansiResult.length;
+    } else {
+      i++;
+    }
+  }
+}
+function tokenizeTextWithAnsi(text) {
+  const tokens = [];
+  let current = "";
+  let pendingAnsi = "";
+  let inWhitespace = false;
+  let i = 0;
+  while (i < text.length) {
+    const ansiResult = extractAnsiCode(text, i);
+    if (ansiResult) {
+      pendingAnsi += ansiResult.code;
+      i += ansiResult.length;
+      continue;
+    }
+    const char = text[i];
+    const charIsSpace = char === " ";
+    if (charIsSpace !== inWhitespace && current) {
+      tokens.push(current);
+      current = "";
+    }
+    if (pendingAnsi) {
+      current += pendingAnsi;
+      pendingAnsi = "";
+    }
+    inWhitespace = charIsSpace;
+    current += char;
+    i++;
+  }
+  if (pendingAnsi) {
+    current += pendingAnsi;
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+var TextWrapper = class {
+  wrap(text, width) {
+    return wrapTextWithAnsi(text, width);
+  }
+};
+var textWrapper = new TextWrapper();
+var TokenWrapEngine = {
+  wrap(tokens, width, tracker) {
+    const wrapped = [];
+    let currentLine = "";
+    let currentVisibleLength = 0;
+    for (const token of tokens) {
+      const tokenVisibleLength = visibleWidth(token);
+      const isWhitespace = token.trim() === "";
+      if (tokenVisibleLength > width && !isWhitespace) {
+        if (currentLine) {
+          const lineEndReset = tracker.getLineEndReset();
+          if (lineEndReset) {
+            currentLine += lineEndReset;
+          }
+          wrapped.push(currentLine);
+          currentLine = "";
+          currentVisibleLength = 0;
+        }
+        const broken = splitLongToken(token, width, tracker);
+        wrapped.push(...broken.slice(0, -1));
+        currentLine = broken[broken.length - 1];
+        currentVisibleLength = visibleWidth(currentLine);
+        continue;
+      }
+      const totalNeeded = currentVisibleLength + tokenVisibleLength;
+      if (totalNeeded > width && currentVisibleLength > 0) {
+        let lineToWrap = currentLine.trimEnd();
+        const lineEndReset = tracker.getLineEndReset();
+        if (lineEndReset) {
+          lineToWrap += lineEndReset;
+        }
+        wrapped.push(lineToWrap);
+        if (isWhitespace) {
+          currentLine = tracker.getActiveCodes();
+          currentVisibleLength = 0;
+        } else {
+          currentLine = tracker.getActiveCodes() + token;
+          currentVisibleLength = tokenVisibleLength;
+        }
+      } else {
+        currentLine += token;
+        currentVisibleLength += tokenVisibleLength;
+      }
+      mergeTextIntoTracker(token, tracker);
+    }
+    return { wrapped, currentLine, currentVisibleLength };
+  }
+};
+function wrapTextWithAnsi(text, width) {
+  if (!text) {
+    return [""];
+  }
+  const inputLines = text.split("\n");
+  const result = [];
+  const tracker = new AnsiStateTracker();
+  for (const inputLine of inputLines) {
+    const prefix = result.length > 0 ? tracker.getActiveCodes() : "";
+    result.push(...wrapLinePreservingAnsi(prefix + inputLine, width));
+    mergeTextIntoTracker(inputLine, tracker);
+  }
+  return result.length > 0 ? result : [""];
+}
+function wrapLinePreservingAnsi(line, width) {
+  if (!line) {
+    return [""];
+  }
+  const visibleLength = visibleWidth(line);
+  if (visibleLength <= width) {
+    return [line];
+  }
+  const tracker = new AnsiStateTracker();
+  const tokens = tokenizeTextWithAnsi(line);
+  const { wrapped, currentLine } = TokenWrapEngine.wrap(tokens, width, tracker);
+  if (currentLine) {
+    wrapped.push(currentLine);
+  }
+  return wrapped.length > 0 ? wrapped.map((segmentLine) => segmentLine.trimEnd()) : [""];
+}
+function splitLongToken(word, width, tracker) {
+  const lines = [];
+  let currentLine = tracker.getActiveCodes();
+  let currentWidth = 0;
+  let i = 0;
+  const segments = [];
+  while (i < word.length) {
+    const ansiResult = extractAnsiCode(word, i);
+    if (ansiResult) {
+      segments.push({ type: "ansi", value: ansiResult.code });
+      i += ansiResult.length;
+    } else {
+      let end = i;
+      while (end < word.length) {
+        const nextAnsi = extractAnsiCode(word, end);
+        if (nextAnsi) break;
+        end++;
+      }
+      const textPortion = word.slice(i, end);
+      for (const seg of segmenter.segment(textPortion)) {
+        segments.push({ type: "grapheme", value: seg.segment });
+      }
+      i = end;
+    }
+  }
+  for (const seg of segments) {
+    if (seg.type === "ansi") {
+      currentLine += seg.value;
+      tracker.process(seg.value);
+      continue;
+    }
+    const grapheme = seg.value;
+    if (!grapheme) continue;
+    const clusterWidth = visibleWidth(grapheme);
+    if (currentWidth + clusterWidth > width) {
+      const lineEndReset = tracker.getLineEndReset();
+      if (lineEndReset) {
+        currentLine += lineEndReset;
+      }
+      lines.push(currentLine);
+      currentLine = tracker.getActiveCodes();
+      currentWidth = 0;
+    }
+    currentLine += grapheme;
+    currentWidth += clusterWidth;
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+var pooledStyleTracker = new AnsiStateTracker();
+
+// src/react-ink/markdown/format-token.ts
+var EOL = "\n";
+var BLOCKQUOTE_BAR = "\u2502";
+var markedConfigured = false;
+function configureMarked() {
+  if (markedConfigured) {
+    return;
+  }
+  markedConfigured = true;
+  marked.use({
+    tokenizer: {
+      del() {
+        return void 0;
+      }
+    }
+  });
+}
+var TOKEN_CACHE_MAX = 500;
+var tokenCache = /* @__PURE__ */ new Map();
+var MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
+function hasMarkdownSyntax(text) {
+  return MD_SYNTAX_RE.test(text.length > 500 ? text.slice(0, 500) : text);
+}
+function hashContent(content) {
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36) + ":" + content.length.toString(36);
+}
+function cachedLexer(content) {
+  configureMarked();
+  if (!hasMarkdownSyntax(content)) {
+    return [
+      {
+        type: "paragraph",
+        raw: content,
+        text: content,
+        tokens: [{ type: "text", raw: content, text: content }]
+      }
+    ];
+  }
+  const key = hashContent(content);
+  const hit = tokenCache.get(key);
+  if (hit) {
+    tokenCache.delete(key);
+    tokenCache.set(key, hit);
+    return hit;
+  }
+  const tokens = marked.lexer(content);
+  if (tokenCache.size >= TOKEN_CACHE_MAX) {
+    const first = tokenCache.keys().next().value;
+    if (first !== void 0) {
+      tokenCache.delete(first);
+    }
+  }
+  tokenCache.set(key, tokens);
+  return tokens;
+}
+function formatToken(token, theme, highlight = null, listDepth = 0, orderedListNumber = null, parent = null) {
+  switch (token.type) {
+    case "blockquote": {
+      const inner = (token.tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("");
+      const bar = theme.dim(BLOCKQUOTE_BAR);
+      return inner.split(EOL).map((line) => stripAnsi3(line).trim() ? `${bar} ${chalk2.italic(line)}` : line).join(EOL);
+    }
+    case "code": {
+      const codeToken = token;
+      if (!highlight) {
+        return codeToken.text + EOL;
+      }
+      let language = "plaintext";
+      if (codeToken.lang && highlight.supportsLanguage(codeToken.lang)) {
+        language = codeToken.lang;
+      }
+      return highlight.highlight(codeToken.text, { language }) + EOL;
+    }
+    case "codespan":
+      return theme.role("codeInline", token.text);
+    case "em":
+      return chalk2.italic(
+        (token.tokens ?? []).map((child) => formatToken(child, theme, highlight, 0, null, parent)).join("")
+      );
+    case "strong":
+      return chalk2.bold(
+        (token.tokens ?? []).map((child) => formatToken(child, theme, highlight, 0, null, parent)).join("")
+      );
+    case "heading": {
+      const headingToken = token;
+      const inner = (headingToken.tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("");
+      const colored = theme.role("heading", inner);
+      if (headingToken.depth === 1) {
+        return chalk2.bold.italic.underline(colored) + EOL + EOL;
+      }
+      return chalk2.bold(colored) + EOL + EOL;
+    }
+    case "hr":
+      return "---";
+    case "image":
+      return token.href;
+    case "link": {
+      const linkToken = token;
+      if (linkToken.href.startsWith("mailto:")) {
+        return linkToken.href.replace(/^mailto:/, "");
+      }
+      const linkText = (linkToken.tokens ?? []).map((child) => formatToken(child, theme, highlight, 0, null, linkToken)).join("");
+      const plainLinkText = stripAnsi3(linkText);
+      const display = plainLinkText && plainLinkText !== linkToken.href ? linkText : linkToken.href;
+      return `\x1B]8;;${linkToken.href}\x07${display}\x1B]8;;\x07`;
+    }
+    case "list": {
+      const listToken = token;
+      const start = typeof listToken.start === "number" ? listToken.start : Number(listToken.start) || 1;
+      return listToken.items.map(
+        (item, index) => formatToken(
+          item,
+          theme,
+          highlight,
+          listDepth,
+          listToken.ordered ? start + index : null,
+          listToken
+        )
+      ).join("");
+    }
+    case "list_item":
+      return (token.tokens ?? []).map(
+        (child) => `${"  ".repeat(listDepth)}${formatToken(child, theme, highlight, listDepth + 1, orderedListNumber, token)}`
+      ).join("");
+    case "paragraph":
+      return (token.tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("") + EOL;
+    case "space":
+    case "br":
+      return EOL;
+    case "text": {
+      const textToken = token;
+      if (parent?.type === "link") {
+        return textToken.text;
+      }
+      if (parent?.type === "list_item") {
+        const marker = orderedListNumber === null ? "-" : `${getListNumber(listDepth, orderedListNumber)}.`;
+        const body = textToken.tokens ? textToken.tokens.map((child) => formatToken(child, theme, highlight, listDepth, orderedListNumber, token)).join("") : textToken.text;
+        return `${marker} ${body}${EOL}`;
+      }
+      return textToken.text;
+    }
+    case "escape":
+      return token.text;
+    case "table":
+    case "def":
+    case "del":
+    case "html":
+      return "";
+    default:
+      return "";
+  }
+}
+function numberToLetter(n) {
+  let result = "";
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(97 + n % 26) + result;
+    n = Math.floor(n / 26);
+  }
+  return result;
+}
+var ROMAN_VALUES = [
+  [1e3, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"]
+];
+function numberToRoman(n) {
+  let result = "";
+  for (const [value, numeral] of ROMAN_VALUES) {
+    while (n >= value) {
+      result += numeral;
+      n -= value;
+    }
+  }
+  return result;
+}
+function getListNumber(listDepth, orderedListNumber) {
+  switch (listDepth) {
+    case 0:
+    case 1:
+      return orderedListNumber.toString();
+    case 2:
+      return numberToLetter(orderedListNumber);
+    case 3:
+      return numberToRoman(orderedListNumber);
+    default:
+      return orderedListNumber.toString();
+  }
+}
+function padAligned(content, displayWidth, targetWidth, align) {
+  const padding = Math.max(0, targetWidth - displayWidth);
+  if (align === "center") {
+    const leftPad = Math.floor(padding / 2);
+    return " ".repeat(leftPad) + content + " ".repeat(padding - leftPad);
+  }
+  if (align === "right") {
+    return " ".repeat(padding) + content;
+  }
+  return content + " ".repeat(padding);
+}
+function stringWidth(text) {
+  return visibleWidth(text);
+}
+
+// src/react-ink/markdown/highlight.ts
+import { extname } from "node:path";
+import hljs from "highlight.js";
+function scopeToRole(scope) {
+  const head = scope.split(".")[0] ?? scope;
+  switch (head) {
+    case "keyword":
+    case "built_in":
+    case "literal":
+    case "operator":
+      return "synKeyword";
+    case "string":
+    case "regexp":
+    case "symbol":
+    case "char":
+    case "meta":
+      return "synString";
+    case "number":
+      return "synNumber";
+    case "comment":
+    case "quote":
+      return "synComment";
+    case "type":
+    case "class":
+    case "title":
+    case "tag":
+    case "name":
+    case "attr":
+    case "attribute":
+    case "selector":
+      return "synType";
+    default:
+      return null;
+  }
+}
+var HTML_ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#x27;": "'",
+  "&#39;": "'"
+};
+function decodeEntities2(text) {
+  return text.replace(/&(?:amp|lt|gt|quot|#x27|#39);/g, (match) => HTML_ENTITIES[match] ?? match);
+}
+function parseHljsHtml(html) {
+  const nodes = [];
+  const scopeStack = [];
+  const tagRe = /<span class="hljs-([^"]+)">|<\/span>/g;
+  let lastIndex = 0;
+  let match;
+  const pushText = (raw) => {
+    if (!raw) return;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+    const scope = currentScope ? currentScope.split(/\s+/)[0].replace(/_$/, "") : null;
+    nodes.push({ text: decodeEntities2(raw), scope });
+  };
+  while ((match = tagRe.exec(html)) !== null) {
+    pushText(html.slice(lastIndex, match.index));
+    lastIndex = tagRe.lastIndex;
+    if (match[0] === "</span>") {
+      scopeStack.pop();
+    } else if (match[1]) {
+      scopeStack.push(match[1]);
+    }
+  }
+  pushText(html.slice(lastIndex));
+  return nodes;
+}
+function createHighlighter(theme) {
+  return {
+    supportsLanguage: (language) => {
+      if (!language || language === "plaintext" || language === "text") {
+        return false;
+      }
+      try {
+        return hljs.getLanguage(language) !== void 0;
+      } catch {
+        return false;
+      }
+    },
+    highlight: (code, options) => {
+      const language = options.language;
+      if (!language || language === "plaintext" || language === "text") {
+        return code;
+      }
+      try {
+        if (hljs.getLanguage(language) === void 0) {
+          return code;
+        }
+        const { value } = hljs.highlight(code, { language, ignoreIllegals: true });
+        return parseHljsHtml(value).map((node) => {
+          const role = node.scope ? scopeToRole(node.scope) : null;
+          return role ? theme.role(role, node.text) : node.text;
+        }).join("");
+      } catch {
+        return code;
+      }
+    }
+  };
+}
+function highlightByPath(code, filePath, theme) {
+  const language = languageFromPath(filePath);
+  if (!language) {
+    return code;
+  }
+  const highlighter = createHighlighter(theme);
+  if (!highlighter.supportsLanguage(language)) {
+    return code;
+  }
+  return highlighter.highlight(code, { language });
+}
+var EXTENSION_LANGUAGES = {
+  ts: "typescript",
+  tsx: "typescript",
+  mts: "typescript",
+  cts: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  py: "python",
+  rb: "ruby",
+  rs: "rust",
+  go: "go",
+  java: "java",
+  kt: "kotlin",
+  c: "c",
+  h: "c",
+  cc: "cpp",
+  cpp: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  sh: "bash",
+  bash: "bash",
+  zsh: "bash",
+  yml: "yaml",
+  yaml: "yaml",
+  json: "json",
+  md: "markdown",
+  html: "xml",
+  xml: "xml",
+  css: "css",
+  scss: "scss",
+  sql: "sql",
+  toml: "ini",
+  ini: "ini",
+  php: "php",
+  swift: "swift"
+};
+function languageFromPath(filePath) {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  if (!ext) {
+    return null;
+  }
+  const mapped = EXTENSION_LANGUAGES[ext];
+  if (mapped) {
+    return mapped;
+  }
+  try {
+    return hljs.getLanguage(ext) !== void 0 ? ext : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/react-ink/markdown/MarkdownTable.tsx
+import chalk3 from "chalk";
+import stripAnsi4 from "strip-ansi";
+var MIN_COLUMN_WIDTH = 3;
+var COLUMN_GAP = 2;
+function MarkdownTable({ token, theme, highlight = null }) {
+  const formatCell = (tokens) => (tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("");
+  const displayWidth = (tokens) => stringWidth(stripAnsi4(formatCell(tokens)));
+  const columnCount = token.header.length;
+  const columnWidths = token.header.map((header, index) => {
+    let max = displayWidth(header.tokens);
+    for (const row of token.rows) {
+      max = Math.max(max, displayWidth(row[index]?.tokens));
+    }
+    return Math.max(max, MIN_COLUMN_WIDTH);
+  });
+  const renderRow2 = (cells, key, bold) => /* @__PURE__ */ jsx(Box, { flexDirection: "row", children: columnWidths.map((width, index) => {
+    const cell = cells[index];
+    const content = formatCell(cell?.tokens);
+    const visible = stringWidth(stripAnsi4(content));
+    const align = token.align?.[index];
+    const padded = padAligned(content, visible, width, align ?? "left");
+    const styled = bold ? chalk3.bold(padded) : padded;
+    const gap = index < columnCount - 1 ? " ".repeat(COLUMN_GAP) : "";
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      styled,
+      gap
+    ] }, index);
+  }) }, key);
+  const separator = /* @__PURE__ */ jsx(Box, { flexDirection: "row", children: columnWidths.map((width, index) => {
+    const gap = index < columnCount - 1 ? " ".repeat(COLUMN_GAP) : "";
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      theme.dim("-".repeat(width)),
+      gap
+    ] }, index);
+  }) });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    renderRow2(token.header, "header", true),
+    separator,
+    token.rows.map((row, rowIndex) => renderRow2(row, `row-${rowIndex}`, false))
+  ] });
+}
+
+// src/react-ink/markdown/Markdown.tsx
+function stripPromptXMLTags(text) {
+  return text.replace(/<\/?(?:system-reminder|prompt|context)[^>]*>/g, "");
+}
+function Markdown({ children, theme, highlightCode = true, dim = false }) {
+  const highlight = useMemo(
+    () => highlightCode ? createHighlighter(theme) : null,
+    [highlightCode, theme]
+  );
+  const elements = useMemo(() => {
+    configureMarked();
+    const tokens = cachedLexer(stripPromptXMLTags(children));
+    const out = [];
+    let buffer = "";
+    const flush = () => {
+      if (buffer) {
+        const text = buffer.replace(/\n+$/, "");
+        if (text) {
+          out.push(
+            /* @__PURE__ */ jsx(Text, { children: dim ? theme.dim(text) : text }, out.length)
+          );
+        }
+        buffer = "";
+      }
+    };
+    for (const token of tokens) {
+      if (token.type === "table") {
+        flush();
+        out.push(
+          /* @__PURE__ */ jsx(
+            MarkdownTable,
+            {
+              token,
+              theme,
+              highlight
+            },
+            out.length
+          )
+        );
+      } else {
+        buffer += formatToken(token, theme, highlight);
+      }
+    }
+    flush();
+    return out;
+  }, [children, dim, highlight, theme]);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: elements });
+}
+
 // src/react-ink/utils/tool-display.ts
 import { homedir as homedir2 } from "node:os";
+
+// src/react-ink/diff/structured.ts
+import { structuredPatch } from "diff";
+
+// src/react-ink/diff/word-diff.ts
+import { diffWordsWithSpace } from "diff";
+var CHANGE_THRESHOLD = 0.4;
+function wordDiffLine(oldLine, newLine, side) {
+  const lineText = side === "removed" ? oldLine : newLine;
+  if (oldLine.length === 0 || newLine.length === 0) {
+    return [{ text: lineText, changed: true }];
+  }
+  let changes;
+  try {
+    changes = diffWordsWithSpace(oldLine, newLine);
+  } catch {
+    return [{ text: lineText, changed: true }];
+  }
+  let changedChars = 0;
+  let totalChars = 0;
+  for (const change of changes) {
+    totalChars += change.value.length;
+    if (change.added || change.removed) {
+      changedChars += change.value.length;
+    }
+  }
+  const fraction = totalChars === 0 ? 0 : changedChars / totalChars;
+  if (fraction > CHANGE_THRESHOLD) {
+    return [{ text: lineText, changed: true }];
+  }
+  const spans = [];
+  for (const change of changes) {
+    const belongs = side === "removed" ? !change.added : !change.removed;
+    if (!belongs) {
+      continue;
+    }
+    spans.push({ text: change.value, changed: Boolean(change.added || change.removed) });
+  }
+  return spans.length > 0 ? spans : [{ text: lineText, changed: false }];
+}
+
+// src/react-ink/diff/structured.ts
+var CONTEXT_LINES = 3;
+function buildStructuredDiff(oldStr, newStr, filePath = "") {
+  if (oldStr === newStr) {
+    return null;
+  }
+  let patch;
+  try {
+    patch = structuredPatch(filePath, filePath, oldStr, newStr, "", "", { context: CONTEXT_LINES });
+  } catch {
+    return null;
+  }
+  const hunks = [];
+  let addedCount = 0;
+  let removedCount = 0;
+  for (const hunk of patch.hunks) {
+    const lines = classifyHunkLines(hunk);
+    for (const line of lines) {
+      if (line.kind === "added") addedCount += 1;
+      else if (line.kind === "removed") removedCount += 1;
+    }
+    if (lines.length > 0) {
+      hunks.push({ oldStart: hunk.oldStart, newStart: hunk.newStart, lines });
+    }
+  }
+  if (hunks.length === 0) {
+    return null;
+  }
+  return { hunks, addedCount, removedCount };
+}
+function classifyHunkLines(hunk) {
+  const out = [];
+  let oldNum = hunk.oldStart;
+  let newNum = hunk.newStart;
+  const rawLines = hunk.lines.filter((line) => !line.startsWith("\\"));
+  let removedRun = [];
+  let removedRunStart = -1;
+  const flushPairing = (addedRun2) => {
+    const pairs = Math.min(removedRun.length, addedRun2.length);
+    for (let i = 0; i < pairs; i += 1) {
+      const removed = removedRun[i];
+      const added = addedRun2[i];
+      removed.spans = wordDiffLine(removed.text, added.text, "removed");
+      added.spans = wordDiffLine(removed.text, added.text, "added");
+    }
+    removedRun = [];
+    removedRunStart = -1;
+  };
+  let addedRun = [];
+  for (const raw of rawLines) {
+    const marker = raw[0];
+    const text = raw.slice(1);
+    if (marker === "-") {
+      if (addedRun.length > 0) {
+        addedRun = [];
+      }
+      const line = { kind: "removed", oldLine: oldNum, text };
+      out.push(line);
+      if (removedRunStart === -1) removedRunStart = out.length - 1;
+      removedRun.push(line);
+      oldNum += 1;
+    } else if (marker === "+") {
+      const line = { kind: "added", newLine: newNum, text };
+      out.push(line);
+      addedRun.push(line);
+      newNum += 1;
+    } else {
+      if (removedRun.length > 0 && addedRun.length > 0) {
+        flushPairing(addedRun);
+      }
+      removedRun = [];
+      removedRunStart = -1;
+      addedRun = [];
+      out.push({ kind: "context", oldLine: oldNum, newLine: newNum, text });
+      oldNum += 1;
+      newNum += 1;
+    }
+  }
+  if (removedRun.length > 0 && addedRun.length > 0) {
+    flushPairing(addedRun);
+  }
+  return out;
+}
+
+// src/react-ink/utils/tool-display.ts
 function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -8964,6 +10183,12 @@ function clipBody(value, maxLines = 8, maxChars = 1400) {
   }
   return previewMultiline(value, { maxLines, maxChars });
 }
+function highlightedBody(body, filePath, theme) {
+  if (!body || !theme || !filePath || languageFromPath(filePath) === null) {
+    return { body };
+  }
+  return { body: highlightByPath(body, filePath, theme), preformatted: true };
+}
 function extractDetails(value) {
   return asRecord2(asRecord2(value)?.details);
 }
@@ -9030,7 +10255,7 @@ function fallbackBody(output, fallbackOutputText, showImages = false) {
   return clipBody(fallbackOutputText);
 }
 function describeToolSource(source) {
-  const { args, fallbackArgsText, fallbackOutputText, output, showImages = false, toolName } = source;
+  const { args, fallbackArgsText, fallbackOutputText, output, showImages = false, theme, toolName } = source;
   const argsRecord = asRecord2(args);
   const details = extractDetails(output);
   const outputText = toolText(output, showImages);
@@ -9048,10 +10273,12 @@ function describeToolSource(source) {
         summary += `:${start}${end ? `-${end}` : ""}`;
       }
       const responseSummary = containsImage(output) ? firstMeaningfulLine(outputText) ?? "Read image" : /unchanged/i.test(outputText) ? "Unchanged since last read" : countMeaningfulLines(outputText) > 0 ? `Read ${countMeaningfulLines(outputText)} ${countMeaningfulLines(outputText) === 1 ? "line" : "lines"}` : "Read file";
+      const readBody = hasResult && !containsImage(output) ? highlightedBody(clipBody(outputText, 10, 1800), rawPath, theme) : { body: hasResult ? clipBody(outputText, 10, 1800) : void 0 };
       return {
         title,
         summary: hasResult ? responseSummary : summary,
-        body: hasResult ? clipBody(outputText, 10, 1800) : void 0,
+        body: readBody.body,
+        preformatted: readBody.preformatted,
         emptyText: "Reading file..."
       };
     }
@@ -9059,10 +10286,14 @@ function describeToolSource(source) {
       const rawPath = asString(argsRecord?.file_path) ?? asString(argsRecord?.path) ?? "";
       const content = asString(argsRecord?.content);
       const responseSummary = firstMeaningfulLine(outputText) ?? "Wrote file";
+      const writeDiff = !hasResult && content !== void 0 && content.length > 0 ? buildStructuredDiff("", content, rawPath) ?? void 0 : void 0;
+      const writeBody = hasResult ? { body: clipBody(outputText, 8, 1500) } : highlightedBody(clipBody(content, 8, 1500), rawPath, theme);
       return {
         title,
         summary: hasResult ? responseSummary : rawPath ? shortenPath2(rawPath) : void 0,
-        body: hasResult ? clipBody(outputText, 8, 1500) : clipBody(content, 8, 1500),
+        body: writeDiff ? void 0 : writeBody.body,
+        preformatted: writeDiff ? void 0 : writeBody.preformatted,
+        diff: writeDiff,
         emptyText: "Preparing file write..."
       };
     }
@@ -9079,10 +10310,15 @@ function describeToolSource(source) {
         400
       ) : void 0;
       const responseSummary = firstMeaningfulLine(outputText) ?? "Applied edit";
+      const editDiff = oldText !== void 0 && newText !== void 0 ? buildStructuredDiff(oldText, newText, rawPath) ?? void 0 : void 0;
+      const editBody = hasResult ? highlightedBody(clipBody(outputText, 8, 1500), rawPath, theme) : { body: replacementPreview };
+      const editChangeSummary = editDiff ? `+${editDiff.addedCount} -${editDiff.removedCount}` : void 0;
       return {
         title,
-        summary: hasResult ? responseSummary : rawPath ? shortenPath2(rawPath) : void 0,
-        body: hasResult ? clipBody(outputText, 8, 1500) : replacementPreview,
+        summary: hasResult ? editChangeSummary ?? responseSummary : editChangeSummary ?? (rawPath ? shortenPath2(rawPath) : void 0),
+        body: editDiff ? void 0 : editBody.body,
+        preformatted: editDiff ? void 0 : editBody.preformatted,
+        diff: editDiff,
         emptyText: "Applying edit..."
       };
     }
@@ -9179,7 +10415,7 @@ function describeToolCall(toolCall) {
     args: toolCall.arguments
   });
 }
-function describeToolResult(message, showImages, args) {
+function describeToolResult(message, showImages, args, theme) {
   return describeToolSource({
     args,
     toolName: message.toolName,
@@ -9187,12 +10423,13 @@ function describeToolResult(message, showImages, args) {
       content: message.content,
       details: message.details
     },
-    showImages
+    showImages,
+    theme
   });
 }
 
 // src/react-ink/components/ToolEventBlock.tsx
-import stripAnsi3 from "strip-ansi";
+import stripAnsi5 from "strip-ansi";
 function statusMarker(status) {
   switch (status) {
     case "error":
@@ -9203,12 +10440,15 @@ function statusMarker(status) {
       return ">";
   }
 }
+function statusColorKey(status) {
+  return status === "error" ? "error" : "text";
+}
 function plainToolText(text) {
-  return stripAnsi3(text);
+  return stripAnsi5(text);
 }
 function splitVisibleLines(text) {
   return (text ?? "").split(/\r?\n/).map((line) => line.trimEnd()).filter((line, index, lines) => {
-    if (line.length > 0) {
+    if (stripAnsi5(line).length > 0) {
       return true;
     }
     return index !== 0 && index !== lines.length - 1;
@@ -9239,11 +10479,12 @@ function ToolEventBlock({
   indent = 0,
   marginBottom = 1,
   maxContentLines = 10,
+  preformatted = false,
   showSummaryInline = false,
   showTitle = true,
   status,
   summary,
-  theme: _theme,
+  theme,
   title
 }) {
   const normalizedSummary = summary?.trim();
@@ -9259,19 +10500,19 @@ function ToolEventBlock({
   const { visibleLines, hiddenLineCount } = clampContentLines(combinedLines, maxContentLines);
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom, marginLeft: indent, children: [
     showTitle ? /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(`${statusMarker(status)} `) }),
-      /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(title) }),
-      showSummaryInline && normalizedSummary ? /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(` (${normalizedSummary})`) }) : null
+      /* @__PURE__ */ jsx(Text, { children: theme.color(statusColorKey(status), plainToolText(`${statusMarker(status)} `)) }),
+      /* @__PURE__ */ jsx(Text, { children: theme.color(statusColorKey(status), plainToolText(title)) }),
+      showSummaryInline && normalizedSummary ? /* @__PURE__ */ jsx(Text, { children: theme.muted(plainToolText(` (${normalizedSummary})`)) }) : null
     ] }) : null,
     visibleLines.map((line, index) => /* @__PURE__ */ jsx(
       Box,
       {
         marginLeft: line.kind === "response" ? showTitle ? 2 : 0 : showTitle ? 4 : 2,
-        children: /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(line.text) })
+        children: preformatted ? /* @__PURE__ */ jsx(Text, { children: line.text }) : /* @__PURE__ */ jsx(Text, { children: theme.color("text", plainToolText(line.text)) })
       },
-      `${line.kind}:${index}:${line.text}`
+      `${line.kind}:${index}:${stripAnsi5(line.text)}`
     )),
-    hiddenLineCount > 0 ? /* @__PURE__ */ jsx(Box, { marginLeft: showTitle ? 4 : 2, children: /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(`... ${hiddenLineCount} more line(s)`) }) }) : null
+    hiddenLineCount > 0 ? /* @__PURE__ */ jsx(Box, { marginLeft: showTitle ? 4 : 2, children: /* @__PURE__ */ jsx(Text, { children: theme.muted(plainToolText(`... ${hiddenLineCount} more line(s)`)) }) }) : null
   ] });
 }
 
@@ -9294,17 +10535,100 @@ function ToolCallMessage({ theme, toolCall }) {
   );
 }
 
+// src/react-ink/diff/Diff.tsx
+import chalk4 from "chalk";
+function lineMarker(kind) {
+  switch (kind) {
+    case "added":
+      return "+";
+    case "removed":
+      return "-";
+    default:
+      return " ";
+  }
+}
+function gutterWidth(diff) {
+  let max = 1;
+  for (const hunk of diff.hunks) {
+    for (const line of hunk.lines) {
+      const num2 = line.kind === "removed" ? line.oldLine : line.newLine;
+      if (num2 !== void 0) {
+        max = Math.max(max, stringWidth(String(num2)));
+      }
+    }
+  }
+  return max;
+}
+function renderLineText(line, theme, bgRole, fgRole) {
+  const paintSpan = (text, changed) => {
+    const fg = theme.role(fgRole, text);
+    return changed ? chalk4.bold(fg) : fg;
+  };
+  let body;
+  if (line.spans && line.spans.length > 0) {
+    body = line.spans.map((span) => paintSpan(span.text, span.changed)).join("");
+  } else {
+    body = theme.role(fgRole, line.text);
+  }
+  return bgRole ? theme.roleBackground(bgRole, body) : body;
+}
+function Diff({ diff, theme, indent = 0, marginBottom = 0 }) {
+  const gutter = gutterWidth(diff);
+  const renderLine = (line, key) => {
+    const num2 = line.kind === "removed" ? line.oldLine : line.newLine;
+    const gutterText = (num2 !== void 0 ? String(num2) : "").padStart(gutter);
+    const marker = lineMarker(line.kind);
+    const bgRole = line.kind === "added" ? "diffAddedBg" : line.kind === "removed" ? "diffRemovedBg" : null;
+    const fgRole = line.kind === "added" ? "diffAddedText" : line.kind === "removed" ? "diffRemovedText" : "blockquoteBar";
+    const gutterStyled = theme.dim(`${gutterText} `);
+    const markerStyled = line.kind === "context" ? theme.dim(`${marker} `) : theme.role(fgRole, `${marker} `);
+    const text = renderLineText(line, theme, bgRole, fgRole);
+    return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { children: [
+      gutterStyled,
+      markerStyled,
+      text
+    ] }) }, key);
+  };
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginLeft: indent, marginBottom, children: diff.hunks.map((hunk, hunkIndex) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    hunkIndex > 0 ? /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { children: theme.dim("...") }) }) : null,
+    hunk.lines.map((line, lineIndex) => renderLine(line, `${hunkIndex}-${lineIndex}`))
+  ] }, `hunk-${hunkIndex}`)) });
+}
+
 // src/react-ink/components/messages/ToolResultBlock.tsx
 function ToolResultBlock({ expanded = false, message, nested = false, showImages, theme, toolCall }) {
-  const descriptor = describeToolResult(message, showImages, toolCall?.arguments);
+  const descriptor = describeToolResult(message, showImages, toolCall?.arguments, theme);
+  const indent = nested ? 4 : 2;
+  if (descriptor.diff) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [
+      /* @__PURE__ */ jsx(
+        ToolEventBlock,
+        {
+          detail: void 0,
+          emptyText: descriptor.emptyText,
+          indent,
+          marginBottom: 0,
+          maxContentLines: 0,
+          showSummaryInline: false,
+          showTitle: !nested,
+          status: message.isError ? "error" : "success",
+          summary: descriptor.summary,
+          theme,
+          title: descriptor.title
+        }
+      ),
+      /* @__PURE__ */ jsx(Diff, { diff: descriptor.diff, theme, indent: indent + 2 })
+    ] });
+  }
   return /* @__PURE__ */ jsx(
     ToolEventBlock,
     {
       detail: descriptor.body,
       emptyText: descriptor.emptyText,
-      indent: nested ? 4 : 2,
+      indent,
       marginBottom: 0,
       maxContentLines: expanded ? Number.MAX_SAFE_INTEGER : 10,
+      preformatted: descriptor.preformatted,
       showSummaryInline: false,
       showTitle: !nested,
       status: message.isError ? "error" : "success",
@@ -9329,7 +10653,7 @@ function AssistantMessageView({
   const matchedToolResultIds = /* @__PURE__ */ new Set();
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ jsx(Text, { children: theme.color("accent", `Assistant  ${message.provider}/${message.model}  ${formatMessageTimestamp(message.timestamp)}`) }),
-    parts.text ? /* @__PURE__ */ jsx(Text, { children: parts.text }) : null,
+    parts.text ? /* @__PURE__ */ jsx(Markdown, { theme, children: parts.text }) : null,
     parts.thinking.map((thinking, index) => /* @__PURE__ */ jsx(Text, { children: theme.muted(`[thinking] ${thinking}`) }, index)),
     parts.toolCalls.map((toolCall) => {
       const toolResult = toolResultsByCallId.get(toolCall.id);
@@ -9531,20 +10855,20 @@ function MessageList({
 }
 
 // src/react-ink/components/StatusLine.tsx
-function StatusLine({ snapshot, status, theme }) {
+function StatusLine({ snapshot, status, theme, showBusyText = true }) {
   let text = status?.text;
   let tone = status?.kind ?? "info";
   if (!text) {
-    if (snapshot.isCompacting) {
+    if (showBusyText && snapshot.isCompacting) {
       text = "Compacting conversation context...";
       tone = "busy";
-    } else if (snapshot.isBashRunning) {
+    } else if (showBusyText && snapshot.isBashRunning) {
       text = "Running bash command...";
       tone = "busy";
-    } else if (snapshot.pendingToolCallCount > 0 || snapshot.pendingMessageCount > 0) {
+    } else if (showBusyText && (snapshot.pendingToolCallCount > 0 || snapshot.pendingMessageCount > 0)) {
       text = "Agent working...";
       tone = "busy";
-    } else if (snapshot.isStreaming) {
+    } else if (showBusyText && snapshot.isStreaming) {
       text = "Agent working...";
       tone = "busy";
     } else if (snapshot.error) {