thincoder 0.12.62 → 0.12.64

package/src/tools/glob-dialect.mjs

@@ -1,130 +0,0 @@
-/**
- * glob-dialect.mjs — glob 方言（TOOLS.md §17 — 2026-09-06）单一权威模块（CLI）。
- *
- * `{a,b}` brace expansion is handled BEFORE the sentinel/escape flow (braces must
- * not be literal-escaped — a bare "star-star slash star .{js,txt}" pattern
- * previously escaped to a literal that silently matched nothing). Unsupported
- * extglob dialects (`?(x)`/`@(a|b)`/`+(x)`/`*(x)`/`!(x)`) and malformed braces
- * (empty `{}`, unclosed `{`, nested `{a,{b,c}}`) are EXPLICIT errors — never a
- * silent no-match. Exclude prefixes (`!pattern`) are the CALLER's job: the
- * glob/grep tools whitespace-split the pattern expression (splitGlobPatterns —
- * never inside a brace group) and pass the parts to compileGlobMatchers, which
- * intersects includes and excludes.
- *
- * Extracted from shared.mjs (2026-09-06 advisor #5 — shared.mjs exceeded the
- * 500-line cap after §17); shared.mjs re-exports these symbols so all existing
- * importers (system.mjs / ls filter / tests) keep their import paths.
- */
-
-const BRACE_OPEN = "\u0003", BRACE_SEP = "\u0004", BRACE_CLOSE = "\u0005"
-const EXT_GLOB_RE = /[@?+*!]\(/
-
-export const GLOB_EXTGLOB_ERROR =
-  "glob syntax error: unsupported extglob syntax — ?(x)/@(a|b)/+(x)/*(x)/!(x) are not supported; use {a,b} brace expansion or multiple space-separated patterns instead"
-export const GLOB_EMPTY_BRACE_ERROR =
-  'glob syntax error: empty brace group "{}" — put at least one alternative between the braces (e.g. {js,txt})'
-export const GLOB_UNCLOSED_BRACE_ERROR =
-  'glob syntax error: unclosed brace group — add a matching "}" (e.g. {js,txt})'
-export const GLOB_NESTED_BRACE_ERROR =
-  "glob syntax error: nested brace groups are not supported (e.g. {a,{b,c}}) — use a flat alternative list (e.g. {a,b,c})"
-
-function assertNoExtglob(pattern) {
-  if (EXT_GLOB_RE.test(pattern)) throw new Error(GLOB_EXTGLOB_ERROR)
-}
-
-/** Replace every {a,b,c} group with placeholder alternation markers. Runs BEFORE
- *  the sentinel/escape flow so the inserted alternation survives literal escaping. */
-function expandBraces(pattern) {
-  for (;;) {
-    const open = pattern.indexOf("{")
-    if (open === -1) return pattern
-    let close = -1
-    for (let j = open + 1; j < pattern.length; j++) {
-      if (pattern[j] === "{") throw new Error(GLOB_NESTED_BRACE_ERROR)
-      if (pattern[j] === "}") { close = j; break }
-    }
-    if (close === -1) throw new Error(GLOB_UNCLOSED_BRACE_ERROR)
-    const inner = pattern.slice(open + 1, close)
-    if (inner === "") throw new Error(GLOB_EMPTY_BRACE_ERROR)
-    const alts = inner.split(",").map((a) => a.trim())
-    pattern = pattern.slice(0, open) + BRACE_OPEN + alts.join(BRACE_SEP) + BRACE_CLOSE + pattern.slice(close + 1)
-  }
-}
-
-/** Convert a single glob pattern to a RegExp (anchored full match). Supports the
- *  recursive "star-star" forms, single-star, "?", "[..]" character classes and
- *  {a,b} brace expansion. Malformed braces and unsupported extglob syntax throw
- *  explicit errors (no silent mismatch). */
-export function globToRegex(pattern) {
-  pattern = String(pattern)
-  assertNoExtglob(pattern)
-  pattern = expandBraces(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"), ".*")
-    .replace(new RegExp(BRACE_OPEN, "g"), "(?:")
-    .replace(new RegExp(BRACE_SEP, "g"), "|")
-    .replace(new RegExp(BRACE_CLOSE, "g"), ")")
-  return new RegExp(`^${escaped}$`)
-}
-
-/** Whitespace-split a glob expression into parts WITHOUT splitting inside {a,b}
- *  brace groups and WITHOUT splitting literal spaces inside a single pattern
- *  (2026-09-06 audit F1 / advisor #4): a whitespace run is a pattern separator
- *  ONLY when the next non-space token starts an exclusion ("!" — the §17
- *  "include !exclude" form). So a BARE pattern like "docs/my file/*.md" and an
- *  exclude like "!docs/my file/**" each stay ONE part; the standard
- *  "js-pattern 空格 !test-pattern" form still splits into its two parts. */
-export function splitGlobPatterns(expr) {
-  const s = String(expr ?? "").trim()
-  if (!s) return []
-  const parts = []
-  let depth = 0
-  let cur = ""
-  for (let i = 0; i < s.length; i++) {
-    const ch = s[i]
-    if (ch === "{") depth++
-    else if (ch === "}") depth = Math.max(0, depth - 1)
-    if (/\s/.test(ch) && depth === 0) {
-      let j = i
-      while (j < s.length && /\s/.test(s[j])) j++
-      if (s[j] === "!") {
-        if (cur) { parts.push(cur); cur = "" }
-        i = j - 1 // next loop iteration continues at the "!"
-        continue
-      }
-      // literal space inside a pattern (or trailing) — keep it in the current part
-      cur += ch
-      continue
-    }
-    cur += ch
-  }
-  if (cur) parts.push(cur)
-  return parts
-}
-
-/** Compile whitespace-split pattern parts (see splitGlobPatterns) into a matcher:
- *  non-"!" parts are includes, leading-"!" parts are excludes — a rel path matches
- *  when it matches ≥1 include (or there are no includes) and no exclude. Every
- *  part runs the full brace/error dialect through globToRegex (excludes too). */
-export function compileGlobMatchers(parts) {
-  const includes = []
-  const excludes = []
-  for (const p of parts) {
-    const part = String(p)
-    if (part.startsWith("!")) excludes.push(part.slice(1))
-    else if (part !== "") includes.push(part)
-  }
-  const include = includes.map((p) => globToRegex(p))
-  const exclude = excludes.map((p) => globToRegex(p))
-  const test = (relPath) =>
-    (include.length === 0 || include.some((re) => re.test(relPath))) &&
-    !exclude.some((re) => re.test(relPath))
-  return { include, exclude, test }
-}

package/src/tools/glob.md

@@ -1,11 +0,0 @@
-Find files by glob pattern. Returns matching paths (relative to the search path), sorted, capped at 1000. Use this to discover file structure; use grep to search file contents.
-
-Parameters:
-- pattern (required): Glob pattern — supports `**` (recursive), `**/`, `*` (within a segment), `?` (single char), `[..]` character classes, and `{a,b}` brace expansion (e.g. `**/*.{js,txt}` matches .js and .txt files at any depth). Space-separated multiple patterns with a leading `!` are EXCLUSIONS — `**/*.js !test/**` matches .js files except those under test/. Pattern matching is relative to `path`. A pattern containing a literal space is fine on its own (spaces only separate patterns when a `!` exclusion is present). An expression splits ONLY before `!`-exclusion tokens — to match several extensions in one include, use a `{a,b}` group (e.g. `**/*.{js,md}`); adjacent space-separated includes are not a supported form.
-- path: Directory to search in (default cwd)
-
-Notes:
-- Invalid glob syntax is an EXPLICIT error — never a silent no-match. Unsupported extglob dialects (`?(x)`/`@(a|b)`/`+(x)`) and malformed braces (empty `{}`, unclosed `{`, nested `{a,{b,c}}`) return `glob error: ...` — use `{a,b}` or a space-separated `!exclude` pattern instead.
-- Skips node_modules, .git, dist, build, .turbo, coverage
-- Results capped at 1000 matches
-- Prefer patterns with a literal anchor (extension or subdirectory) over bare wildcards

package/src/tools/grep.md

@@ -1,19 +0,0 @@
-Search file contents with a regex. Returns matching lines as path:line: content.
-
-**Route to grep instead of bash:** `findstr /c:"pat" file` / `grep -rn pat .` → grep. Searching file contents is a read — never shell out for it.
-
-Parameters:
-- 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 — supports `**`, `*`, `?`, `[..]`, `{a,b}` braces and space-separated exclusion (`"**/*.js !test/**"` = .js files outside test/); 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
-
-Notes:
-- Skips node_modules, .git, dist, build, .turbo, coverage
-- Results capped at 200 matches
-- Binary/unreadable files are silently skipped
-- Use this to find usages, definitions, patterns; use glob to find files by name
-- With before/after: matching lines use `:` separator, context lines use `-` (like ripgrep); overlapping context ranges in the same file are merged and de-duplicated

package/src/tools/hashline_edit.md

@@ -1,14 +0,0 @@
-Edit a file using content-hash addressing instead of string matching. More reliable than edit when whitespace or encoding varies — hashes are computed from exact line bytes on disk.
-
-Parameters:
-- path (required): File path
-- old_hashes (required): Array of SHA256 hashes (12-char hex) identifying lines to replace. Read the file with hashes=true first to obtain these hashes. For a single line, pass [hash]; for a contiguous block, pass [hash1, hash2, ...] in order.
-- new_content (required): Replacement text (multi-line ok, \n separated)
-
-Notes:
-- The hash of each line is computed as SHA256(line_content).slice(0, 12) — the same algorithm used by read(hashes=true)
-- Hashes are position-independent: they identify lines by content, not by line number (which changes after edits)
-- If the hash sequence isn't found, the error will include the current file's hashes so you can retry with corrected values
-- Prefer this over edit when: 1) the file may have mixed whitespace/encoding, 2) you want to edit a block of lines with a single call
-- Replacement text replaces the lines identified by the hashes — content not present in new_content is deleted. For a new line after a known line, use insert_after. For a single simple string swap, use edit.
-- use the most recent read of the file as the source of old_string / line numbers / hashes — re-read after the file changed

package/src/tools/index.mjs

@@ -1,36 +0,0 @@
-// tools/index.mjs — backend-compatible re-export
-export { toOpenAISchema } from "./shared.mjs";
-
-import { readTool, writeTool, editTool, insertAfterTool, readImageTool, hashlineEditTool } from "./file.mjs";
-import { applyPatchTool, deleteTool } from "./patch.mjs";
-import { bashTool } from "./bash.mjs";
-import { globTool, grepTool, lsTool } from "./search.mjs";
-import { websearchTool, fetchTool } from "./web.mjs";
-import { gitTool } from "./git.mjs";
-import { questionTool } from "./question.mjs";
-import { checklistTool } from "./checklist.mjs";
-import { lintTool } from "./linter.mjs";
-import { lspTool } from "./lsp.mjs";
-import { executeTool } from "./execute.mjs";
-import { fileOpsTool, processTool, getCurrentTimeTool, waitForTool } from "./ops.mjs";
-import { treeTool } from "./tree.mjs";
-
-export const builtinTools = [
-  readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
-  readImageTool, bashTool, globTool, grepTool,
-  websearchTool, lsTool, fetchTool, deleteTool,
-  gitTool, questionTool,
-  checklistTool, lintTool, lspTool, executeTool,
-  fileOpsTool, processTool, getCurrentTimeTool, waitForTool,
-  treeTool,
-];
-
-export {
-  readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
-  readImageTool, bashTool, globTool, grepTool,
-  websearchTool, lsTool, fetchTool, deleteTool,
-  gitTool, questionTool,
-  checklistTool, lintTool, lspTool, executeTool,
-  fileOpsTool, processTool, getCurrentTimeTool, waitForTool,
-  treeTool,
-};

package/src/tools/insert_after.md

@@ -1,15 +0,0 @@
-Insert a line of text after a specific line in a file. Safer than `edit` for adding new content — no need to copy surrounding context for exact string matching.
-
-Parameters:
-- path (required): File path
-- content (required): Text to insert (will be placed as a new line after the target line)
-- after_line: Line number to insert after (1-based). Preferred when you know the exact line number from `read`.
-- after_regex: JavaScript regex to find the line to insert after. Must match exactly one line; if it matches multiple, the tool errors and shows the matching line numbers.
-
-Notes:
-- Either after_line or after_regex is required; if both are given, after_line wins.
-- Use this instead of edit when you're adding a new line — a checklist item, a doc heading, a line of prose, a function, an import, or a block — no need to fabricate surrounding context for exact matching.
-- The inserted content becomes its own line; it's equivalent to `lines.splice(targetLine, 0, content)`.
-- Returns a diff of the change.
-- **Read-before-insert guard**: if the file was modified by any write tool (write/edit/insert_after/hashline_edit/apply_patch/delete) since your last `read`, this tool REFUSES with an error — line numbers may be stale. Read the file again, then retry. This prevents after_line from silently landing at a drifted position.
-- use the most recent read of the file as the source of old_string / line numbers / hashes — re-read after the file changed

package/src/tools/lint.md

@@ -1,10 +0,0 @@
-Run the appropriate linter/checker for a file. Auto-detects based on file extension and project config.
-Without 'full', runs a fast node --check (JS/TS syntax only, catches parse errors in milliseconds).
-With 'full', runs the language-aware cascade: tsc –noEmit (TS); ruff (Python); cargo check (Rust); go vet (Go). JS/JSX files fall back to node --check; TS uses tsc --noEmit (requires tsconfig.json).
-Use the fast default after every write/edit; use 'full' before declaring a task complete.
-
-Returns the check result: `Syntax OK: <path>` / `Syntax error in <path>: <message>` (or the language checker's output — `✓ no issues` or the failure text).
-
-Parameters:
-- path: File to check (default: most recently modified file)
-- full: Run the full language-aware cascade instead of just node --check (default false)

package/src/tools/linter.mjs

@@ -1,128 +0,0 @@
-import { DESC, resolveInCwd } from "./shared.mjs"
-import { execFileSync } from "node:child_process"
-import { existsSync } from "node:fs"
-import { join } from "node:path"
-
-export const lintTool = {
-  name: "lint",
-  description: DESC("lint"),
-  parameters: {
-    type: "object",
-    properties: {
-      path: { type: "string", description: "File to check (default: most recently modified file)" },
-      full: { type: "boolean", description: "Run the full language-aware cascade instead of just node --check (default false)" },
-    },
-    required: [],
-  },
-  readonly: true,
-  async execute(args, ctx) {
-    const abs = args.path
-      ? resolveInCwd(ctx, args.path)
-      : (ctx.agent?._touchedFiles?.at(-1) || null)
-    if (!abs) return "lint: no file specified and no recently modified file to check"
-
-    if (!args.full) {
-      // Fast path: node --check only
-      return nodeCheckResult(abs)
-    }
-
-    // Full cascade: language-aware (tsc → node --check, ruff, cargo, go vet —
-    // third-party linter cascade removed 2026-09-02, TOOLS.md §10.2: zero-dependency lint)
-    const ext = abs.split(".").pop()?.toLowerCase()
-    const checkers = LANG_CHECKERS[ext]
-    if (!checkers) return nodeCheckResult(abs) // fall back to node --check
-
-    for (const checker of checkers) {
-      const result = await checker(abs, { cwd: ctx.cwd, existsSync, execFileSync, join, relative })
-      if (result !== null) return result
-    }
-    return `lint: no linter available for ${abs}. Install one?`
-  },
-}
-
-function nodeCheckResult(abs) {
-  if (!/\.(?:m?js|cjs|m?ts|cts|jsx|tsx)$/.test(abs)) {
-    return `lint (check): only JS/TS-family files supported for fast syntax check; use full=true for other languages. Path: ${abs}`
-  }
-  try {
-    execFileSync(process.execPath, ["--check", abs], {
-      encoding: "utf8", timeout: 10000, stdio: ["ignore", "pipe", "pipe"],
-    })
-    return `Syntax OK: ${abs}`
-  } catch (e) {
-    const msg = (e.stderr || e.stdout || e.message || "").trim()
-    return `Syntax error in ${abs}:\n${msg || "(unknown)"}`
-  }
-}
-
-// ─── Full-check cascade checkers (third-party linter branch removed 2026-09-02, TOOLS.md §10.2) ──────
-
-async function tscCheck(file, { cwd, existsSync, execFileSync, join }) {
-  if (!existsSync(join(cwd, "tsconfig.json"))) return null
-  if (!/\.(ts|tsx|mts|cts)$/.test(file)) return null
-  try {
-    execFileSync("npx", ["tsc", "--noEmit", "--pretty", "false"], {
-      cwd, encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"],
-    })
-    return "✓ tsc: no type errors"
-  } catch (e) {
-    const stdout = (e.stdout || "").trim()
-    if (stdout) return stdout
-    return `✗ tsc: ${(e.stderr || e.message).slice(0, 500)}`
-  }
-}
-
-async function ruffCheck(file, { cwd, execFileSync }) {
-  if (!/\.py$/.test(file)) return null
-  try {
-    execFileSync("ruff", ["check", "--output-format", "concise", file], {
-      cwd, encoding: "utf8", timeout: 30000, stdio: ["ignore", "pipe", "pipe"],
-    })
-    return "✓ ruff: no issues"
-  } catch (e) {
-    if (e.code === "ENOENT") return "lint: ruff not installed. Run: pip install ruff"
-    const stdout = (e.stdout || "").trim()
-    if (stdout) return stdout
-    return `✗ ruff: ${(e.stderr || e.message).slice(0, 500)}`
-  }
-}
-
-async function cargoCheck(file, { cwd, existsSync, execFileSync, join }) {
-  if (!/\.rs$/.test(file)) return null
-  if (!existsSync(join(cwd, "Cargo.toml"))) return null
-  const fname = file.split(/[\\/]/).pop()
-  try {
-    const out = execFileSync("cargo", ["check", "--message-format", "short"], {
-      cwd, encoding: "utf8", timeout: 120000, stdio: ["ignore", "pipe", "pipe"],
-    })
-    const errors = out.split("\n").filter(l => l.includes(fname))
-    return errors.length > 0 ? errors.join("\n") : "✓ cargo check: no errors"
-  } catch (e) {
-    const combined = ((e.stdout || "") + "\n" + (e.stderr || "")).trim()
-    const errors = combined.split("\n").filter(l => l.includes(fname) || l.startsWith("error"))
-    return errors.length > 0 ? errors.join("\n") : `✗ cargo check failed:\n${combined.slice(0, 1000)}`
-  }
-}
-
-async function goVet(file, { cwd, execFileSync }) {
-  if (!/\.go$/.test(file)) return null
-  try {
-    execFileSync("go", ["vet", file], {
-      cwd, encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"],
-    })
-    return "✓ go vet: no issues"
-  } catch (e) {
-    return `✗ go vet: ${(e.stderr || e.message).slice(0, 500)}`
-  }
-}
-
-const LANG_CHECKERS = {
-  // js/mjs/cjs/jsx fall back to node --check (no entry — third-party linter cascade removed 2026-09-02, TOOLS.md §10.2)
-  ts:  [tscCheck],
-  tsx: [tscCheck],
-  mts: [tscCheck],
-  cts: [tscCheck],
-  py:  [ruffCheck],
-  rs:  [cargoCheck],
-  go:  [goVet],
-}

package/src/tools/ls.md

@@ -1,12 +0,0 @@
-List directory contents with type, size, and modification time. Directories listed first. Use to see what a directory contains (glob only matches files).
-
-**Route to ls instead of bash:** `dir /b` / `ls` / `dir` → ls. Listing a directory is a read — never shell out for it.
-
-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
-- Directories are suffixed with `/` and listed before files
-- Use this for a quick overview; use glob when you have a specific file pattern in mind

package/src/tools/lsp.md

@@ -1,10 +0,0 @@
-LSP code intelligence: go to definition, find references, hover info, document symbols, diagnostics. Use this to understand code structure without grep-guessing function locations or type shapes. Find files with glob / repo_outline — use lsp for definition / references / diagnostics
-
-Parameters:
-- subcommand (required): LSP operation — "definition" | "references" | "hover" | "symbols" | "diagnostics"
-- uri (required): Target file path (relative to project root)
-- line: 1-based line number (for definition/references/hover)
-- character: 1-based character offset (for definition/references/hover)
-
-Notes:
-- Returns the requested LSP result: definition location, references, hover info, document symbols, or diagnostics — or an error message.