thincoder 0.12.59 → 0.12.61

package/src/tools/patch.mjs

@@ -16,7 +16,7 @@ import { relative, dirname } from "node:path";
  * Parse a unified diff: returns [{ path, isNew, hunks: [{ ops: [{type:" "|"-"|"+", text}] }] }]
  * Consume hunk lines by the line counts in the @@ header — LLMs often strip context blank lines to pure empty lines,
  * so we use counts rather than first characters to determine hunk boundaries.
- * D15.6: a bare "@@" header (no coordinates) is accepted — the hunk body runs until the next hunk/file header
+ * APPLY-PATCH.md §3: a bare "@@" header (no coordinates) is accepted — the hunk body runs until the next hunk/file header
  * ("@@" / "--- " / "+++ " / "diff " / "index "), purely located by its ops.
  */
 /**
@@ -68,7 +68,7 @@ function parsePatch(patch) {
       if (!cur) throw new Error("Malformed patch: hunk header before any file header")
       const m = line.match(/^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/)
       if (!m) {
-        // D15.6 (TOOLS.md §15)：坐标裸 "@@" 头——hunk 完全靠操作行定位。
+        // APPLY-PATCH.md §3：坐标裸 "@@" 头——hunk 完全靠操作行定位。
         // 无行数可用：操作行以 " " / "-" / "+" 开头（空行宽容为上下文行），
         // 直到下一个 hunk 头 / 文件头 "@@"/"--- "/"+++ "/"diff "/"index " 为止。
         if (!/^@@(?: @@)?\s*$/.test(line)) {
@@ -94,7 +94,7 @@ function parsePatch(patch) {
         }
         if (hunk.ops.length === 0) throw new Error(`Malformed patch: empty coordinate-less hunk "${line.trim()}"`)
         const ctxCount = hunk.ops.filter((o) => o.type === " ").length
-        // §15.3 (TOOLS.md D15.10.1——2026-09-04)：context<2 且含 ≥1 个 - 行 → 接受——定位锚 = hunk 内
+        // §3 (APPLY-PATCH.md——2026-09-04)：context<2 且含 ≥1 个 - 行 → 接受——定位锚 = hunk 内
         // 匹配行序列（空格上下文行 + - 行——按出现序）连续——唯一匹配即应用（applyHunks 既有锚匹配域——
         // 多匹配 / not-found 语义不变）。0 上下文与 1 上下文同待遇（评审 #4a）。
         // 纯 +（无 - 锚）且 context<2 仍拒——插入位置不可判——报错引导加锚（NF15.8c）。

package/src/tools/question.md

@@ -8,5 +8,9 @@ Notes:
 - The agent loop pauses until the user answers
 - The answer is injected as the next user message
 - Returns the user's answer — the chosen option or free text — as the next message; the loop resumes when it arrives.
+- Availability: this tool needs an interactive UI — in contexts without one (headless runs, subagent children) it returns an error instead of asking; put the question in your reply text instead.
 - Use sparingly — prefer making reasonable decisions when possible
+- Ask ONE question per call — never bundle multiple sub-questions into one question string; ask the next one after the answer arrives.
+- Keep the question text short — one or two sentences. Background, context, and analysis belong in your normal reply text, NOT in the question.
+- Routine confirmations (confirm gates) belong in your plain reply text — the user answers in their next message. Use this tool ONLY when you need the user's decision or input to proceed.
 - After receiving an answer about a design convention, tool preference, or recurring pattern: save it with the memory tool (action: put). This prevents asking the same question in future sessions — the user shouldn't have to repeat their preferences.

package/src/tools/question.mjs

@@ -0,0 +1,26 @@
+import { DESC } from "./shared.mjs";
+
+export const questionTool = {
+  name: "question",
+  description: DESC("question"),
+  parameters: {
+    type: "object",
+    properties: {
+      question: { type: "string", description: "The question to ask the user" },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "Single-choice options for the user to pick from (optional)",
+      },
+    },
+    required: ["question"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    if (!ctx.onQuestion) throw new Error("question tool not supported in this context (no UI to ask)")
+    // §22 D-Q3 机械限制（2026-09-06 用户裁定：100 字符 / 4 条——超限拒绝回模型，不弹卡、不调 onQuestion）
+    if (args.question.length > 100) return "(error: question too long (>100 chars) — ask ONE short question; background belongs in your normal reply text)"
+    if (Array.isArray(args.options) && args.options.length > 4) return "(error: too many options (>4) — offer at most 4 plain-string options)"
+    return ctx.onQuestion(args.question, args.options ?? [])
+  },
+}

package/src/tools/read.md

@@ -7,12 +7,11 @@ Read a text file. Returns numbered lines. Use offset/limit to page large files.
 - Know the symbol but not the location? → `code_search` or `lsp definition`
 - Know the file but not the lines? → `grep` to find line numbers, then read that range with offset/limit
 - Reading an image? → `read_image` instead
-- Reading a PDF? → `read_pdf` instead (read would decode the binary as UTF-8 garbage)
 
 Parameters:
 - path (required): File path, relative to cwd or absolute (alias: filePath)
 - offset: 1-based line number to start reading from
-- limit: Max lines to return (default 2000)
+- limit: Max lines to return (default 2000) — windows over files beyond that return head + `…(truncated: K lines in middle, use offset to continue)` + the file's real tail lines, so the file end is never hidden
 - hashes: Include SHA256 content hashes per line (for hashline_edit). Set true before using hashline_edit.
 
 Notes:

package/src/tools/read_image.md

@@ -5,4 +5,4 @@ Parameters:
 
 Notes:
 - Raster formats only (png/jpg/gif/webp): no mainstream vision API (Kimi, Anthropic, OpenAI, Gemini) accepts svg or bmp, and an unsupported image part in history makes every subsequent request fail with 400. svg files are returned as text source instead (readable by any model); bmp is rejected — convert to PNG first.
-- This tool only works with models that support vision/image input (Kimi K3, Qwen3.8, MiniMax M3, GLM-5.3-Flash). Pure text models (DeepSeek V4, GLM-5) will receive an error — except svg, which needs no vision support since it is read as text.
+- This tool only works with models that support vision/image input (capability is spec-driven — the model spec decides, not a hardcoded list). Models without vision support will receive an error — except svg, which needs no vision support since it is read as text.

package/src/tools/search.mjs

@@ -0,0 +1,236 @@
+import {
+  DESC,
+  truncate,
+  resolveInCwd,
+  globToRegex,
+  splitGlobPatterns,
+  compileGlobMatchers,
+  normalizeEOL,
+  IGNORED_DIRS,
+} from "./shared.mjs";
+import { readFile, readdir, stat, lstat } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Escape a string for literal regex matching (grep literal=true). */
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+// ---------------------------------------------------------------- glob
+
+export const globTool = {
+  name: "glob",
+  description: DESC("glob"),
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Glob pattern — supports **, *, ?, [..], {a,b} braces, and space-separated exclusion (\"**/*.js !test/**\")" },
+      path: { type: "string", description: "Directory to search in (default cwd)" },
+    },
+    required: ["pattern"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const base = resolveInCwd(ctx, args.path ?? ".")
+    // §17 调用侧拆分（评审 #5 职责分层）：空格分隔 include !exclude 多模式在这里拆；
+    // globToRegex 只收单个模式（数组由 compileGlobMatchers 收）。
+    let match
+    try {
+      const parts = splitGlobPatterns(args.pattern)
+      if (parts.length === 0) return "Error: pattern is required"
+      match = compileGlobMatchers(parts).test
+    } catch (e) {
+      return `glob error: invalid pattern "${args.pattern}": ${e.message}`
+    }
+    const results = []
+    for await (const relPath of walkFiles(base)) {
+      if (match(relPath)) {
+        results.push(relPath)
+        if (results.length >= 1000) break
+      }
+    }
+    if (results.length === 0) return "(no matches)"
+    return truncate(results.sort().join("\n"))
+  },
+}
+
+/** Recursively traverse files, yield relative paths (skip IGNORED_DIRS) */
+async function* walkFiles(dir, rel = "") {
+  let entries
+  try {
+    entries = await readdir(dir, { withFileTypes: true })
+  } catch {
+    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()) {
+      yield* walkFiles(join(dir, e.name), relPath)
+    } else {
+      yield relPath
+    }
+  }
+}
+
+// ---------------------------------------------------------------- grep
+
+export const grepTool = {
+  name: "grep",
+  description: DESC("grep"),
+  parameters: {
+    type: "object",
+    properties: {
+      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 — supports **, *, ?, [..], {a,b} braces and space-separated exclusion (\"**/*.js !test/**\")" },
+      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" },
+    },
+    required: ["pattern"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const base = resolveInCwd(ctx, args.path ?? ".")
+    let regex
+    try {
+      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}`, { cause: e })
+    }
+    // §17 调用侧拆分：glob 参数支持空格分隔 include !exclude 多模式（include/exclude 求交）。
+    let fileTest = null
+    if (args.glob) {
+      try {
+        const parts = splitGlobPatterns(args.glob)
+        if (parts.length > 0) fileTest = compileGlobMatchers(parts).test
+      } catch (e) {
+        throw new Error(`grep glob /${args.glob}/ is invalid: ${e.message}`, { cause: e })
+      }
+    }
+    const before = Math.max(0, Math.floor(args.before ?? 0))
+    const after = Math.max(0, Math.floor(args.after ?? 0))
+    const wantCtx = before > 0 || after > 0
+    const hits = [] // { file, line(1-based), text }
+    const fileLines = new Map() // file -> string[] (cached only when context lines requested)
+
+    async function search(file) {
+      let content
+      try {
+        // Large file guard: skip files over 10MB to prevent OOM
+        const fst = await stat(file)
+        if (fst.size > 10_000_000) return
+        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)
+      }
+      const lines = content.split("\n")
+      if (wantCtx) fileLines.set(file, lines)
+      for (let i = 0; i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          hits.push({ file, line: i + 1, text: lines[i] })
+          if (hits.length >= 200) return
+        }
+      }
+    }
+
+    async function walk(target, rel) {
+      if (hits.length >= 200) return
+      // Use lstat to avoid following symlinks — prevents ./evil → /etc from making grep scan the entire system
+      let s
+      try { s = await lstat(target) } catch { return }
+      if (!s.isDirectory()) {
+        // rel 为相对搜索基的路径（排除前缀如 !test/** 必须按目录路径作用——不能用裸文件名）；
+        // 单文件目标（path 指向文件）时 rel 为空 → 退化为按文件名过滤（既有语义）。
+        if (!fileTest || fileTest(rel || target.split(/[\\/]/).pop())) await search(target)
+        return
+      }
+      let entries
+      try {
+        entries = await readdir(target, { withFileTypes: true })
+      } catch {
+        return
+      }
+      for (const e of entries) {
+        if (e.isDirectory() && IGNORED_DIRS.has(e.name)) continue
+        await walk(join(target, e.name), rel ? `${rel}/${e.name}` : e.name)
+      }
+    }
+
+    await walk(base, "")
+    if (hits.length === 0) return "(no matches)"
+
+    // No context: keep original path:line: content format
+    if (!wantCtx) {
+      return truncate(hits.map((h) => `${h.file}:${h.line}: ${h.text}`).join("\n"))
+    }
+
+    // With context: matching lines use ':', context lines use '-' (like ripgrep); overlapping ranges in same file are merged and de-duplicated
+    const fileMatched = new Map() // file -> Set<line>
+    for (const h of hits) {
+      if (!fileMatched.has(h.file)) fileMatched.set(h.file, new Set())
+      fileMatched.get(h.file).add(h.line)
+    }
+    const out = []
+    for (const [file, matchedLines] of fileMatched) {
+      const lines = fileLines.get(file) ?? []
+      const lineSet = new Set()
+      for (const ml of matchedLines) {
+        for (let l = Math.max(1, ml - before); l <= Math.min(lines.length, ml + after); l++) lineSet.add(l)
+      }
+      for (const l of [...lineSet].sort((a, b) => a - b)) {
+        const sep = matchedLines.has(l) ? ":" : "-"
+        out.push(`${file}${sep}${l}${sep} ${lines[l - 1]}`)
+      }
+    }
+    return truncate(out.join("\n"))
+  },
+}
+
+export const lsTool = {
+  name: "ls",
+  description: DESC("ls"),
+  parameters: {
+    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 })
+    } catch (e) {
+      if (e.code === "ENOENT" || e.code === "ENOTDIR") throw new Error(`ls: ${args.path ?? "."} — ${e.code === "ENOTDIR" ? "not a directory" : "not found"}`, { cause: e })
+      throw e
+    }
+    const rows = await Promise.all(
+      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 {
+          dir: isDir,
+          name: e.name + (isDir ? "/" : ""),
+          size: s?.size ?? 0,
+          mtime: s ? s.mtime.toISOString().slice(0, 16).replace("T", " ") : "?",
+        }
+      }),
+    )
+    rows.sort((a, b) => (a.dir === b.dir ? a.name.localeCompare(b.name) : a.dir ? -1 : 1))
+    if (rows.length === 0) return "(no entries)"
+    const out = rows.map((r) => `${r.dir ? "d" : "-"}  ${r.name.padEnd(40)} ${String(r.size).padStart(10)}  ${r.mtime}`)
+    return truncate(out.join("\n"))
+  },
+}

package/src/tools/shared.mjs

@@ -363,19 +363,20 @@ export function detectDanger(command) {
 }
 
 
-/** Convert glob pattern to regex */
-export function globToRegex(pattern) {
-  // Sentinel chars: \u0001/\u0002 never appear in real glob patterns (they
-  // come from model output or the filesystem) — safe as **/ and ** placeholders.
-  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}$`)
-}
+/** Glob dialect (TOOLS.md §17) lives in glob-dialect.mjs — single authority for
+ *  brace expansion / exclusion / explicit syntax errors (extracted 2026-09-06 —
+ *  advisor #5: shared.mjs exceeded 500 lines). Re-exported so existing importers
+ *  (system.mjs tools, ls filter, tests) keep their import paths unchanged. */
+export {
+  globToRegex,
+  splitGlobPatterns,
+  compileGlobMatchers,
+  GLOB_EXTGLOB_ERROR,
+  GLOB_EMPTY_BRACE_ERROR,
+  GLOB_UNCLOSED_BRACE_ERROR,
+  GLOB_NESTED_BRACE_ERROR,
+} from "./glob-dialect.mjs"
+
 
 /** Decode a numeric HTML entity to its code point — invalid/out-of-range
  *  values (e.g. �) must not throw RangeError; keep the source

package/src/tools/wait_for.md

@@ -0,0 +1,22 @@
+Wait until a condition becomes true — polls the condition every interval_ms and returns as soon as it holds or the timeout_ms ceiling passes. Use it ONLY for genuinely asynchronous waits: an async subagent/consult still settling, a file appearing, a port opening. Synchronous tools (advisor, blocking subagent spawn) return when done — waiting after them is NOT needed and wastes time.
+
+Parameters:
+- condition (required): a semantic condition expression:
+  - `advisor settled` — an in-flight advisor review session has finished (async advisor-role children settled)
+  - `subagent id:N done` — async subagent N (the id your async spawn ack returned) has settled
+  - `consult done` — every consult_start session has drained
+  - `file exists:path` — the file at path exists (path relative to cwd)
+  - `port open:N` — something is listening on 127.0.0.1 port N
+  - The agent-internal conditions (advisor / subagent / consult) apply to ASYNC sessions only — a synchronous call already completed before it returned and has nothing to wait for. An unknown condition is an explicit error (`wait_for: unsupported condition "..."` — the supported forms are listed above), never a silent wait.
+- interval_ms: poll interval (default 1000, floor 100 — polling never busy-spins)
+- timeout_ms: overall ceiling (default 30000; config.json `agent.waitForTimeoutMs` overrides the default; hard cap 600000 like the execute tool)
+
+Returns:
+- `wait_for: condition satisfied after Nms (N checks): "<condition>"` — condition held
+- `wait_for: timed out after Nms waiting for "<condition>" ...` — ceiling passed with the condition still false (never burns beyond the ceiling)
+- interrupts (Ctrl+C / cancel) exit immediately; malformed conditions and unsupported syntax error out explicitly
+
+Notes:
+- Read-only and non-destructive — it only observes (agent pools, the filesystem, a local port probe).
+- Blocking by design — call it ALONE in a turn, not batched with calls that depend on its result.
+- Do not use it to wait after synchronous tools (advisor / blocking subagent spawn / verify return only when done).