thincoder 0.8.12 → 0.9.0

package/src/tools/checklist.mjs

@@ -8,38 +8,109 @@ const DONE = "checklist-done.md"
 function checklistPath(cwd) { return join(cwd, ".thincoder", CHECKLIST) }
 function donePath(cwd) { return join(cwd, ".thincoder", DONE) }
 
-/** Parse checklist file into array of { index, status, text } */
+/**
+ * Parse checklist file into tree-structured items.
+ * Indentation (2 spaces per level) determines parent-child relationships.
+ * Each item: { id, index, depth, status, text, children[] }
+ * "index" is the 1-based position in the flat markdown list.
+ */
 function parse(filePath) {
   if (!existsSync(filePath)) return []
   const lines = readFileSync(filePath, "utf-8").split("\n")
   const items = []
-  let idx = 0
+  let flatIdx = 0
+  const stack = [{ children: items, depth: -1 }] // virtual root
+
   for (const line of lines) {
-    const m = line.match(/^- \[(.)\] (.+)$/)
-    if (m) {
-      idx++
-      const raw = m[1]
-      const status = raw === "x" ? "done" : raw === "~" ? "in_progress" : "pending"
-      items.push({ index: idx, status, text: m[2].trim() })
+    const m = line.match(/^(\s*)- \[(.)\] (.+)$/)
+    if (!m) continue
+    flatIdx++
+    const indent = m[1]
+    const depth = Math.floor(indent.length / 2) // 2 spaces = 1 level
+    const raw = m[2]
+    const status = raw === "x" ? "done" : raw === "~" ? "in_progress" : "pending"
+    const text = m[3].trim()
+
+    // Extract explicit ID if present (e.g. "T1:", "T1.1:")
+    const idMatch = text.match(/^(T[\d.]+):/)
+    const node = {
+      id: idMatch ? idMatch[1] : null,
+      index: flatIdx,
+      depth,
+      status,
+      text,
+      children: [],
     }
+
+    // Find parent by popping stack until we find a node at depth-1
+    while (stack.length > 1 && stack.at(-1).depth >= depth) stack.pop()
+    const parent = stack.at(-1)
+    parent.children.push(node)
+    // Auto-assign ID if not explicit
+    if (!node.id) {
+      const siblingCount = parent.children.length
+      const base = parent.id ? `${parent.id}` : "T"
+      if (parent.id) {
+        node.id = `${base}.${siblingCount}`
+      } else {
+        // Root level: T1, T2, T3...
+        let rootIdx = 0
+        for (const c of items) {
+          if (c.id?.match(/^T\d+$/)) rootIdx = Math.max(rootIdx, parseInt(c.id.slice(1)))
+        }
+        node.id = `T${rootIdx + 1}`
+      }
+    }
+    stack.push({ children: node.children, depth, id: node.id })
   }
   return items
 }
 
-/** Write items back to file */
-function write(filePath, items) {
-  mkdirSync(dirname(filePath), { recursive: true })
+/** Write items back to file, preserving tree structure */
+function write(filePath, items, _depth = 0) {
+  if (_depth === 0) mkdirSync(dirname(filePath), { recursive: true })
   const lines = []
+  const indent = "  ".repeat(_depth)
   for (const item of items) {
     const mark = item.status === "done" ? "x" : item.status === "in_progress" ? "~" : " "
-    lines.push(`- [${mark}] ${item.text}`)
+    const label = item.id ? `${item.id}: ${item.text}` : item.text
+    lines.push(`${indent}- [${mark}] ${label}`)
+    if (item.children?.length) {
+      lines.push(...write(filePath, item.children, _depth + 1).split("\n").filter(Boolean))
+    }
+  }
+  if (_depth === 0) {
+    writeFileSync(filePath, lines.join("\n") + "\n")
+    return ""
+  }
+  return lines.join("\n")
+}
+
+/** Find a node by ID in the tree */
+function findById(items, id) {
+  for (const item of items) {
+    if (item.id === id) return { parent: items, item, idx: items.indexOf(item) }
+    if (item.children?.length) {
+      const found = findById(item.children, id)
+      if (found) return found
+    }
   }
-  writeFileSync(filePath, lines.join("\n") + "\n")
+  return null
+}
+
+/** Flatten tree for mark action (index-based) */
+function flatten(items, out = []) {
+  for (const item of items) {
+    out.push(item)
+    if (item.children?.length) flatten(item.children, out)
+  }
+  return out
 }
 
 /** Parse pending items only (for context injection) */
 export function pendingItems(cwd) {
-  return parse(checklistPath(cwd)).filter(i => i.status !== "done")
+  const flat = flatten(parse(checklistPath(cwd)))
+  return flat.filter(i => i.status !== "done")
 }
 
 export const checklistTool = {
@@ -66,6 +137,10 @@ export const checklistTool = {
         enum: ["pending", "in_progress", "done"],
         description: "New status (required for mark)"
       },
+      parent: {
+        type: "string",
+        description: "Parent task ID for tree-structured tasks (e.g. 'T1')"
+      },
     },
     required: ["action"],
   },
@@ -75,9 +150,33 @@ export const checklistTool = {
       case "add": {
         if (!args.item || typeof args.item !== "string") return "Error: 'item' is required for add"
         const items = parse(checklistPath(ctx.cwd))
-        items.push({ index: items.length + 1, status: "pending", text: args.item })
+
+        let target = items
+        let parentId = null
+        if (args.parent) {
+          const found = findById(items, args.parent)
+          if (!found) return `Error: parent '${args.parent}' not found. Use 'list' to see all task IDs.`
+          target = found.item.children
+          parentId = found.item.id
+        }
+
+        // Auto-assign ID
+        let id
+        if (parentId) {
+          id = `${parentId}.${target.length + 1}`
+        } else {
+          let maxIdx = 0
+          for (const c of items) {
+            const m = c.id?.match(/^T(\d+)$/)
+            if (m) maxIdx = Math.max(maxIdx, parseInt(m[1]))
+          }
+          id = `T${maxIdx + 1}`
+        }
+
+        const node = { id, index: 0, depth: parentId ? 1 : 0, status: "pending", text: args.item, children: [] }
+        target.push(node)
         write(checklistPath(ctx.cwd), items)
-        return `Added: [ ] ${args.item}`
+        return `Added: [ ] ${id}: ${args.item}${parentId ? ` (under ${parentId})` : ""}`
       }
       case "mark": {
         if (args.index == null) return "Error: 'index' is required for mark"
@@ -85,8 +184,9 @@ export const checklistTool = {
         if (!status || !["pending", "in_progress", "done"].includes(status)) return "Error: 'status' is required (pending|in_progress|done)"
         const cp = checklistPath(ctx.cwd)
         const items = parse(cp)
-        if (args.index < 1 || args.index > items.length) return `Error: index ${args.index} out of range (1-${items.length})`
-        const item = items[args.index - 1]
+        const flat = flatten(items)
+        if (args.index < 1 || args.index > flat.length) return `Error: index ${args.index} out of range (1-${flat.length})`
+        const item = flat[args.index - 1]
         const old = item.status
         if (old === status) return `Already ${status}: ${item.text}`
         item.status = status
@@ -94,18 +194,30 @@ export const checklistTool = {
           // Move to done file
           const dp = donePath(ctx.cwd)
           const doneItems = parse(dp)
-          doneItems.push(item)
+          doneItems.push({ id: item.id, index: 0, depth: 0, status: "done", text: item.text, children: [] })
           write(dp, doneItems)
-          items.splice(args.index - 1, 1)
+          // Remove from tree
+          const found = findById(items, item.id)
+          if (found) found.parent.splice(found.idx, 1)
         }
         write(cp, items)
-        return `Marked #${args.index} ${old} → ${status}: ${item.text}`
+        return `Marked #${args.index} ${old} → ${status}: ${item.id}: ${item.text}`
       }
       case "list": {
         const items = parse(checklistPath(ctx.cwd))
         if (items.length === 0) return "(checklist is empty)"
         const marks = { pending: " ", in_progress: "~", done: "x" }
-        return items.map(i => `- [${marks[i.status]}] ${i.text}`).join("\n")
+        const lines = []
+        function render(nodes, depth) {
+          const indent = "  ".repeat(depth)
+          for (const n of nodes) {
+            const idTag = n.id ? `${n.id}: ` : ""
+            lines.push(`${indent}- [${marks[n.status]}] ${idTag}${n.text}`)
+            if (n.children?.length) render(n.children, depth + 1)
+          }
+        }
+        render(items, 0)
+        return lines.join("\n")
       }
       default:
         return `Error: unknown action '${args.action}'`

package/src/tools/file.mjs

@@ -6,6 +6,7 @@ import {
   autoSyntaxCheck,
   resolveInCwd,
   resolveExternal,
+  normalizeEOL,
 } from "./shared.mjs";
 import { specForModel } from "../config.mjs";
 import { createHash } from "node:crypto";
@@ -39,7 +40,7 @@ export const readTool = {
     // Large file guard: check size first, reject reading entire file if >10MB (offset/limit only affect the returned slice, not buffering)
     const st = await stat(abs).catch(() => null)
     if (st && st.size > MAX_FILE_READ_BYTES) throw new Error(`File too large (${Math.round(st.size / 1_000_000)}MB > 10MB limit). Use bash with head/tail or grep for targeted extraction.`)
-    const content = await readFile(abs, "utf8")
+    const content = normalizeEOL(await readFile(abs, "utf8"))
     const lines = content.split("\n")
     const offset = Math.max(1, args.offset ?? 1)
     const limit = Math.min(args.limit ?? MAX_READ_LINES, MAX_READ_LINES)
@@ -153,7 +154,7 @@ export const editTool = {
     if (!args.old_string) {
       throw new Error("old_string must not be empty (empty string matches everywhere and would corrupt the file)")
     }
-    const content = await readFile(abs, "utf8")
+    const content = normalizeEOL(await readFile(abs, "utf8"))
     const occurrences = content.split(args.old_string).length - 1
     if (occurrences === 0) {
       // Give clues to help the model locate: first-line preview + common causes
@@ -195,7 +196,7 @@ export const insertAfterTool = {
   readonly: false,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
-    const text = await readFile(abs, "utf8")
+    const text = normalizeEOL(await readFile(abs, "utf8"))
     const lines = text.split("\n")
 
     let targetLine
@@ -208,7 +209,12 @@ export const insertAfterTool = {
         throw new Error(`after_line ${targetLine} out of range (file has ${lines.length} lines)`)
       }
     } else if (args.after_regex) {
-      const regex = new RegExp(args.after_regex)
+      let regex
+      try {
+        regex = new RegExp(args.after_regex)
+      } catch (e) {
+        throw new Error(`after_regex /${args.after_regex}/ is not a valid JavaScript regex: ${e.message}`)
+      }
       const matches = []
       for (let i = 0; i < lines.length; i++) {
         if (regex.test(lines[i])) matches.push(i + 1)
@@ -254,22 +260,24 @@ export const hashlineEditTool = {
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
     if (!args.old_hashes?.length) throw new Error("old_hashes must not be empty — read the file with hashes=true to get line hashes")
-    const content = await readFile(abs, "utf8")
+    const content = normalizeEOL(await readFile(abs, "utf8"))
     const lines = content.split("\n")
     const fileHashes = lines.map((l) => hashLine(l))
     const target = args.old_hashes
 
-    // Sliding-window match: find the exact sequence of hashes
-    let pos = -1
+    // Sliding-window match: find all occurrences of the hash sequence.
+    // When multiple matches are found (e.g. empty lines), report positions so the
+    // model can include more context lines (adjacent lines with unique hashes).
+    const matches = []
     for (let i = 0; i <= fileHashes.length - target.length; i++) {
       let match = true
       for (let j = 0; j < target.length; j++) {
         if (fileHashes[i + j] !== target[j]) { match = false; break }
       }
-      if (match) { pos = i; break }
+      if (match) matches.push(i)
     }
 
-    if (pos === -1) {
+    if (matches.length === 0) {
       // Help the model recover: show the current file hashes for context
       const maxShow = Math.min(fileHashes.length, 50)
       const hashDump = fileHashes.slice(0, maxShow).map((h, i) => `${h}  L${i + 1}: ${lines[i].slice(0, 80)}`).join("\n")
@@ -280,6 +288,26 @@ export const hashlineEditTool = {
       )
     }
 
+    if (matches.length > 1) {
+      const ctx = 2 // lines of surrounding context
+      const detail = matches.map((m) => {
+        const start = Math.max(0, m - ctx)
+        const end = Math.min(lines.length, m + target.length + ctx)
+        const preview = lines.slice(start, end).map((l, i) => {
+          const ln = start + i + 1
+          const marker = m <= ln - 1 && ln - 1 < m + target.length ? ">" : " "
+          return `${marker} L${ln}: ${l.slice(0, 80)}`
+        }).join("\n")
+        return `  Match at line ${m + 1} (${target.length} line(s)):\n${preview}`
+      }).join("\n\n")
+      throw new Error(
+        `Hash sequence matches ${matches.length} positions in ${args.path} — ambiguous.\n` +
+        `Include more surrounding lines (unique-hash lines before/after the target) to disambiguate.\n\n` +
+        `All matches with surrounding context:\n\n${detail}`
+      )
+    }
+
+    const pos = matches[0]
     // Replace: remove old lines, insert new lines at the same position
     const newLines = args.new_content.split("\n")
     lines.splice(pos, target.length, ...newLines)

package/src/tools/patch.mjs

@@ -6,7 +6,7 @@ import {
 import { execFileSync } from "node:child_process";
 import { mkdir } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
-import { stat } from "node:fs/promises";
+import { stat, lstat } from "node:fs/promises";
 import { writeFile } from "node:fs/promises";
 import { unlink } from "node:fs/promises";
 import { existsSync } from "node:fs";
@@ -206,8 +206,12 @@ export const deleteTool = {
   readonly: false,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
-    if (!existsSync(abs)) throw new Error(`File not found: ${args.path}`)
-    const s = await stat(abs)
+    let s
+    try {
+      s = await lstat(abs)
+    } catch {
+      throw new Error(`File not found: ${args.path}`)
+    }
     if (s.isDirectory()) throw new Error(`"${args.path}" is a directory — use bash to remove directories`)
     // git-tracked files: refuse direct deletion (safety net); untracked: allow
     // Use resolved relative path (normalized forward slashes) to prevent backslash/unusual paths from bypassing ls-files matching

package/src/tools/repomap.mjs

@@ -1,11 +1,12 @@
 /**
- * repomap.mjs — repo dependency outline (zero dependencies, pure regex)
+ * repomap.mjs — repo dependency outline
  * Real-time import/export parsing, generates compact text for LLMs to understand code structure.
  * No index stored — reads and parses files on each call, ~50ms.
  */
 import { existsSync } from "node:fs"
-import { readFile } from "node:fs/promises"
+import { readFile, stat } from "node:fs/promises"
 import { join } from "node:path"
+import { normalizeEOL } from "./shared.mjs"
 
 /** Extract JS/TS file import paths (normalize by stripping .ts/.js/.mjs suffixes) */
 function parseImports(lines, ext) {
@@ -125,8 +126,11 @@ async function _buildDepGraph(db, cwd) {
     const rel = allFiles[i]
     const abs = join(cwd, ...rel.split("/"))
     if (!existsSync(abs)) continue
+    // Large file guard: skip files over 10MB to prevent OOM
+    const fst = await stat(abs).catch(() => null)
+    if (fst && fst.size > 10_000_000) continue
     let text
-    try { text = await readFile(abs, "utf8") } catch { continue }
+    try { text = normalizeEOL(await readFile(abs, "utf8")) } catch { continue }
     const lines = text.split("\n")
     const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
 

package/src/tools/shared.mjs

@@ -20,6 +20,13 @@ export const BASH_TIMEOUT_MS = 120_000
 export const MAX_RESPONSE_BODY_BYTES = 5_000_000
 export const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "build", ".turbo", "coverage"])
 
+/** Normalize Windows line endings to Unix: \r\n → \n.
+ *  Applied on every text-file read so that edit/hash matching
+ *  and hash computation are platform-consistent. */
+export function normalizeEOL(text) {
+  return text.replace(/\r\n/g, "\n")
+}
+
 /** Convert to OpenAI tools parameter format */
 export function toOpenAISchema(tool) {
   return {

package/src/tools/system.mjs

@@ -11,7 +11,8 @@ import {
   isDestructiveCommand,
   hasFileRedirection,
   insideGitRepo,
-  globToRegex
+  globToRegex,
+  normalizeEOL,
 } from "./shared.mjs";
 import { spawn, execFileSync } from "node:child_process";
 import { readFile, readdir, stat, lstat } from "node:fs/promises";
@@ -222,6 +223,8 @@ async function* walkFiles(dir, rel = "") {
     return
   }
   for (const e of entries) {
+    // Skip ignored dirs AND symbolic links (symlinks to directories would cause infinite loops)
+    if (e.isSymbolicLink()) continue
     if (e.isDirectory() && IGNORED_DIRS.has(e.name)) continue
     const relPath = rel ? `${rel}/${e.name}` : e.name
     if (e.isDirectory()) {
@@ -253,7 +256,12 @@ export const grepTool = {
   readonly: true,
   async execute(args, ctx) {
     const base = resolveInCwd(ctx, args.path ?? ".")
-    const regex = new RegExp(args.pattern)
+    let regex
+    try {
+      regex = new RegExp(args.pattern)
+    } catch (e) {
+      throw new Error(`grep pattern /${args.pattern}/ is not a valid regex: ${e.message}`)
+    }
     const fileFilter = args.glob ? globToRegex(args.glob) : null
     const before = Math.max(0, Math.floor(args.before ?? 0))
     const after = Math.max(0, Math.floor(args.after ?? 0))
@@ -267,7 +275,7 @@ export const grepTool = {
         // Large file guard: skip files over 10MB to prevent OOM
         const fst = await stat(file)
         if (fst.size > 10_000_000) return
-        content = await readFile(file, "utf8")
+        content = normalizeEOL(await readFile(file, "utf8"))
       } catch {
         return // Skip unreadable files; binary files will be read as UTF-8 and searched (may produce garbled matches)
       }
@@ -346,7 +354,13 @@ export const lsTool = {
   readonly: true,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path ?? ".")
-    const entries = await readdir(abs, { withFileTypes: true })
+    let entries
+    try {
+      entries = await readdir(abs, { withFileTypes: true })
+    } catch (e) {
+      if (e.code === "ENOENT" || e.code === "ENOTDIR") throw new Error(`ls: ${args.path ?? "."} — ${e.code === "ENOTDIR" ? "not a directory" : "not found"}`)
+      throw e
+    }
     const rows = await Promise.all(
       entries.slice(0, 500).map(async (e) => {
         const s = await stat(join(abs, e.name)).catch(() => null)

package/src/tui/agent-turn.mjs

@@ -218,6 +218,14 @@ export async function runAgentTurn(ctx, text) {
     } catch (error) {
       flushStream()
       if (error.name === "AbortError" || state.controller?.signal.aborted) {
+        // Ctrl+I inject: the signal was aborted with an interrupt message — the agent loop
+        // may have already injected it into history, but the aborted signal prevents retry.
+        // Recreate the controller and resume from the same context.
+        if (state.controller?.signal?.reason?.interrupt) {
+          state.controller = new AbortController()
+          resume = true
+          continue
+        }
         pushLine("[stopped]", C.warn)
         break
       }

package/src/tui/ansi.mjs

@@ -17,6 +17,10 @@ export const ansi = {
   clearLine: `${ESC}[K`,
   clearToEnd: `${ESC}[J`,
   clearScreen: `${ESC}[2J`,
+  saveCursor: `${ESC}7`,      // DECSC — save cursor position
+  restoreCursor: `${ESC}8`,   // DECRC — restore cursor position
+  syncUpdateStart: `${ESC}[?2026h`, // DECSET 2026 — buffer output until syncUpdateEnd
+  syncUpdateEnd: `${ESC}[?2026l`,   // DECRST 2026 — flush buffered output atomically
   reset: `${ESC}[0m`,
   dim: `${ESC}[2m`,
   bold: `${ESC}[1m`,
@@ -34,4 +38,5 @@ export const C = {
   dim: ansi.gray,
   warn: ansi.fg(3),
   advisor: `${ESC}[92m`,  // bright green — visible on dark backgrounds
+  fold: `${ESC}[2m${ESC}[37m`,   // dim white — fold hints
 }

package/src/tui/cmd-advisor.mjs

@@ -56,11 +56,11 @@ async function openAdvisorModelPicker(ctx) {
           // Same as main — clear override (use main pool)
           delete cfg.provider
           delete cfg.model
-          pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`)
+          pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`, C.dim)
         } else {
           cfg.provider = e.provider
           cfg.model = e.model
-          pushLine(`Advisor: ${e.provider}/${e.model}`)
+          pushLine(`Advisor: ${e.provider}/${e.model}`, C.dim)
         }
       }
     },

package/src/tui/cmd-fold.mjs

@@ -0,0 +1,21 @@
+/**
+ * cmd-fold.mjs — /fold command: toggle conversation result folding
+ */
+import { C } from "./ansi.mjs"
+
+export async function handleFoldCommand(ctx) {
+  const { state } = ctx
+  const text = state.input.join("").trim()
+  const arg = text.split(/\s+/)[1]
+  if (arg === "on") {
+    state.foldEnabled = true
+    ctx.pushLine("Folding: on (long tool results are collapsed)", C.dim)
+  } else if (arg === "off") {
+    state.foldEnabled = false
+    ctx.pushLine("Folding: off (all results shown in full)", C.dim)
+  } else {
+    state.foldEnabled = !state.foldEnabled
+    ctx.pushLine(`Folding: ${state.foldEnabled ? "on" : "off"}`, C.dim)
+  }
+  ctx.render()
+}

package/src/tui/cmd-mcp.mjs

@@ -124,12 +124,53 @@ export async function handleMcpCommand(ctx) {
         openPicker({
           title: "MCP Transport",
           entries: [
-            { type: "header", text: "Select server transport" },
+            { type: "header", text: "Select transport or use AI assist" },
+            { type: "item", text: "🤖 Describe with AI — natural language → config", action: "ai" },
             { type: "item", text: "HTTP (https://…)", action: "http" },
             { type: "item", text: "WebSocket (ws://…)", action: "ws" },
             { type: "item", text: "stdio (local command)", action: "stdio" },
           ],
           onSelect: async (te) => {
+            if (te.action === "ai") {
+              const description = await askQuestion("Describe the MCP server you want to add (e.g. 'a filesystem server that gives access to /tmp'):")
+              if (!description) return
+              pushLine("[mcp] Generating config from description...", C.dim)
+              try {
+                const { chat } = await import("../provider/index.mjs")
+                const res = await chat(agent.provider, {
+                  messages: [{
+                    role: "user",
+                    content: `Generate an MCP server configuration JSON from this description. Return ONLY the JSON object, no explanation.
+
+Description: "${description}"
+
+The JSON should have these fields:
+- name: a short identifier
+- One of: url (HTTP), wsUrl (WebSocket), or command + args (stdio)
+- headers: optional key-value object
+
+Example HTTP: {"name":"filesystem","url":"https://example.com/mcp","headers":{"Authorization":"Bearer xxx"}}
+Example stdio: {"name":"filesystem","command":"npx","args":["-y","@modelcontextprotocol/server-filesystem","/tmp"]}
+
+Return ONLY the JSON object:`,
+                  }],
+                  tools: [],
+                  signal: AbortSignal.timeout(15_000),
+                })
+                const jsonMatch = (res.content ?? "").match(/\{[\s\S]*\}/)
+                if (!jsonMatch) { pushLine("[mcp] AI response not valid JSON", C.error); return }
+                const srv = JSON.parse(jsonMatch[0])
+                if (!srv.name) { pushLine("[mcp] AI response missing 'name' field", C.error); return }
+                // Show preview and confirm
+                pushLine(`[mcp] Generated config: ${JSON.stringify(srv)}`, C.tool)
+                const confirm = await askQuestion("Add this server? (y/n):")
+                if (confirm?.toLowerCase() !== "y") { pushLine("[mcp] Cancelled", C.dim); return }
+                await addAndConnect(ctx, srv)
+              } catch (err) {
+                pushLine(`[mcp] AI generation failed: ${err.message}`, C.error)
+              }
+              return
+            }
             const name = await askQuestion("Server name:")
             if (!name) return
             const existing = (agent.config?.mcp?.servers ?? []).find((s) => s.name === name)

package/src/tui/cmd-undo.mjs

@@ -0,0 +1,91 @@
+/**
+ * cmd-undo.mjs — /undo command: revert recent file modifications
+ *
+ * Tracks write/edit/delete/hashline_edit/apply_patch operations in agent._undoStack.
+ * /undo opens a picker to select and revert an operation.
+ */
+
+import { existsSync, writeFileSync, unlinkSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { ansi, C } from "./ansi.mjs"
+
+const MAX_UNDO = 50
+
+/**
+ * Snapshot a file before a side-effect tool modifies it.
+ * Called from dispatch.mjs before each write/edit/delete/apply_patch/hashline_edit.
+ */
+export function snapshotForUndo(agent, toolName, args, cwd) {
+  if (!agent._undoStack) agent._undoStack = []
+  const path = args.path ?? args.file
+  if (!path || typeof path !== "string") return
+
+  const abs = join(cwd, ...path.split("/"))
+  let backup = null
+  try {
+    if (existsSync(abs)) {
+      backup = readFileSync(abs, "utf8")
+    }
+  } catch {
+    // can't read — maybe binary, skip
+    return
+  }
+
+  agent._undoStack.push({
+    tool: toolName,
+    path,
+    backup,
+    timestamp: Date.now(),
+  })
+  if (agent._undoStack.length > MAX_UNDO) agent._undoStack.shift()
+}
+
+export async function handleUndoCommand(ctx) {
+  const { agent, pushLine, openPicker } = ctx
+  const stack = agent._undoStack ?? []
+
+  if (stack.length === 0) {
+    pushLine("[undo] Nothing to undo — no file modifications tracked yet.", C.dim)
+    return
+  }
+
+  const entries = [
+    { type: "header", text: `${stack.length} operation(s) available to undo (most recent first)` },
+    ...stack.map((item, i) => {
+      const relIdx = stack.length - i
+      const time = new Date(item.timestamp).toLocaleTimeString()
+      const preview = item.backup === null
+        ? "(was created — undo will delete)"
+        : `(${item.backup.split("\n").length} lines — undo will restore)`
+      return {
+        type: "item",
+        text: `#${relIdx} ${item.tool}: ${item.path} ${preview} — ${time}`,
+        idx: i,
+      }
+    }),
+  ]
+
+  openPicker({
+    title: "Undo",
+    entries,
+    onSelect: async (e) => {
+      const item = stack[e.idx]
+      const abs = join(agent.cwd, ...item.path.split("/"))
+
+      try {
+        if (item.backup === null) {
+          // File was created — undo deletes it
+          if (existsSync(abs)) unlinkSync(abs)
+        } else {
+          // File was modified — undo restores original
+          writeFileSync(abs, item.backup, "utf8")
+        }
+        // Remove this and all newer entries (can't undo out of order)
+        stack.splice(e.idx)
+        pushLine(`[undo] Reverted: ${item.tool} ${item.path}`, C.tool)
+      } catch (err) {
+        pushLine(`[undo] Failed to revert ${item.path}: ${err.message}`, C.error)
+      }
+    },
+  })
+}