thincoder 0.7.7 → 0.8.0

package/src/tools/patch.mjs

@@ -0,0 +1,226 @@
+import {
+  DESC,
+  autoSyntaxCheck,
+  resolveInCwd
+} from "./shared.mjs";
+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 { writeFile } from "node:fs/promises";
+import { unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, relative, dirname } from "node:path";
+
+/**
+ * 解析统一 diff（unified diff）：返回 [{ path, isNew, hunks: [{ ops: [{type:" "|"-"|"+", text}] }] }]
+ * 按 @@ 头的行数计数消费 hunk 行——LLM 常把上下文空行剥成纯空行，靠计数而不是行首字符判断 hunk 边界
+ */
+function parsePatch(patch) {
+  // 补丁文本常来自 CRLF 终端/模型输出，行尾 \r 会混进 hunk 内容导致上下文对不上，统一剥掉
+  const lines = patch.replace(/\r(?=\n|$)/g, "").split("\n")
+  const files = []
+  let cur = null
+  let i = 0
+  const stripPrefix = (p) => p.replace(/^[ab]\//, "")
+  while (i < lines.length) {
+    const line = lines[i]
+    if (line.startsWith("--- ")) {
+      const oldPath = line.slice(4).trim()
+      const plus = lines[i + 1]
+      if (!plus?.startsWith("+++ ")) throw new Error(`Malformed patch: expected "+++" line after "${line}"`)
+      const newPath = plus.slice(4).trim()
+      if (newPath === "/dev/null") throw new Error("Deleting files via patch is not supported — use the delete tool")
+      cur = { path: stripPrefix(newPath), isNew: oldPath === "/dev/null", hunks: [] }
+      files.push(cur)
+      i += 2
+      continue
+    }
+    if (line.startsWith("@@")) {
+      if (!cur) throw new Error("Malformed patch: hunk header before any file header")
+      const m = line.match(/^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/)
+      if (!m) throw new Error(`Malformed patch: bad hunk header "${line}" (need @@ -old,count +new,count @@)`)
+      let oldNeed = m[1] == null ? 1 : Number(m[1])
+      let newNeed = m[2] == null ? 1 : Number(m[2])
+      const hunk = { ops: [] }
+      i++
+      while (oldNeed > 0 || newNeed > 0) {
+        if (i >= lines.length) throw new Error("Malformed patch: hunk truncated (line counts in @@ header not satisfied)")
+        const hl = lines[i]
+        if (hl.startsWith("\\")) { i++; continue } // ""
+        const tag = hl === "" ? " " : hl[0] // 纯空行按上下文行宽容处理
+        const text = hl === "" ? "" : hl.slice(1)
+        if (tag === " ") { hunk.ops.push({ type: " ", text }); oldNeed--; newNeed-- }
+        else if (tag === "-") { hunk.ops.push({ type: "-", text }); oldNeed-- }
+        else if (tag === "+") { hunk.ops.push({ type: "+", text }); newNeed-- }
+        else throw new Error(`Malformed patch: unexpected line "${hl.slice(0, 60)}" inside hunk`)
+        i++
+      }
+      cur.hunks.push(hunk)
+      continue
+    }
+    i++ // diff --git / index / 空行等元信息跳过
+  }
+  if (files.length === 0) throw new Error("No file changes found in patch (need --- / +++ headers)")
+  return files
+}
+
+/** 在内存行数组上按序应用 hunks；任何一步失败抛错（调用方保证不落盘）。比较时忽略行尾 \r，上下文行保留原始字节 */
+function applyHunks(fileLines, hunks, eol, path) {
+  const cr = eol === "\r\n" ? "\r" : ""
+  for (let h = 0; h < hunks.length; h++) {
+    const oldSeq = hunks[h].ops.filter((o) => o.type !== "+").map((o) => o.text)
+    if (oldSeq.length === 0) throw new Error(`Hunk ${h + 1} in ${path} has no context/removed lines to locate`)
+    const matches = []
+    for (let pos = 0; pos + oldSeq.length <= fileLines.length; pos++) {
+      let ok = true
+      for (let j = 0; j < oldSeq.length; j++) {
+        if (fileLines[pos + j].replace(/\r$/, "") !== oldSeq[j]) { ok = false; break }
+      }
+      if (ok) matches.push(pos)
+    }
+    if (matches.length === 0) {
+      const preview = oldSeq.slice(0, 3).join(" ⏎ ")
+      throw new Error(`Hunk ${h + 1} in ${path} does not apply — context not found: "${preview}${oldSeq.length > 3 ? "…" : ""}". Read the file first and regenerate the patch from actual content.`)
+    }
+    if (matches.length > 1) throw new Error(`Hunk ${h + 1} in ${path} matches ${matches.length} locations — add more context lines to make it unique`)
+    const pos = matches[0]
+    const out = []
+    let src = pos
+    for (const op of hunks[h].ops) {
+      if (op.type === " ") out.push(fileLines[src++]) // 上下文保留原始行（行尾/空白原样）
+      else if (op.type === "-") src++
+      else out.push(op.text + cr)
+    }
+    fileLines.splice(pos, oldSeq.length, ...out)
+  }
+}
+
+export const applyPatchTool = {
+  name: "apply_patch",
+  description: DESC("apply_patch"),
+  parameters: {
+    type: "object",
+    properties: {
+      patch: { type: "string", description: "Unified diff. May span multiple files; --- / +++ headers per file, @@ -old,count +new,count @@ hunks. Use --- /dev/null to create a file." },
+    },
+    required: ["patch"],
+  },
+  readonly: false,
+  /** 供 agent 层追踪触碰文件（多路径，替代单 path 参数） */
+  touchedPaths(args) {
+    try { return parsePatch(args.patch ?? "").map((f) => f.path) } catch { return [] }
+  },
+  async execute(args, ctx) {
+    const files = parsePatch(args.patch ?? "")
+    // 先全部读入内存试算：任何一个 hunk 不上就整体抛错，不写半个补丁（原子性）
+    const planned = []
+    for (const f of files) {
+      const abs = resolveInCwd(ctx, f.path)
+      if (f.isNew) {
+        if (existsSync(abs)) throw new Error(`Cannot create ${f.path}: file already exists`)
+        const content = f.hunks.flatMap((h) => h.ops.filter((o) => o.type === "+").map((o) => o.text)).join("\n") + "\n"
+        planned.push({ abs, path: f.path, content, isNew: true })
+      } else {
+        const original = await readFile(abs, "utf8").catch(() => { throw new Error(`File not found: ${f.path}`) })
+        const eol = original.includes("\r\n") ? "\r\n" : "\n"
+        const lines = original.split("\n")
+        applyHunks(lines, f.hunks, eol, f.path)
+        planned.push({ abs, path: f.path, content: lines.join("\n"), isNew: false })
+      }
+    }
+    // 多文件写：先全部写 .tmp，全部成功后再 rename——任一写失败清理已写的 .tmp 不影响已落盘的文件
+    const { rename, unlink } = await import("node:fs/promises")
+    const written = []
+    try {
+      for (const p of planned) {
+        await mkdir(dirname(p.abs), { recursive: true })
+        await writeFile(p.abs + ".thincoder-tmp", p.content, "utf8")
+        written.push(p.abs)
+      }
+      for (const p of planned) {
+        await rename(p.abs + ".thincoder-tmp", p.abs)
+      }
+    } catch (renameError) {
+      // rename 阶段失败：清理残留 .tmp 文件
+      for (const abs of written) {
+        try { await unlink(abs + ".thincoder-tmp") } catch {}
+      }
+      throw renameError
+    }
+    const summary = planned.map((p) => `  ${p.isNew ? "created " : "modified"} ${p.path}`).join("\n")
+    const syntaxResults = planned.map((p) => {
+      const r = autoSyntaxCheck(p.abs)
+      return r ? `${p.path}:${r.replace("Syntax: ", "")}` : ""
+    }).filter(Boolean).join("\n")
+    return `Applied patch to ${planned.length} file(s):\n${summary}${syntaxResults ? "\n\nSyntax checks:\n" + syntaxResults : ""}`
+  },
+}
+
+// ---------------------------------------------------------------- syntax_check
+
+export const syntaxCheckTool = {
+  name: "syntax_check",
+  description: DESC("syntax_check"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path (.js/.mjs/.cjs only)" },
+    },
+    required: ["path"],
+  },
+  readonly: true,
+  execute(args, ctx) {
+    const abs = resolveInCwd(ctx, args.path)
+    if (!/\.(?:[mc]?js)$/.test(abs)) {
+      return `syntax_check only supports .js/.mjs/.cjs files; ${args.path} skipped.`
+    }
+    try {
+      execFileSync(process.execPath, ["--check", abs], {
+        cwd: ctx.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"],
+      })
+      return `Syntax OK: ${args.path}`
+    } catch (e) {
+      // node --check 把错误写到 stderr
+      const msg = (e.stderr || e.stdout || e.message || "").trim()
+      return `Syntax error in ${args.path}:\n${msg || "(unknown)"}`
+    }
+  },
+}
+
+// ---------------------------------------------------------------- bash
+
+export const deleteTool = {
+  name: "delete",
+  description: DESC("delete"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path (relative to cwd or absolute)" },
+      force: { type: "boolean", description: "Allow deleting git-tracked files (default false)" },
+    },
+    required: ["path"],
+  },
+  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)
+    if (s.isDirectory()) throw new Error(`"${args.path}" is a directory — use bash to remove directories`)
+    // git 跟踪文件拒绝直接删除（安全网）；未跟踪的放行
+    // 用解析后的相对路径（统一正斜杠），防反斜杠/非常规路径绕过 ls-files 匹配
+    const rel = relative(ctx.cwd, abs).replace(/\\/g, "/")
+    let tracked = false
+    try {
+      execFileSync("git", ["ls-files", "--error-unmatch", "--", rel], { cwd: ctx.cwd, stdio: "ignore" })
+      tracked = true
+    } catch {
+      // 未跟踪 / 非 git 仓库
+    }
+    if (tracked && !args.force) throw new Error(`"${args.path}" is git-tracked. Set force=true to delete anyway.`)
+    await unlink(abs)
+    return `Deleted ${args.path}`
+  },
+}
+
+// ---------------------------------------------------------------- git_diff

package/src/tools/repomap-parse.mjs

@@ -0,0 +1,168 @@
+/**
+ * repomap-parse.mjs — 仓库依赖图解析（零依赖，纯 regex）
+ * 从 code_chunks 取已知文件列表，实时解析每个文件的 import/export 关系，
+ * 构建正向依赖图 + 反向引用图。被 repomap.mjs 的 buildSummary / buildOutline 共用。
+ */
+import { readFileSync, existsSync } from "node:fs"
+import { join } from "node:path"
+
+/**
+ * 扫描全量文件，构建正向依赖图 + 反向引用图。
+ * 返回 { deps, importers, fileCount } 供 buildOutline / buildSummary 共用。
+ */
+export function buildDepGraph(db, cwd) {
+  const allFiles = db.prepare(`SELECT DISTINCT path FROM code_chunks ORDER BY path`).all().map((r) => r.path)
+  if (allFiles.length === 0) return null
+
+  const deps = new Map()      // path → { imports: Set, exports: Set, size: number, dir: string }
+  const importers = new Map() // importee → Set<importer>
+
+  for (const rel of allFiles) {
+    const abs = join(cwd, ...rel.split("/"))
+    if (!existsSync(abs)) continue
+    const text = readFileSync(abs, "utf8")
+    const lines = text.split("\n")
+    const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
+
+    let imports, exports
+    if (ext === ".py") {
+      const py = parsePyOutline(lines)
+      imports = py.imports
+      exports = py.symbols
+    } else {
+      imports = parseImports(lines, ext)
+      exports = parseExports(lines, ext)
+    }
+
+    // 把 import 路径解析成相对路径（处理 ./ ../）
+    const resolved = []
+    for (let imp of imports) {
+      if (imp.startsWith("./")) imp = imp.slice(2)
+      const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : ""
+      const parts = imp.split("/")
+      if (parts[0] === "..") {
+        const up = dir.split("/").filter(Boolean)
+        let i = 0
+        while (parts[i] === ".." && up.length > 0) { up.pop(); i++ }
+        resolved.push([...up, ...parts.slice(i)].join("/"))
+      } else {
+        resolved.push(dir ? `${dir}/${imp}` : imp)
+      }
+    }
+
+    const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "."
+    deps.set(rel, { imports: new Set(resolved), exports: new Set(exports), size: Math.floor(text.length / 1024), dir })
+
+    for (const r of resolved) {
+      if (!importers.has(r)) importers.set(r, new Set())
+      importers.get(r).add(rel)
+    }
+  }
+
+  return { deps, importers, fileCount: allFiles.length }
+}
+
+// ---------------------------------------------------------- 内部实现
+
+function normalizeExt(p) {
+  return p.replace(/\.(m?js|jsx|tsx?)$/i, "")
+}
+
+/** 提取 JS/TS 文件的 import 路径（去掉 .ts/.js/.mjs 后缀统一） */
+function parseImports(lines, ext) {
+  const imports = []
+  const text = lines.join("\n")
+  // 普通 import
+  const re = /import\s+(?:{[^}]*}|\*\s+as\s+\w+|\w+\s*,?\s*(?:{[^}]*})?)\s*from\s*['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/g
+  let m
+  while ((m = re.exec(text))) {
+    const raw = m[1] || m[2]
+    if (!raw || raw.startsWith("node:") || !raw.startsWith(".")) continue
+    imports.push(normalizeExt(raw))
+  }
+  // re-export: export { x } from './module'
+  const reExportRe = /export\s*\{[^}]*\}\s*from\s*['"]([^'"]+)['"]/g
+  while ((m = reExportRe.exec(text))) {
+    const raw = m[1]
+    if (!raw || raw.startsWith("node:") || !raw.startsWith(".")) continue
+    imports.push(normalizeExt(raw))
+  }
+  return [...new Set(imports)]
+}
+
+/** 提取 JS/TS 文件的 export 符号 */
+function parseExports(lines, ext) {
+  const exports = []
+  const text = lines.join("\n")
+  // export function/class/const/let/var name
+  const namedRe = /export\s+(?:async\s+)?(?:function\s+(\w+)|class\s+(\w+)|(?:const|let|var)\s+(\w+))/g
+  let m
+  while ((m = namedRe.exec(text))) {
+    exports.push(m[1] || m[2] || m[3])
+  }
+  // export default function/class name / export default expression
+  const defaultRe = /export\s+default\s+(?:(?:async\s+)?(?:function\s+(\w+)|class\s+(\w+))|(\w+))/g
+  while ((m = defaultRe.exec(text))) {
+    const name = m[1] || m[2] || m[3]
+    if (name) exports.push(name)
+    else if (!exports.some((e) => e === "default")) exports.push("default")
+  }
+  // export { a, b as c } —— 优先取 as 后的导出名
+  const braceRe = /export\s*\{([^}]+)\}/g
+  while ((m = braceRe.exec(text))) {
+    for (const name of m[1].split(",")) {
+      const parts = name.trim().split(/\s+/)
+      // "a as b" → b（导出名），"a" → a
+      const exported = parts.length >= 3 ? parts[2] : parts[0]
+      if (exported) exports.push(exported)
+    }
+  }
+  // export const { a, b } = ...（解构导出）
+  const destructRe = /export\s+(?:const|let|var)\s*\{([^}]+)\}\s*=/g
+  while ((m = destructRe.exec(text))) {
+    for (const name of m[1].split(",")) {
+      const parts = name.trim().split(/\s*:\s*/)
+      const n = parts[0].trim()
+      if (n) exports.push(n)
+    }
+  }
+  return [...new Set(exports)]
+}
+
+/** 提取 Python 的 import 和顶层 def/class */
+function parsePyOutline(lines) {
+  const imports = []
+  const symbols = []
+  for (const line of lines) {
+    const fromRe = line.match(/^from\s+(\S+)\s+import\s+(.+)/)
+    if (fromRe) {
+      const rel = pyRelPath(fromRe[1])
+      if (rel) imports.push(rel)
+      continue
+    }
+    const impRe = line.match(/^import\s+(.+)/)
+    if (impRe) {
+      for (const mod of impRe[1].split(",")) {
+        const rel = pyRelPath(mod.trim().split(/\s+/)[0])
+        if (rel) imports.push(rel)
+      }
+      continue
+    }
+    const defRe = line.match(/^(?:async\s+)?(?:def|class)\s+(\w+)/)
+    if (defRe) symbols.push(defRe[1])
+  }
+  return { imports: [...new Set(imports)], symbols: [...new Set(symbols)] }
+}
+
+/**
+ * Python 相对导入 → 相对文件路径：
+ * 前导 n 个点表示上溯 n-1 层（"."=当前包），模块点号转路径分隔符。
+ * 非相对导入（不以 . 开头）或纯包导入（"from . import x"）返回 null。
+ */
+function pyRelPath(mod) {
+  if (!mod?.startsWith(".")) return null
+  const dots = mod.match(/^\.+/)[0].length
+  const rest = mod.slice(dots).replaceAll(".", "/")
+  if (!rest) return null
+  return normalizeExt("../".repeat(dots - 1) + rest)
+}

package/src/tools/shared.mjs

@@ -0,0 +1,257 @@
+/**
+ * tools/shared.mjs — 共享工具函数、常量、OpenAI schema 转换
+ * 被 tools/file.mjs / system.mjs / web.mjs / git.mjs 导入
+ */
+
+import { spawn, execFileSync } from "node:child_process"
+import { readFileSync, existsSync, realpathSync } from "node:fs"
+import { dirname, join, resolve, relative, isAbsolute, sep } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+export const DESC = (name) => readFileSync(join(__dirname, "..", "tools", `${name}.md`), "utf8")
+
+export const MAX_READ_LINES = 2000
+export const MAX_OUTPUT_CHARS = 200_000
+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"])
+
+/** 转成 OpenAI tools 参数格式 */
+export function toOpenAISchema(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+    },
+  }
+}
+
+/** 剥离 ANSI 转义序列 */
+export function sanitizeOutput(s) {
+  return s
+    .replace(/\x1b\[[0-9;?]*[\x40-\x7E]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-B]|\x1b[=>#][0-9]?/g, "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+}
+
+export function truncate(text, max = MAX_OUTPUT_CHARS) {
+  if (text.length <= max) return text
+  return text.slice(0, max) + `\n[... truncated: ${text.length - max} chars omitted — redirect to a file if you need the full output]`
+}
+
+/** 限量读取响应体 */
+export async function readBodyText(response, limit = MAX_RESPONSE_BODY_BYTES) {
+  if (!response.body) return ""
+  const reader = response.body.getReader()
+  const chunks = []
+  let total = 0
+  try {
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      if (value) { chunks.push(value); total += value.length }
+      if (total >= limit) { await reader.cancel(); break }
+    }
+  } finally { reader.releaseLock() }
+  return new TextDecoder("utf-8").decode(Buffer.concat(chunks))
+}
+
+/** 流解码器：编码嗅探 ASCII→UTF-8→GBK */
+export function makeDecoder() {
+  let decoder = null
+  let pending = Buffer.alloc(0)
+  return (d, flush = false) => {
+    pending = Buffer.concat([pending, d])
+    if (!decoder) {
+      const hasHighByte = pending.some((b) => b >= 0x80)
+      if (!hasHighByte) { const s = pending.toString("ascii"); pending = Buffer.alloc(0); return s }
+      for (let trim = 0; trim <= 3 && !decoder; trim++) {
+        try { new TextDecoder("utf-8", { fatal: true }).decode(pending.subarray(0, pending.length - trim)); decoder = new TextDecoder("utf-8") }
+        catch { /* continue */ }
+      }
+      if (!decoder) decoder = new TextDecoder("gbk")
+    }
+    const s = decoder.decode(pending, { stream: !flush })
+    pending = Buffer.alloc(0)
+    return s
+  }
+}
+
+/** 单文件 git diff，失败静默返回空。大 diff 超 maxBuffer 时截断而非吞掉 */
+export function gitDiffOne(cwd, abs) {
+  try {
+    const diff = execFileSync("git", ["--no-pager", "diff", "--no-color", "--", abs], {
+      cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 10 * 1024 * 1024,
+    }).trim()
+    if (!diff) return ""
+    const lines = diff.split("\n")
+    if (lines.length <= 200) return diff
+    return lines.slice(0, 200).join("\n") + `\n... (${lines.length - 200} more diff lines)`
+  } catch (e) {
+    // maxBuffer 溢出时 e.stdout 含已收集的部分；其他错误（非 git 仓库等）返回空
+    if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" && e.stdout) {
+      const lines = e.stdout.toString().split("\n")
+      return lines.slice(0, 200).join("\n") + `\n... (diff too large, showing first 200 of more lines)`
+    }
+    return ""
+  }
+}
+
+/** 文件变更后自动语法检查 */
+export function autoSyntaxCheck(abs) {
+  if (!/\.(m?js)$/i.test(abs)) return ""
+  try {
+    execFileSync("node", ["--check", abs], { stdio: ["ignore", "pipe", "pipe"], timeout: 10000 })
+    return "\nSyntax: OK"
+  } catch (e) {
+    const err = (e.stderr || e.stdout || e.message || "").toString().split("\n").slice(0, 3).join("\n")
+    return `\nSyntax: FAILED — ${err}`
+  }
+}
+
+/** 逐级向上找真实路径 */
+export function realpathNearest(abs) {
+  let cur = abs
+  const tail = []
+  while (!existsSync(cur)) {
+    const parent = dirname(cur)
+    if (parent === cur) return abs
+    tail.unshift(cur.slice(parent.length + 1))
+    cur = parent
+  }
+  try { const real = realpathSync(cur); return tail.length ? join(real, ...tail) : real }
+  catch { return abs }
+}
+
+const realCwdCache = new Map()
+export function realCwd(cwd) {
+  if (!realCwdCache.has(cwd)) realCwdCache.set(cwd, realpathNearest(resolve(cwd)))
+  return realCwdCache.get(cwd)
+}
+
+export function assertInside(cwd, resolved, p) {
+  const rel = relative(cwd, resolved)
+  if (isAbsolute(rel) || rel === ".." || rel.startsWith(".." + sep)) {
+    throw new Error(`Access denied outside working directory: ${p}`)
+  }
+}
+
+export function resolveInCwd(ctx, p) {
+  const cwd = realCwd(ctx.cwd)
+  const resolved = resolve(cwd, p)
+  assertInside(cwd, resolved, p)
+  const real = realpathNearest(resolved)
+  assertInside(cwd, real, p)
+  return resolved
+}
+
+/** 破坏性预检用的粗切分（也切 > >> <，使段内破坏性检测在重定向时仍生效） */
+export function shellSegments(command) {
+  return command.split(/&&|\|\||>>|\$\(|[;|\n<>]|`|[(]/)
+}
+
+/** 检测 shell 输出/输入重定向（> >> < 后跟文件名）——引号内未排除，保守拦截 */
+export function hasFileRedirection(command) {
+  return /(^|[\s;&|])>{1,2}\s*\S/.test(command) || /(^|[\s;&|])<\s*\S/.test(command)
+}
+
+/** 单命令段是否为破坏性非 git 命令（保守：宁可误拦） */
+export function isDestructiveCommand(seg) {
+  const s = seg
+  // rm 同时带递归(-r/-R)与强制(-f)标志：-rf / -fr / -r -f / -Rf 等
+  if (/\brm\b/.test(s) && /\s-\S*r/i.test(s) && /\s-\S*f/i.test(s)) return true
+  if (/\brmdir\b/i.test(s)) return true
+  if (/\bdel\b/i.test(s) && /\/f\b/i.test(s)) return true
+  if (/\brd\b/i.test(s) && /\/s\b/i.test(s)) return true
+  // format 作为命令调用（排除 --format= 之类的选项误报）
+  if (/\bformat\b\s+\S/i.test(s) && !/--format\b/i.test(s)) return true
+  if (/\bshred\b/i.test(s)) return true
+  if (/\bdd\b/.test(s) && /\bof=/i.test(s)) return true
+  if (/\bDROP\s+TABLE\b/i.test(s)) return true
+  if (/\bDELETE\s+FROM\b/i.test(s)) return true
+  if (/\bTRUNCATE\b/i.test(s)) return true
+  return false
+}
+
+/** 单命令段是否销毁未提交改动 */
+export function isDestructiveGitSegment(seg) {
+  if (!/^\s*git\s/.test(seg)) return false
+  if (/\scheckout\s+(?:--|\.(?:\s|$))/.test(seg)) return true
+  if (/\sreset\s+--hard\b/.test(seg)) return true
+  if (/\sclean\s+-\S*f/.test(seg)) return true
+  if (/\srestore\s/.test(seg) && (/--worktree/.test(seg) || !/--staged/.test(seg))) return true
+  return false
+}
+
+/** cwd 是否在 git 仓库内 */
+export function insideGitRepo(cwd) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
+    })
+    return true
+  } catch { return false }
+}
+
+/** glob 转正则 */
+export function globToRegex(pattern) {
+  const DS = "\u0001", DP = "\u0002"
+  const escaped = pattern
+    .replace(/\*\*\//g, DS).replace(/\*\*/g, DP)
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")
+    .replace(new RegExp(DS, "g"), "(?:.+/)?")
+    .replace(new RegExp(DP, "g"), ".*")
+  return new RegExp(`^${escaped}$`)
+}
+
+/** 剥 HTML 标签 */
+export function stripTags(html) {
+  return html
+    .replace(/<[^>]+>/g, "")
+    .replace(/&#0*(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+    .replace(/&nbsp;|&ensp;/g, " ")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&amp;/g, "&")
+    .replace(/\s+/g, " ")
+    .trim()
+}
+
+/** HTML → 粗文本：去脚本样式、块级标签换行、剥标签、解码实体、压缩空行 */
+export function htmlToText(html) {
+  return html
+    .replace(/<script[\s\S]*?<\/script>/gi, "")
+    .replace(/<style[\s\S]*?<\/style>/gi, "")
+    .replace(/<noscript[\s\S]*?<\/noscript>/gi, "")
+    .replace(/<\/(p|div|li|ul|ol|h[1-6]|tr|table|section|article|header|footer|blockquote|pre)>/gi, "\n")
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<li[^>]*>/gi, "- ")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&#0*(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+    .replace(/&nbsp;|&ensp;/g, " ")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&amp;/g, "&") // &amp; 必须最后解码，否则 &amp;lt; 会被二次解码成 <
+    .replace(/[ \t]+/g, " ")
+    .replace(/\n\s*\n\s*\n+/g, "\n\n")
+    .trim()
+}
+
+/** 执行 git 命令。maxBuffer 10MB 防大 diff/log 溢出；溢出时返回截断的部分输出而非空。 */
+export function runGit(cwd, cmdArgs) {
+  try {
+    return execFileSync("git", cmdArgs, { cwd, encoding: "utf8", maxBuffer: 10 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }).trim().replace(/\r/g, "")
+  } catch (e) {
+    // ERR_CHILD_PROCESS_STDIO_MAXBUFFER 时 e.stdout 含部分输出，截取前 200 行返回
+    if (e.stdout) return String(e.stdout).trim().replace(/\r/g, "").split("\n").slice(0, 200).join("\n")
+    return ""
+  }
+}