thincoder 0.12.37 → 0.12.39

package/src/tools/get_current_time.md

@@ -0,0 +1,6 @@
+Get the current date, time, weekday, and timezone.
+
+**Route to get_current_time instead of bash:**
+- `date` / `time` → get_current_time
+
+Use it whenever a task depends on the current time or date (deadlines, freshness, timestamps) rather than shelling out.

package/src/tools/git.md

@@ -2,14 +2,20 @@ Run a git command. Use this to see uncommitted changes, staged changes, diff aga
 - action='diff': Show unified diff — what changed since last commit. Set staged=true for staged-only diff, ref=<ref> to compare against a specific commit/branch, path=<dir> to scope to a file or directory.
 - action='status': Show working tree state — staged, unstaged, untracked files, and conflicts. Returns categorized lists.
 - action='log': Show recent commit history. Set count to limit, oneline=true for compact format, path=<file> to see history of one file.
+- action='show': Show a commit's details (--stat). Set ref=<ref> to inspect a specific commit (default HEAD).
 - action='checkpoint': Manage git-based snapshots. Use checkpointAction to choose: list (overview), create (snapshot now), rewind (restore snapshot by id), cat (read a file from a snapshot).
+- action='rm': Untrack a file/directory (git rm --cached — keeps the file on disk). path is required.
+- action='commit': Stage all changes and commit. message is required. Confirms with the user (outward action).
+- action='push': Push the current branch to the remote. Confirms with the user (outward action).
 
 Parameters:
-- action (required): diff / status / log / checkpoint
+- action (required): diff / status / log / show / checkpoint / rm / commit / push
 - staged: (diff) Show staged changes instead of working tree
-- path: (diff/log/checkpoint:cat/checkpoint:rewind) File or directory to scope to
-- ref: (diff) Compare against this ref (default HEAD)
+- path: (diff/log/checkpoint:cat/checkpoint:rewind/rm) File or directory to scope to
+- ref: (show) Commit ref to inspect (default HEAD)
 - count: (log) Number of commits (default 10)
 - oneline: (log) One-line-per-commit format
+- message: (commit) Commit message — required for commit
+- filter: Optional — keep only status/diff/log output lines matching this regex (case-insensitive)
 - checkpointAction: (checkpoint) list snapshots / create one / restore by id / read file from snapshot
-- checkpointId: (checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)
+- checkpointId: (checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)

package/src/tools/git.mjs

@@ -7,19 +7,44 @@ import { escapeXml } from "../agent/helpers.mjs";
 import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 
+/** Keep only output lines matching a regex (git filter, case-insensitive). */
+function filterLines(output, filter) {
+  if (!filter) return output
+  try {
+    const re = new RegExp(filter, "i")
+    const lines = output.split("\n").filter((l) => re.test(l))
+    return lines.length ? lines.join("\n") : `(no lines matched filter "${filter}")`
+  } catch (e) {
+    return `Error: filter regex invalid: ${e.message}`
+  }
+}
+
+/** Run git and report failure (stderr + exit code) instead of swallowing it.
+ *  Used by write ops (commit/push/rm) where a silent "" would masquerade as success. */
+function runGitStrict(cwd, cmdArgs) {
+  try {
+    const out = execFileSync("git", cmdArgs, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim().replace(/\r/g, "")
+    return { ok: true, out }
+  } catch (e) {
+    return { ok: false, out: String(e.stdout || "").trim(), err: String(e.stderr || e.message || "").trim() }
+  }
+}
+
 export const gitTool = {
   name: "git",
   description: DESC("git"),
   parameters: {
     type: "object",
     properties: {
-      action: { type: "string", enum: ["diff", "status", "log", "checkpoint"], description: "diff / status / log / checkpoint" },
+      action: { type: "string", enum: ["diff", "status", "log", "show", "checkpoint", "rm", "commit", "push"], description: "diff / status / log / show / checkpoint / rm / commit / push" },
       // diff/log params
       staged: { type: "boolean", description: "(diff) Show staged changes instead of working tree" },
-      path: { type: "string", description: "(diff/log/checkpoint:cat/versions/rewind) File or directory to scope to" },
-      ref: { type: "string", description: "(diff) Compare against this ref (default HEAD)" },
+      path: { type: "string", description: "(diff/log/checkpoint:cat/versions/rewind/rm) File or directory to scope to" },
+      ref: { type: "string", description: "(show) Commit ref to show (default HEAD)" },
       count: { type: "number", description: "(log) Number of commits (default 10)" },
       oneline: { type: "boolean", description: "(log) One-line-per-commit format" },
+      message: { type: "string", description: "(commit) Commit message — required for commit" },
+      filter: { type: "string", description: "Optional: keep only status/diff/log output lines matching this regex (case-insensitive)" },
       // checkpoint params
       checkpointAction: { type: "string", enum: ["list", "create", "rewind", "cat", "versions"], description: "(checkpoint) list snapshots / create one / restore by id / read file from snapshot / list a file's historical versions" },
       checkpointId: { type: "string", description: "(checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)" },
@@ -35,7 +60,7 @@ export const gitTool = {
         const flags = args.staged ? ["--staged"] : []
         const paths = args.path ? [args.path] : []
         const out = runGit(ctx.cwd, ["diff", ...flags, ref, "--", ...paths])
-        return truncate(out || "(no changes)")
+        return truncate(filterLines(out || "(no changes)", args.filter))
       }
       case "status": {
         const porcelain = runGit(ctx.cwd, ["status", "--porcelain"])
@@ -68,17 +93,44 @@ export const gitTool = {
         if (unstaged.length) parts.push("Unstaged (" + unstaged.length + "):\n" + unstaged.join("\n"))
         if (untracked.length) parts.push("Untracked (" + untracked.length + "):\n" + untracked.join("\n"))
         if (conflicts.length) parts.push("Conflicts (" + conflicts.length + "):\n" + conflicts.join("\n"))
-        return truncate(parts.join("\n\n"))
+        return truncate(filterLines(parts.join("\n\n"), args.filter))
       }
       case "log": {
-        const n = Math.min(Math.max(1, args.count ?? 10), 200)
+        const parsed = Number.parseInt(args.count, 10)
+        const n = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 10
         const isOneline = args.oneline
         const cmdArgs = isOneline
           ? ["log", "-" + n, "--oneline"]
           : ["log", "-" + n, "--format=%h %ad %an %s", "--date=short"]
         if (args.path) cmdArgs.push("--", args.path)
         const out = runGit(ctx.cwd, cmdArgs)
-        return truncate(out || "(no commits)")
+        return truncate(filterLines(out || "(no commits)", args.filter))
+      }
+      case "show": {
+        const ref = args.ref ?? "HEAD"
+        if (!/^[A-Za-z0-9._\/~^@][A-Za-z0-9._\/~^@{}\-]*$/.test(ref)) throw new Error(`Invalid git ref: ${ref}`)
+        const out = runGit(ctx.cwd, ["show", "--stat", ref])
+        return truncate(out || "(no such commit)")
+      }
+      case "rm": {
+        if (!args.path) return "Error: rm requires path (the file/directory to untrack, relative to repo root)"
+        const r = runGitStrict(ctx.cwd, ["rm", "--cached", "-r", "--", args.path])
+        return r.ok ? truncate(r.out || `Untracked ${args.path} (kept on disk)`) : truncate(`git rm failed: ${r.err || r.out}`)
+      }
+      case "commit": {
+        if (!args.message) return "Error: commit requires message"
+        const add = runGitStrict(ctx.cwd, ["add", "-A"])
+        if (!add.ok) return truncate(`git add failed: ${add.err || add.out || "(no output)"}`)
+        const commit = runGitStrict(ctx.cwd, ["commit", "-m", args.message])
+        const parts = []
+        if (add.out) parts.push(add.out)
+        if (commit.ok) { if (commit.out) parts.push(commit.out) }
+        else parts.push(`git commit failed: ${commit.err || "(no output)"}`)
+        return truncate(parts.join("\n") || "(commit produced no output)")
+      }
+      case "push": {
+        const r = runGitStrict(ctx.cwd, ["push"])
+        return r.ok ? truncate(r.out || "(push complete — no output)") : truncate(`git push failed: ${r.err || r.out || "(no output)"}`)
       }
       case "checkpoint": {
         const { createCheckpoint, listCheckpoints, rewind, listFileVersions, isGitRepo } = await import("../git/checkpoint.mjs")
@@ -139,7 +191,7 @@ export const gitTool = {
         throw new Error(`Unknown checkpoint action: ${sub}. Use: list | create | rewind | cat | versions`)
       }
       default:
-        return `Unknown action '${args.action}'. Use: diff | status | log | checkpoint`
+        return `Unknown action '${args.action}'. Use: diff | status | log | show | checkpoint | rm | commit | push`
     }
   },
 }

package/src/tools/grep.md

@@ -1,9 +1,11 @@
 Search file contents with a regex. Returns matching lines as path:line: content.
 
 Parameters:
-- pattern (required): JavaScript regular expression
+- pattern (required): JavaScript regular expression, or a literal string when literal=true
 - path: Directory or file to search (default cwd)
 - glob: Only search files matching this glob (e.g. '*.mjs')
+- ignoreCase: Case-insensitive match (default false)
+- literal: Literal string match — no regex interpretation (default false; use for strings with `. \` etc.)
 - before: Lines of context to show before each match (grep -B). Default 0
 - after: Lines of context to show after each match (grep -A). Default 0
 

package/src/tools/index.mjs

@@ -10,6 +10,8 @@ import { checklistTool } from "./checklist.mjs";
 import { lintTool } from "./linter.mjs";
 import { lspTool } from "./lsp.mjs";
 import { codeModeTool } from "./codemode.mjs";
+import { fileOpsTool, processTool, getCurrentTimeTool, sleepTool } from "./ops.mjs";
+import { treeTool } from "./tree.mjs";
 
 export const builtinTools = [
   readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
@@ -17,6 +19,8 @@ export const builtinTools = [
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, codeModeTool,
+  fileOpsTool, processTool, getCurrentTimeTool, sleepTool,
+  treeTool,
 ];
 
 export {
@@ -25,4 +29,6 @@ export {
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, codeModeTool,
-};
+  fileOpsTool, processTool, getCurrentTimeTool, sleepTool,
+  treeTool,
+};

package/src/tools/ls.md

@@ -2,6 +2,7 @@ List directory contents with type, size, and modification time. Directories list
 
 Parameters:
 - path: Directory path (default cwd)
+- filter: Only list entries matching this glob (e.g. '*.mjs', '*test*') — a wildcard filter, not a full listing
 
 Notes:
 - Shows first 500 entries

package/src/tools/ops.mjs

@@ -0,0 +1,142 @@
+/**
+ * ops.mjs — operational tools: file_ops (move/copy/rename), process (list),
+ * get_current_time, sleep. Each exists so the model reaches for a dedicated tool
+ * instead of shelling out to `bash` for the same operation (parity with thinworker).
+ */
+import { DESC, resolveInCwd, truncate } from "./shared.mjs"
+import { cp, rename, rm } from "node:fs/promises"
+import { execFileSync } from "node:child_process"
+
+// ─── file_ops ──────────────────────────────────────────────────
+
+export const fileOpsTool = {
+  name: "file_ops",
+  description: DESC("file_ops"),
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["move", "copy", "rename"], description: "move | copy | rename" },
+      source: { type: "string", description: "Source path, relative to cwd or absolute" },
+      dest: { type: "string", description: "Destination path" },
+    },
+    required: ["action", "source", "dest"],
+  },
+  readonly: false,
+  async execute({ action, source, dest }, ctx) {
+    if (typeof source !== "string" || !source) return "Error: source is required"
+    if (typeof dest !== "string" || !dest) return "Error: dest is required"
+    if (!["move", "copy", "rename"].includes(action)) return `Error: action must be move | copy | rename (got "${action}")`
+    const src = resolveInCwd(ctx, source)
+    const dst = resolveInCwd(ctx, dest)
+    if (src === dst) return "Error: source and dest resolve to the same path"
+
+    if (action === "copy") {
+      await cp(src, dst, { recursive: true, force: true })
+      return `Copied ${source} → ${dest}`
+    }
+    // move & rename share the rename syscall; cross-device move falls back to copy+rm.
+    try {
+      await rename(src, dst)
+    } catch (e) {
+      if (e?.code !== "EXDEV") throw e
+      await cp(src, dst, { recursive: true, force: true })
+      await rm(src, { recursive: true, force: true })
+    }
+    return `${action === "rename" ? "Renamed" : "Moved"} ${source} → ${dest}`
+  },
+}
+
+// ─── process ───────────────────────────────────────────────────
+
+export const processTool = {
+  name: "process",
+  description: DESC("process"),
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Optional name substring filter (case-insensitive)" },
+    },
+  },
+  readonly: true,
+  async execute({ name }, ctx) {
+    const filter = typeof name === "string" && name.trim() ? name.trim().toLowerCase() : null
+    let rows
+    try {
+      rows = process.platform === "win32" ? listWindows() : listPosix()
+    } catch (e) {
+      return `process listing failed: ${e?.message ?? String(e)}`
+    }
+    if (filter) rows = rows.filter((r) => r.name.toLowerCase().includes(filter))
+    if (rows.length === 0) return filter ? `No running processes match "${name}"` : "(no processes)"
+    return truncate(rows.map((r) => `${r.name}\tPID ${r.pid}${r.mem ? `\t${r.mem}` : ""}`).join("\n"))
+  },
+}
+
+function listWindows() {
+  // tasklist /FO CSV /NH → lines: "name.exe","1234","Console","1","12,345 K"
+  const out = execFileSync("tasklist", ["/FO", "CSV", "/NH"], { encoding: "utf8", timeout: 10000 })
+  const rows = []
+  for (const line of out.split("\n")) {
+    const parts = line.split('","')
+    if (parts.length < 2) continue
+    const name = parts[0].replace(/^"/, "").trim()
+    const pid = parts[1].replace(/"/, "").trim()
+    const mem = parts[4] ? parts[4].replace(/"/, "").trim() : ""
+    if (!name || !pid) continue
+    rows.push({ name, pid, mem })
+  }
+  return rows
+}
+
+function listPosix() {
+  const out = execFileSync("ps", ["-eo", "pid=,comm="], { encoding: "utf8", timeout: 10000 })
+  const rows = []
+  for (const line of out.split("\n")) {
+    const m = line.trim().match(/^(\d+)\s+(.+)$/)
+    if (m) rows.push({ name: m[2], pid: m[1], mem: "" })
+  }
+  return rows
+}
+
+// ─── get_current_time ──────────────────────────────────────────
+
+export const getCurrentTimeTool = {
+  name: "get_current_time",
+  description: DESC("get_current_time"),
+  parameters: { type: "object", properties: {} },
+  readonly: true,
+  async execute() {
+    const now = new Date()
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone ?? "unknown"
+    const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+    return `Date: ${now.toISOString()} (UTC)\nTimezone: ${tz}\nWeekday: ${days[now.getDay()]}\nLocal: ${now.toLocaleString()}`
+  },
+}
+
+// ─── sleep ─────────────────────────────────────────────────────
+
+export const sleepTool = {
+  name: "sleep",
+  description: DESC("sleep"),
+  parameters: {
+    type: "object",
+    properties: {
+      seconds: { type: "number", description: "Seconds to wait (1-300)" },
+      reason: { type: "string", description: "Why wait (shown to the user)" },
+    },
+    required: ["seconds"],
+  },
+  readonly: true,
+  async execute({ seconds, reason }, ctx) {
+    const raw = Number(seconds)
+    const n = Number.isFinite(raw) ? Math.min(Math.max(Math.round(raw), 1), 300) : 1
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(resolve, n * 1000)
+      if (ctx?.signal) {
+        if (ctx.signal.aborted) { clearTimeout(t); reject(new Error("aborted")) }
+        else ctx.signal.addEventListener("abort", () => { clearTimeout(t); reject(new Error("aborted")) }, { once: true })
+      }
+    })
+    return `Waited ${n}s${reason ? ` (${reason})` : ""}`
+  },
+}

package/src/tools/process.md

@@ -0,0 +1,10 @@
+List running processes, optionally filtered by name. Returns process name / PID / memory.
+
+**Route to process instead of bash:**
+- `tasklist` (Windows) / `ps aux` (POSIX) → process
+
+Parameters:
+- name (optional): substring filter (case-insensitive), e.g. "node", "python"
+
+Notes:
+- List-only. To kill a process, use `bash taskkill /PID <pid> /F` (Windows) or `bash kill <pid>` — and confirm with the user first.

package/src/tools/sleep.md

@@ -0,0 +1,5 @@
+Wait a number of seconds before continuing. Use to wait for a web page to load, an async task to finish, or to respect a rate limit — cheaper than repeatedly polling.
+
+Parameters:
+- seconds (required): how many seconds to wait (1-300)
+- reason (optional): why you are waiting (shown to the user)

package/src/tools/system.mjs

@@ -17,6 +17,20 @@ import { join } from "node:path";
 /** Maximum buffer size per stream (stdout / stderr) before truncation */
 const MAX_STREAM_BUF = 2_000_000
 
+/** Escape a string for literal regex matching (grep literal=true). */
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+/** Keep only output lines matching a regex (bash filter, case-insensitive). */
+function applyLineFilter(output, filter) {
+  let re
+  try { re = new RegExp(filter, "i") } catch (e) { return `Error: filter regex invalid: ${e.message}` }
+  const lines = output.split("\n").filter((l) => re.test(l))
+  if (lines.length === 0) return `(no output lines matched filter "${filter}")`
+  return truncate(lines.join("\n"))
+}
+
 // ====================================================================
 // bash — command execution with safety gates
 // ====================================================================
@@ -223,6 +237,7 @@ export const bashTool = {
     properties: {
       command: { type: "string", description: "Shell command to execute" },
       timeout: { type: "number", description: `Timeout in ms (default ${BASH_TIMEOUT_MS})` },
+      filter: { type: "string", description: "Optional: only return output lines matching this regex (case-insensitive)" },
     },
     required: ["command"],
   },
@@ -241,7 +256,8 @@ export const bashTool = {
       onOutput: ctx.onOutput,
       shell: ctx.agent?.config?.shell ?? null,
     })
-    return guard ? `${guard.notice}\n\n${result}` : result
+    const filtered = args.filter ? applyLineFilter(result, args.filter) : result
+    return guard ? `${guard.notice}\n\n${filtered}` : filtered
   },
 }
 
@@ -305,9 +321,11 @@ export const grepTool = {
   parameters: {
     type: "object",
     properties: {
-      pattern: { type: "string", description: "Regular expression" },
+      pattern: { type: "string", description: "Regular expression, or a literal string when literal=true" },
       path: { type: "string", description: "Directory or file to search (default cwd)" },
       glob: { type: "string", description: "Only search files matching this glob (e.g. '*.mjs')" },
+      ignoreCase: { type: "boolean", description: "Case-insensitive match (default false)" },
+      literal: { type: "boolean", description: "Literal string match — no regex interpretation (default false)" },
       before: { type: "integer", description: "Lines of context to show before each match (grep -B). Default 0" },
       after: { type: "integer", description: "Lines of context to show after each match (grep -A). Default 0" },
     },
@@ -318,7 +336,8 @@ export const grepTool = {
     const base = resolveInCwd(ctx, args.path ?? ".")
     let regex
     try {
-      regex = new RegExp(args.pattern)
+      const pat = args.literal ? escapeRegExp(String(args.pattern)) : args.pattern
+      regex = new RegExp(pat, args.ignoreCase ? "i" : "")
     } catch (e) {
       throw new Error(`grep pattern /${args.pattern}/ is not a valid regex: ${e.message}`)
     }
@@ -409,11 +428,13 @@ export const lsTool = {
     type: "object",
     properties: {
       path: { type: "string", description: "Directory path (default cwd)" },
+      filter: { type: "string", description: "Only list entries matching this glob (e.g. '*.mjs', '*test*')" },
     },
   },
   readonly: true,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path ?? ".")
+    const filterRe = args.filter ? globToRegex(args.filter) : null
     let entries
     try {
       entries = await readdir(abs, { withFileTypes: true })
@@ -422,7 +443,10 @@ export const lsTool = {
       throw e
     }
     const rows = await Promise.all(
-      entries.slice(0, 500).map(async (e) => {
+      entries
+        .filter((e) => !filterRe || filterRe.test(e.name))
+        .slice(0, 500)
+        .map(async (e) => {
         const s = await stat(join(abs, e.name)).catch(() => null)
         const isDir = e.isDirectory()
         return {
@@ -439,5 +463,3 @@ export const lsTool = {
     return truncate(out.join("\n"))
   },
 }
-
-// ---------------------------------------------------------------- fetch

package/src/tools/tree.md

@@ -0,0 +1,13 @@
+Generate a directory tree of the codebase (default depth 3). Skips dotfiles, .git/node_modules/dist/build/bin/obj and other build/vendor dirs, and binary files. Use to quickly see which modules exist and where files live.
+
+**Route to tree instead of bash:**
+- `tree` / `find .` / `dir /s` → tree
+
+Parameters:
+- path: Root directory (default cwd)
+- depth: Tree depth (default 3, max 6). Directories are listed before files, both sorted.
+
+Notes:
+- Capped at 200 entries.
+- Directories end with `/`; tree-drawing uses `├──`/`└──`/`│`.
+- Use depth for a shallow overview; use `ls` for one directory, `glob` for a specific file pattern.

package/src/tools/tree.mjs

@@ -0,0 +1,66 @@
+/**
+ * tree.mjs — directory tree tool (parity with thinworker `repomap`).
+ * Renders a repo's directory tree (default depth 3), skipping dotfiles,
+ * build/vendor dirs and binary files, so the model can see which modules
+ * exist without shelling out to `tree`/`find`.
+ */
+import { DESC, truncate, resolveInCwd } from "./shared.mjs"
+import { readdir, stat } from "node:fs/promises"
+import { join, basename, extname } from "node:path"
+
+const MAX_ENTRIES = 200
+const DEFAULT_DEPTH = 3
+const SKIP_DIRS = new Set(["node_modules", "bin", "obj", "dist", "build", "coverage", "turbo", ".git", ".thincoder", ".vs", ".venv", "__pycache__", ".idea"])
+const BINARY_EXTS = new Set([".exe", ".dll", ".png", ".jpg", ".jpeg", ".gif", ".pdf", ".docx", ".xlsx", ".pptx", ".zip", ".7z", ".mp3", ".mp4", ".woff", ".woff2", ".ico"])
+
+export const treeTool = {
+  name: "tree",
+  description: DESC("tree"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Root directory (default cwd)" },
+      depth: { type: "integer", description: `Tree depth (default ${DEFAULT_DEPTH}, max 6)` },
+    },
+    required: [],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const root = resolveInCwd(ctx, args.path ?? ".")
+    let st
+    try { st = await stat(root) } catch { return `Error: directory not found: ${args.path ?? "."}` }
+    if (!st.isDirectory()) return `Error: not a directory: ${args.path ?? "."}`
+    const d = Number(args.depth)
+    const maxDepth = Number.isInteger(d) && d > 0 ? Math.min(d, 6) : DEFAULT_DEPTH
+    const lines = [basename(root) + "/"]
+    const state = { count: 1, capped: false }
+    await walk(root, 0, maxDepth, "", lines, state)
+    return truncate(lines.join("\n"))
+  },
+}
+
+async function walk(dir, depth, maxDepth, prefix, lines, state) {
+  if (state.capped) return
+  let entries
+  try { entries = await readdir(dir, { withFileTypes: true }) } catch { return }
+  const items = []
+  for (const e of entries) {
+    if (e.name.startsWith(".")) continue // dotfiles + dotdirs
+    const isDir = e.isDirectory()
+    if (isDir) { if (SKIP_DIRS.has(e.name)) continue; items.push({ name: e.name, isDir: true }) }
+    else if (!BINARY_EXTS.has(extname(e.name).toLowerCase())) items.push({ name: e.name, isDir: false })
+  }
+  items.sort((a, b) => (a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1))
+
+  for (let i = 0; i < items.length; i++) {
+    if (state.capped) return
+    if (state.count >= MAX_ENTRIES) { state.capped = true; lines.push(prefix + "…（更多项已省略）"); return }
+    const { name, isDir } = items[i]
+    const isLast = i === items.length - 1
+    lines.push(prefix + (isLast ? "└── " : "├── ") + (isDir ? name + "/" : name))
+    state.count++
+    if (isDir && depth + 1 < maxDepth) {
+      await walk(join(dir, name), depth + 1, maxDepth, prefix + (isLast ? "    " : "│   "), lines, state)
+    }
+  }
+}