steward-cli 0.11.0 → 0.12.0

package/README.md

@@ -1,6 +1,6 @@
 # Steward
 
-[![Version](https://img.shields.io/badge/version-v0.11.0-D77757.svg)](https://github.com/sapirrior/steward/releases)
+[![Version](https://img.shields.io/badge/version-v0.12.0-D77757.svg)](https://github.com/sapirrior/steward/releases)
 [![npm](https://img.shields.io/npm/v/steward-cli.svg?color=373737)](https://www.npmjs.com/package/steward-cli)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Runtime](https://img.shields.io/badge/runtime-Bun-fbf0df.svg?logo=bun)](https://bun.sh)

package/dist/cli.js

@@ -44696,15 +44696,6 @@ function wrapVisualLineWithCursor(text, maxCols, targetCharOffset, hangingIndent
   }
   function emitCurrentLine() {
     const activeStyles = getActiveStyleCodes();
-    if (activeBg && currentWidth < maxCols) {
-      const remainingCols = maxCols - currentWidth;
-      currentTokens.push({
-        type: "char",
-        value: " ".repeat(remainingCols),
-        width: remainingCols
-      });
-      currentWidth = maxCols;
-    }
     let lineStr = currentTokens.map((t) => t.value).join("");
     if (activeStyles.length > 0 && !lineStr.endsWith("\x1B[0m")) {
       lineStr += "\x1B[0m";
@@ -52415,23 +52406,12 @@ function formatToolStatus(options) {
       const maxOutLen = Math.max(10, fullTermWidth - 6);
       const truncatedSummary = summaryText.length > maxOutLen ? `${summaryText.slice(0, maxOutLen - 1)}…` : summaryText;
       lines.push(`  ${source_default.dim("└ ")}${source_default.white(truncatedSummary)}`);
-      const diffDeleteBg = themeBgColor(theme.diffDeleteBG);
-      const diffAddBg = themeBgColor(theme.diffAddBG);
-      const rawDiffDelBg = theme.diffDeleteBG;
-      const rawDiffAddBg = theme.diffAddBG;
+      const maxContentWidth = Math.max(30, Math.min(fullTermWidth - 4, Math.floor(fullTermWidth * 0.85)));
       for (let i = 1;i < outputLines.length; i++) {
-        const line = outputLines[i] ?? "";
-        const plain = stripAnsi(line);
-        const isDelete = line.includes(rawDiffDelBg) || /\d+\s+-/.test(plain) || plain.startsWith("-");
-        const isAdd = line.includes(rawDiffAddBg) || /\d+\s+\+/.test(plain) || plain.startsWith("+");
-        if (isDelete || isAdd) {
-          const bgFn = isDelete ? diffDeleteBg : diffAddBg;
-          const visLen = 3 + stringWidth(plain);
-          const padLen = Math.max(0, fullTermWidth - visLen);
-          lines.push(bgFn(`   ${line}${" ".repeat(padLen)}`));
-        } else {
-          lines.push(`   ${line}`);
-        }
+        const rawLine = outputLines[i] ?? "";
+        const prefixed = `   ${rawLine}`;
+        const wrapped = wrapVisualLine(prefixed, maxContentWidth, "     ");
+        lines.push(...wrapped);
       }
     }
   }
@@ -71099,7 +71079,8 @@ var writeFileTool = {
   summarize: (args, result) => {
     const lines = result?.linesWritten ?? 0;
     const filePath = args.file_path;
-    const summary = `Wrote ${lines} line${lines === 1 ? "" : "s"} to ${filePath}`;
+    const isNew = result?.isNew ?? true;
+    const summary = isNew ? `Created ${filePath} (${lines} line${lines === 1 ? "" : "s"})` : `Wrote ${lines} line${lines === 1 ? "" : "s"} to ${filePath}`;
     const contentLines = args.content.split(/\r?\n/);
     if (contentLines.length === 0 || contentLines.length === 1 && !contentLines[0]) {
       return summary;
@@ -71107,7 +71088,7 @@ var writeFileTool = {
     const cap = 50;
     const shown = contentLines.slice(0, cap);
     const padWidth = String(contentLines.length).length;
-    const detail = shown.map((l, i) => `${String(i + 1).padStart(padWidth)}  ${l}`).join(`
+    const detail = shown.map((l, i) => `${source_default.dim(String(i + 1).padStart(padWidth))}  ${source_default.white(l)}`).join(`
 `);
     const overflow = contentLines.length > cap ? `
    … (${contentLines.length - cap} more lines)` : "";
@@ -71233,6 +71214,237 @@ import {
   writeSync as writeSync6
 } from "node:fs";
 import { dirname as dirname6, join as join8 } from "node:path";
+
+// src/utils/diff.ts
+function tokenizeLines(content) {
+  if (!content)
+    return [];
+  const tokens = [];
+  const regex = /([^\r\n]*)(\r?\n)?/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match.index === content.length)
+      break;
+    const text = match[1] ?? "";
+    const ending = match[2] ?? "";
+    tokens.push({ text, ending });
+    if (!ending && match.index + text.length === content.length)
+      break;
+  }
+  return tokens;
+}
+function tokenizeWords(text) {
+  if (!text)
+    return [];
+  const matches = text.match(/[\w]+|[^\w\s]+|\s+/g);
+  return matches ?? [text];
+}
+function myersDiff(oldArr, newArr, equals = (a, b) => a === b) {
+  const n = oldArr.length;
+  const m = newArr.length;
+  if (n === 0 && m === 0)
+    return [];
+  if (n === 0)
+    return newArr.map((newItem, i) => ({ kind: "insert", newItem, newIndex: i }));
+  if (m === 0)
+    return oldArr.map((oldItem, i) => ({ kind: "delete", oldItem, oldIndex: i }));
+  const max = n + m;
+  const v = { 1: 0 };
+  const trace = [];
+  for (let d = 0;d <= max; d++) {
+    trace.push({ ...v });
+    for (let k = -d;k <= d; k += 2) {
+      let x = k === -d || k !== d && (v[k - 1] ?? -1) < (v[k + 1] ?? -1) ? v[k + 1] ?? 0 : (v[k - 1] ?? 0) + 1;
+      let y = x - k;
+      while (x < n && y < m && equals(oldArr[x], newArr[y])) {
+        x++;
+        y++;
+      }
+      v[k] = x;
+      if (x >= n && y >= m) {
+        const ops = [];
+        let cx = n;
+        let cy = m;
+        for (let cd = d;cd > 0; cd--) {
+          const prevV = trace[cd];
+          const pk = cx - cy;
+          const prevK = pk === -cd || pk !== cd && (prevV[pk - 1] ?? -1) < (prevV[pk + 1] ?? -1) ? pk + 1 : pk - 1;
+          const prevX = prevV[prevK] ?? 0;
+          const prevY = prevX - prevK;
+          while (cx > prevX + (prevK === pk + 1 ? 0 : 1) && cy > prevY + (prevK === pk + 1 ? 1 : 0)) {
+            cx--;
+            cy--;
+            ops.push({
+              kind: "equal",
+              oldItem: oldArr[cx],
+              newItem: newArr[cy],
+              oldIndex: cx,
+              newIndex: cy
+            });
+          }
+          if (prevK === pk + 1) {
+            cy--;
+            ops.push({ kind: "insert", newItem: newArr[cy], newIndex: cy });
+          } else {
+            cx--;
+            ops.push({ kind: "delete", oldItem: oldArr[cx], oldIndex: cx });
+          }
+        }
+        while (cx > 0 && cy > 0) {
+          cx--;
+          cy--;
+          ops.push({
+            kind: "equal",
+            oldItem: oldArr[cx],
+            newItem: newArr[cy],
+            oldIndex: cx,
+            newIndex: cy
+          });
+        }
+        ops.reverse();
+        return ops;
+      }
+    }
+  }
+  return [];
+}
+function computeWordDiff(oldLine, newLine) {
+  const oldWords = tokenizeWords(oldLine);
+  const newWords = tokenizeWords(newLine);
+  const ops = myersDiff(oldWords, newWords);
+  const oldSpans = [];
+  const newSpans = [];
+  for (const op of ops) {
+    if (op.kind === "equal") {
+      const text = op.oldItem ?? "";
+      oldSpans.push({ text, kind: "equal" });
+      newSpans.push({ text, kind: "equal" });
+    } else if (op.kind === "delete") {
+      oldSpans.push({ text: op.oldItem ?? "", kind: "deletion" });
+    } else if (op.kind === "insert") {
+      newSpans.push({ text: op.newItem ?? "", kind: "addition" });
+    }
+  }
+  return { oldSpans, newSpans };
+}
+function buildUnifiedDiff(before, after, contextLines = 3) {
+  const oldTokens = tokenizeLines(before);
+  const newTokens = tokenizeLines(after);
+  if (before === after) {
+    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
+  }
+  const ops = myersDiff(oldTokens, newTokens, (a, b) => a.text === b.text && a.ending === b.ending);
+  const editIndices = ops.map((op, i) => op.kind !== "equal" ? i : -1).filter((i) => i !== -1);
+  if (editIndices.length === 0) {
+    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
+  }
+  const hunkRanges = [];
+  let currentRange = {
+    startIdx: Math.max(0, editIndices[0] - contextLines),
+    endIdx: Math.min(ops.length - 1, editIndices[0] + contextLines)
+  };
+  for (let i = 1;i < editIndices.length; i++) {
+    const editIdx = editIndices[i];
+    const opStart = Math.max(0, editIdx - contextLines);
+    const opEnd = Math.min(ops.length - 1, editIdx + contextLines);
+    if (opStart <= currentRange.endIdx) {
+      currentRange.endIdx = Math.max(currentRange.endIdx, opEnd);
+    } else {
+      hunkRanges.push(currentRange);
+      currentRange = { startIdx: opStart, endIdx: opEnd };
+    }
+  }
+  hunkRanges.push(currentRange);
+  const hunks = [];
+  for (const range of hunkRanges) {
+    const lines = [];
+    let oldCount = 0;
+    let newCount = 0;
+    let oldStart = null;
+    let newStart = null;
+    for (let i = range.startIdx;i <= range.endIdx; i++) {
+      const op = ops[i];
+      if (op.kind === "equal") {
+        const oIdx = op.oldIndex + 1;
+        const nIdx = op.newIndex + 1;
+        if (oldStart === null)
+          oldStart = oIdx;
+        if (newStart === null)
+          newStart = nIdx;
+        lines.push({
+          kind: "context",
+          text: op.oldItem.text,
+          ending: op.oldItem.ending,
+          oldLineNumber: oIdx,
+          newLineNumber: nIdx
+        });
+        oldCount++;
+        newCount++;
+      } else if (op.kind === "delete") {
+        const oIdx = op.oldIndex + 1;
+        if (oldStart === null)
+          oldStart = oIdx;
+        lines.push({
+          kind: "deletion",
+          text: op.oldItem.text,
+          ending: op.oldItem.ending,
+          oldLineNumber: oIdx
+        });
+        oldCount++;
+      } else if (op.kind === "insert") {
+        const nIdx = op.newIndex + 1;
+        if (newStart === null)
+          newStart = nIdx;
+        lines.push({
+          kind: "addition",
+          text: op.newItem.text,
+          ending: op.newItem.ending,
+          newLineNumber: nIdx
+        });
+        newCount++;
+      }
+    }
+    let l = 0;
+    while (l < lines.length) {
+      if (lines[l]?.kind === "deletion") {
+        const delStart = l;
+        while (l < lines.length && lines[l]?.kind === "deletion")
+          l++;
+        const delEnd = l;
+        const addStart = l;
+        while (l < lines.length && lines[l]?.kind === "addition")
+          l++;
+        const addEnd = l;
+        const delCount = delEnd - delStart;
+        const addCount = addEnd - addStart;
+        const pairCount = Math.min(delCount, addCount);
+        for (let p = 0;p < pairCount; p++) {
+          const delLine = lines[delStart + p];
+          const addLine = lines[addStart + p];
+          const { oldSpans, newSpans } = computeWordDiff(delLine.text, addLine.text);
+          delLine.spans = oldSpans;
+          addLine.spans = newSpans;
+        }
+      } else {
+        l++;
+      }
+    }
+    hunks.push({
+      oldStart: oldStart ?? (oldTokens.length === 0 ? 0 : 1),
+      oldCount,
+      newStart: newStart ?? (newTokens.length === 0 ? 0 : 1),
+      newCount,
+      lines
+    });
+  }
+  return {
+    hunks,
+    oldLineCount: oldTokens.length,
+    newLineCount: newTokens.length
+  };
+}
+
+// src/tools/edit-file/index.ts
 var editFileInputSchema = object({
   file_path: string2().describe("The path of the file to edit (relative to current working directory or absolute inside trusted workspace)."),
   old_string: string2().describe("The exact string to find and replace in the file."),
@@ -71260,27 +71472,54 @@ var editFileTool = {
     const added = result?.addedLines ?? 0;
     const removed = result?.removedLines ?? 0;
     const summary = `Added ${added} line${added === 1 ? "" : "s"}, removed ${removed} line${removed === 1 ? "" : "s"}`;
-    const oldLines = args.old_string.split(/\r?\n/);
-    const newLines = args.new_string.split(/\r?\n/);
     if (added === 0 && removed === 0)
       return summary;
-    const cap = 30;
-    const padWidth = String(Math.max(oldLines.length, newLines.length)).length;
+    const diff = buildUnifiedDiff(args.old_string, args.new_string, 2);
     const theme = getTheme();
     const deleteStyle = (str) => themeBgColor(theme.diffDeleteBG)(themeColor2(theme.diffDeleteFG)(str));
     const addStyle = (str) => themeBgColor(theme.diffAddBG)(themeColor2(theme.diffAddFG)(str));
-    const removedDetail = oldLines.slice(0, cap).map((l, i) => deleteStyle(`${String(i + 1).padStart(padWidth)} -${l}`)).join(`
-`);
-    const addedDetail = newLines.slice(0, cap).map((l, i) => addStyle(`${String(i + 1).padStart(padWidth)} +${l}`)).join(`
-`);
-    const overflowOld = oldLines.length > cap ? `
-   … (${oldLines.length - cap} more removed)` : "";
-    const overflowNew = newLines.length > cap ? `
-   … (${newLines.length - cap} more added)` : "";
-    const diffBlock = [removedDetail + overflowOld, addedDetail + overflowNew].filter(Boolean).join(`
-`);
-    return `${summary}
-${diffBlock}`;
+    const contextStyle = (str) => source_default.dim(str);
+    let maxLineNum = 1;
+    for (const hunk of diff.hunks) {
+      for (const line of hunk.lines) {
+        if (line.oldLineNumber)
+          maxLineNum = Math.max(maxLineNum, line.oldLineNumber);
+        if (line.newLineNumber)
+          maxLineNum = Math.max(maxLineNum, line.newLineNumber);
+      }
+    }
+    const padWidth = Math.max(1, String(maxLineNum).length);
+    const diffLines = [];
+    const cap = 30;
+    let count = 0;
+    let overflow = 0;
+    for (const hunk of diff.hunks) {
+      for (const line of hunk.lines) {
+        if (count >= cap) {
+          overflow++;
+          continue;
+        }
+        count++;
+        if (line.kind === "deletion") {
+          const numStr = String(line.oldLineNumber ?? "").padStart(padWidth, " ");
+          const body = line.spans ? "-" + line.spans.map((s) => s.kind === "deletion" ? source_default.bold(s.text) : s.text).join("") : `-${line.text}`;
+          diffLines.push(deleteStyle(`${numStr} ${body}`));
+        } else if (line.kind === "addition") {
+          const numStr = String(line.newLineNumber ?? "").padStart(padWidth, " ");
+          const body = line.spans ? "+" + line.spans.map((s) => s.kind === "addition" ? source_default.bold(s.text) : s.text).join("") : `+${line.text}`;
+          diffLines.push(addStyle(`${numStr} ${body}`));
+        } else {
+          const numStr = String(line.newLineNumber ?? line.oldLineNumber ?? "").padStart(padWidth, " ");
+          diffLines.push(contextStyle(`${numStr}  ${line.text}`));
+        }
+      }
+    }
+    if (overflow > 0) {
+      diffLines.push(source_default.dim(`   … (${overflow} more lines)`));
+    }
+    return diffLines.length > 0 ? `${summary}
+${diffLines.join(`
+`)}` : summary;
   },
   execute: async (args, context) => {
     const { absolutePath: targetPath, relativePath } = resolveDirectMutationPath(context.cwd, args.file_path);
@@ -72440,7 +72679,7 @@ var taskKillTool = {
 // package.json
 var package_default = {
   name: "steward-cli",
-  version: "0.11.0",
+  version: "0.12.0",
   description: "Interactive AI engineering assistant for the terminal with human-in-the-loop control across local and frontier models.",
   author: "sapirrior",
   license: "MIT",
@@ -118861,6 +119100,9 @@ class StatusBar extends Component {
       });
     }
   }
+  setUpdateStatus(updateStatus) {
+    this.setState({ updateStatus });
+  }
   showWarning(warningText, durationMs = 4000) {
     if (this.warningTimer) {
       clearTimeout(this.warningTimer);
@@ -118888,7 +119130,16 @@ class StatusBar extends Component {
     const theme = getTheme();
     const termWidth = width ?? process.stdout.columns ?? 80;
     const maxCols = Math.max(1, termWidth);
-    const { model, usage, isBusy, exitPending, warning, voiceState, voiceDurationSec } = this.state;
+    const {
+      model,
+      usage,
+      isBusy,
+      exitPending,
+      warning,
+      voiceState,
+      voiceDurationSec,
+      updateStatus
+    } = this.state;
     let left = "";
     if (warning) {
       left = themeColor2(theme.warning)(warning);
@@ -118904,6 +119155,24 @@ class StatusBar extends Component {
     } else if (exitPending) {
       const errColor = themeColor2(theme.error);
       left = `${errColor("▸ ")}${source_default.dim("Press ")}${errColor("Ctrl+C")}${source_default.dim(" again to exit")}`;
+    } else if (updateStatus && updateStatus.state !== "idle") {
+      if (updateStatus.state === "checking") {
+        left = source_default.white(updateStatus.message ?? "Checking for updates...");
+      } else if (updateStatus.state === "no-updates") {
+        left = source_default.white(updateStatus.message ?? "No updates found");
+      } else if (updateStatus.state === "available") {
+        left = source_default.white(updateStatus.message ?? `Found version v${updateStatus.version ?? ""}`);
+      } else if (updateStatus.state === "downloading") {
+        left = source_default.white(updateStatus.message ?? `Downloading v${updateStatus.version ?? ""}...`);
+      } else if (updateStatus.state === "ready") {
+        left = source_default.white.bold(updateStatus.message ?? "Update complete · Restart to apply");
+      } else if (updateStatus.state === "error" && updateStatus.message) {
+        left = themeColor2(theme.error)(updateStatus.message);
+      } else if (isBusy) {
+        left = source_default.dim("esc to interrupt");
+      } else {
+        left = source_default.dim("? for shortcuts");
+      }
     } else if (isBusy) {
       left = source_default.dim("esc to interrupt");
     } else {
@@ -120545,235 +120814,6 @@ class BashPermissionDock extends Component {
   }
 }
 
-// src/utils/diff.ts
-function tokenizeLines(content) {
-  if (!content)
-    return [];
-  const tokens = [];
-  const regex = /([^\r\n]*)(\r?\n)?/g;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    if (match.index === content.length)
-      break;
-    const text = match[1] ?? "";
-    const ending = match[2] ?? "";
-    tokens.push({ text, ending });
-    if (!ending && match.index + text.length === content.length)
-      break;
-  }
-  return tokens;
-}
-function tokenizeWords(text) {
-  if (!text)
-    return [];
-  const matches = text.match(/[\w]+|[^\w\s]+|\s+/g);
-  return matches ?? [text];
-}
-function myersDiff(oldArr, newArr, equals = (a, b) => a === b) {
-  const n = oldArr.length;
-  const m = newArr.length;
-  if (n === 0 && m === 0)
-    return [];
-  if (n === 0)
-    return newArr.map((newItem, i) => ({ kind: "insert", newItem, newIndex: i }));
-  if (m === 0)
-    return oldArr.map((oldItem, i) => ({ kind: "delete", oldItem, oldIndex: i }));
-  const max = n + m;
-  const v = { 1: 0 };
-  const trace = [];
-  for (let d = 0;d <= max; d++) {
-    trace.push({ ...v });
-    for (let k = -d;k <= d; k += 2) {
-      let x = k === -d || k !== d && (v[k - 1] ?? -1) < (v[k + 1] ?? -1) ? v[k + 1] ?? 0 : (v[k - 1] ?? 0) + 1;
-      let y = x - k;
-      while (x < n && y < m && equals(oldArr[x], newArr[y])) {
-        x++;
-        y++;
-      }
-      v[k] = x;
-      if (x >= n && y >= m) {
-        const ops = [];
-        let cx = n;
-        let cy = m;
-        for (let cd = d;cd > 0; cd--) {
-          const prevV = trace[cd];
-          const pk = cx - cy;
-          const prevK = pk === -cd || pk !== cd && (prevV[pk - 1] ?? -1) < (prevV[pk + 1] ?? -1) ? pk + 1 : pk - 1;
-          const prevX = prevV[prevK] ?? 0;
-          const prevY = prevX - prevK;
-          while (cx > prevX + (prevK === pk + 1 ? 0 : 1) && cy > prevY + (prevK === pk + 1 ? 1 : 0)) {
-            cx--;
-            cy--;
-            ops.push({
-              kind: "equal",
-              oldItem: oldArr[cx],
-              newItem: newArr[cy],
-              oldIndex: cx,
-              newIndex: cy
-            });
-          }
-          if (prevK === pk + 1) {
-            cy--;
-            ops.push({ kind: "insert", newItem: newArr[cy], newIndex: cy });
-          } else {
-            cx--;
-            ops.push({ kind: "delete", oldItem: oldArr[cx], oldIndex: cx });
-          }
-        }
-        while (cx > 0 && cy > 0) {
-          cx--;
-          cy--;
-          ops.push({
-            kind: "equal",
-            oldItem: oldArr[cx],
-            newItem: newArr[cy],
-            oldIndex: cx,
-            newIndex: cy
-          });
-        }
-        ops.reverse();
-        return ops;
-      }
-    }
-  }
-  return [];
-}
-function computeWordDiff(oldLine, newLine) {
-  const oldWords = tokenizeWords(oldLine);
-  const newWords = tokenizeWords(newLine);
-  const ops = myersDiff(oldWords, newWords);
-  const oldSpans = [];
-  const newSpans = [];
-  for (const op of ops) {
-    if (op.kind === "equal") {
-      const text = op.oldItem ?? "";
-      oldSpans.push({ text, kind: "equal" });
-      newSpans.push({ text, kind: "equal" });
-    } else if (op.kind === "delete") {
-      oldSpans.push({ text: op.oldItem ?? "", kind: "deletion" });
-    } else if (op.kind === "insert") {
-      newSpans.push({ text: op.newItem ?? "", kind: "addition" });
-    }
-  }
-  return { oldSpans, newSpans };
-}
-function buildUnifiedDiff(before, after, contextLines = 3) {
-  const oldTokens = tokenizeLines(before);
-  const newTokens = tokenizeLines(after);
-  if (before === after) {
-    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
-  }
-  const ops = myersDiff(oldTokens, newTokens, (a, b) => a.text === b.text && a.ending === b.ending);
-  const editIndices = ops.map((op, i) => op.kind !== "equal" ? i : -1).filter((i) => i !== -1);
-  if (editIndices.length === 0) {
-    return { hunks: [], oldLineCount: oldTokens.length, newLineCount: newTokens.length };
-  }
-  const hunkRanges = [];
-  let currentRange = {
-    startIdx: Math.max(0, editIndices[0] - contextLines),
-    endIdx: Math.min(ops.length - 1, editIndices[0] + contextLines)
-  };
-  for (let i = 1;i < editIndices.length; i++) {
-    const editIdx = editIndices[i];
-    const opStart = Math.max(0, editIdx - contextLines);
-    const opEnd = Math.min(ops.length - 1, editIdx + contextLines);
-    if (opStart <= currentRange.endIdx) {
-      currentRange.endIdx = Math.max(currentRange.endIdx, opEnd);
-    } else {
-      hunkRanges.push(currentRange);
-      currentRange = { startIdx: opStart, endIdx: opEnd };
-    }
-  }
-  hunkRanges.push(currentRange);
-  const hunks = [];
-  for (const range of hunkRanges) {
-    const lines = [];
-    let oldCount = 0;
-    let newCount = 0;
-    let oldStart = null;
-    let newStart = null;
-    for (let i = range.startIdx;i <= range.endIdx; i++) {
-      const op = ops[i];
-      if (op.kind === "equal") {
-        const oIdx = op.oldIndex + 1;
-        const nIdx = op.newIndex + 1;
-        if (oldStart === null)
-          oldStart = oIdx;
-        if (newStart === null)
-          newStart = nIdx;
-        lines.push({
-          kind: "context",
-          text: op.oldItem.text,
-          ending: op.oldItem.ending,
-          oldLineNumber: oIdx,
-          newLineNumber: nIdx
-        });
-        oldCount++;
-        newCount++;
-      } else if (op.kind === "delete") {
-        const oIdx = op.oldIndex + 1;
-        if (oldStart === null)
-          oldStart = oIdx;
-        lines.push({
-          kind: "deletion",
-          text: op.oldItem.text,
-          ending: op.oldItem.ending,
-          oldLineNumber: oIdx
-        });
-        oldCount++;
-      } else if (op.kind === "insert") {
-        const nIdx = op.newIndex + 1;
-        if (newStart === null)
-          newStart = nIdx;
-        lines.push({
-          kind: "addition",
-          text: op.newItem.text,
-          ending: op.newItem.ending,
-          newLineNumber: nIdx
-        });
-        newCount++;
-      }
-    }
-    let l = 0;
-    while (l < lines.length) {
-      if (lines[l]?.kind === "deletion") {
-        const delStart = l;
-        while (l < lines.length && lines[l]?.kind === "deletion")
-          l++;
-        const delEnd = l;
-        const addStart = l;
-        while (l < lines.length && lines[l]?.kind === "addition")
-          l++;
-        const addEnd = l;
-        const delCount = delEnd - delStart;
-        const addCount = addEnd - addStart;
-        const pairCount = Math.min(delCount, addCount);
-        for (let p = 0;p < pairCount; p++) {
-          const delLine = lines[delStart + p];
-          const addLine = lines[addStart + p];
-          const { oldSpans, newSpans } = computeWordDiff(delLine.text, addLine.text);
-          delLine.spans = oldSpans;
-          addLine.spans = newSpans;
-        }
-      } else {
-        l++;
-      }
-    }
-    hunks.push({
-      oldStart: oldStart ?? (oldTokens.length === 0 ? 0 : 1),
-      oldCount,
-      newStart: newStart ?? (newTokens.length === 0 ? 0 : 1),
-      newCount,
-      lines
-    });
-  }
-  return {
-    hunks,
-    oldLineCount: oldTokens.length,
-    newLineCount: newTokens.length
-  };
-}
-
 // src/tui/components/docks/FilePermissionDock.tsx
 class FilePermissionDock extends Component {
   wrap = true;
@@ -120903,8 +120943,7 @@ class FilePermissionDock extends Component {
           const wrapped = prefixedBlock(firstPrefix, bodyText, {
             continuationPrefix: contPrefix,
             width: maxCols,
-            bg: diffDeleteBg,
-            padToWidth: true
+            bg: diffDeleteBg
           });
           renderedRows.push(...wrapped);
         } else if (line.kind === "addition") {
@@ -120915,8 +120954,7 @@ class FilePermissionDock extends Component {
           const wrapped = prefixedBlock(firstPrefix, bodyText, {
             continuationPrefix: contPrefix,
             width: maxCols,
-            bg: diffAddBg,
-            padToWidth: true
+            bg: diffAddBg
           });
           renderedRows.push(...wrapped);
         } else {
@@ -122049,6 +122087,230 @@ class VoiceController {
     this.setState("idle");
   }
 }
+// src/services/updater/service.ts
+import { spawn as spawn2 } from "node:child_process";
+var DEFAULT_REPO = "sapirrior/steward";
+function parseSemver(v) {
+  const clean = v.replace(/^v/i, "").trim().split("-")[0] ?? "";
+  const parts = clean.split(".").map((p) => parseInt(p, 10) || 0);
+  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+function isNewerVersion(current, latest) {
+  const [cMaj, cMin, cPat] = parseSemver(current);
+  const [lMaj, lMin, lPat] = parseSemver(latest);
+  if (lMaj > cMaj)
+    return true;
+  if (lMaj < cMaj)
+    return false;
+  if (lMin > cMin)
+    return true;
+  if (lMin < cMin)
+    return false;
+  return lPat > cPat;
+}
+
+class AutoUpdaterService {
+  currentVersion;
+  repo;
+  state = "idle";
+  options;
+  checkTimer = null;
+  intervalTimer = null;
+  isUpdating = false;
+  constructor(options = {}) {
+    this.options = options;
+    this.currentVersion = options.currentVersion || package_default.version || "0.0.0";
+    this.repo = options.repo || DEFAULT_REPO;
+  }
+  getState() {
+    return this.state;
+  }
+  getRepo() {
+    return this.repo;
+  }
+  getCurrentVersion() {
+    return this.currentVersion;
+  }
+  get latestReleaseApi() {
+    return `https://api.github.com/repos/${this.repo}/releases/latest`;
+  }
+  get installShUrl() {
+    return `https://raw.githubusercontent.com/${this.repo}/main/installer/install.sh`;
+  }
+  get installPs1Url() {
+    return `https://raw.githubusercontent.com/${this.repo}/main/installer/install.ps1`;
+  }
+  setState(state, info) {
+    this.state = state;
+    this.options.onStatusChange?.(state, info);
+  }
+  async checkForUpdates() {
+    if (process.env.STEWARD_NO_UPDATE_CHECK === "1" || process.env.STEWARD_NO_UPDATE_CHECK === "true") {
+      return null;
+    }
+    try {
+      this.setState("checking", { message: "Checking for updates..." });
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 1e4);
+      const response = await fetch(this.latestReleaseApi, {
+        headers: {
+          "User-Agent": `steward-cli/${this.currentVersion}`,
+          Accept: "application/vnd.github.v3+json"
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!response.ok) {
+        this.setState("idle");
+        return null;
+      }
+      const data = await response.json();
+      const rawTag = data.tag_name ?? "";
+      const latestVersion = rawTag.replace(/^v/i, "").trim();
+      if (!latestVersion) {
+        this.setState("idle");
+        return null;
+      }
+      const hasUpdate = isNewerVersion(this.currentVersion, latestVersion);
+      const updateInfo = {
+        currentVersion: this.currentVersion,
+        latestVersion,
+        hasUpdate,
+        tag: rawTag,
+        releaseUrl: data.html_url
+      };
+      if (hasUpdate) {
+        this.setState("available", {
+          version: latestVersion,
+          message: `Found version v${latestVersion}`
+        });
+      } else {
+        this.setState("no-updates", { message: "No updates found" });
+        setTimeout(() => {
+          if (this.state === "no-updates") {
+            this.setState("idle");
+          }
+        }, 3000);
+      }
+      return updateInfo;
+    } catch (err) {
+      logError(err, { component: "AutoUpdaterService", method: "checkForUpdates" });
+      this.setState("idle");
+      return null;
+    }
+  }
+  async installUpdate(version) {
+    if (this.isUpdating)
+      return false;
+    this.isUpdating = true;
+    this.setState("downloading", {
+      version,
+      message: `Downloading v${version}...`
+    });
+    try {
+      const isWindows = process.platform === "win32";
+      let childProcess;
+      if (isWindows) {
+        childProcess = spawn2("powershell", [
+          "-NoProfile",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-Command",
+          `irm ${this.installPs1Url} | iex`
+        ], {
+          stdio: "ignore",
+          windowsHide: true
+        });
+      } else {
+        childProcess = spawn2("bash", ["-c", `curl -fsSL ${this.installShUrl} | bash`], {
+          stdio: "ignore",
+          env: {
+            ...process.env,
+            HOME: process.env.HOME || "",
+            PATH: process.env.PATH || ""
+          }
+        });
+      }
+      const success = await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          try {
+            childProcess.kill();
+          } catch {}
+          resolve(false);
+        }, 300000);
+        childProcess.on("exit", (code) => {
+          clearTimeout(timeout);
+          resolve(code === 0);
+        });
+        childProcess.on("error", () => {
+          clearTimeout(timeout);
+          resolve(false);
+        });
+      });
+      if (success) {
+        this.setState("ready", {
+          version,
+          message: `Update complete · Restart to apply`
+        });
+        return true;
+      } else {
+        this.setState("error", {
+          version,
+          message: `Update to v${version} failed`
+        });
+        setTimeout(() => {
+          if (this.state === "error") {
+            this.setState("idle");
+          }
+        }, 4000);
+        return false;
+      }
+    } catch (err) {
+      logError(err, { component: "AutoUpdaterService", method: "installUpdate" });
+      this.setState("error", { version, message: "Update failed" });
+      setTimeout(() => {
+        if (this.state === "error") {
+          this.setState("idle");
+        }
+      }, 4000);
+      return false;
+    } finally {
+      this.isUpdating = false;
+    }
+  }
+  startBackgroundCheck(initialDelayMs = 2000, intervalMs) {
+    if (this.checkTimer)
+      clearTimeout(this.checkTimer);
+    if (this.intervalTimer)
+      clearInterval(this.intervalTimer);
+    const performCheck = async () => {
+      const update = await this.checkForUpdates();
+      if (update && update.hasUpdate) {
+        setTimeout(async () => {
+          await this.installUpdate(update.latestVersion);
+        }, 1200);
+      }
+    };
+    this.checkTimer = setTimeout(async () => {
+      this.checkTimer = null;
+      await performCheck();
+      const recurringInterval = intervalMs ?? this.options.checkIntervalMs;
+      if (recurringInterval && recurringInterval > 0) {
+        this.intervalTimer = setInterval(performCheck, recurringInterval);
+      }
+    }, initialDelayMs);
+  }
+  dispose() {
+    if (this.checkTimer) {
+      clearTimeout(this.checkTimer);
+      this.checkTimer = null;
+    }
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer);
+      this.intervalTimer = null;
+    }
+  }
+}
 // src/tui/app.ts
 class TUIApp {
   engine;
@@ -122064,6 +122326,7 @@ class TUIApp {
   ctrlCTimer = null;
   isBusy = false;
   voiceController;
+  autoUpdater;
   permissionQueue;
   constructor(options = {}) {
     this.cwd = options.cwd ?? process.cwd();
@@ -122126,6 +122389,20 @@ class TUIApp {
         this.statusBar.showWarning(warning);
       }
     });
+    this.autoUpdater = new AutoUpdaterService({
+      currentVersion: options.version,
+      onStatusChange: (state, info) => {
+        if (state === "idle") {
+          this.statusBar.setUpdateStatus(undefined);
+        } else {
+          this.statusBar.setUpdateStatus({
+            state,
+            version: info?.version,
+            message: info?.message
+          });
+        }
+      }
+    });
     this.permissionQueue = new PermissionQueue({
       onShow: (item) => {
         if (this.activeModal)
@@ -122222,6 +122499,7 @@ class TUIApp {
     this.engine.mount(this.streamingView, { kind: "custom" });
     this.engine.mount(this.promptInput, { keepCursorVisible: true, kind: "input" });
     this.engine.mount(this.statusBar, { kind: "custom" });
+    this.autoUpdater.startBackgroundCheck(3000);
     this.engine.addInputListener((chunk) => {
       const action = parseKeyInput(chunk);
       if (this.voiceController.isActive) {
@@ -122657,6 +122935,7 @@ class TUIApp {
     this.permissionQueue.clear();
     this.session.shutdown().catch(() => {});
     this.voiceController.dispose();
+    this.autoUpdater.dispose();
     this.engine.cleanupSync();
     if (this.onExitCallback) {
       this.onExitCallback();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "steward-cli",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Interactive AI engineering assistant for the terminal with human-in-the-loop control across local and frontier models.",
   "author": "sapirrior",
   "license": "MIT",