thincoder 0.12.62 → 0.12.63

package/src/tools/checklist-sync.mjs

@@ -1,181 +0,0 @@
-/**
- * checklist-sync.mjs — checklist 并发写同步机（R10 F4，MULTI-INSTANCE-COLLAB.md §2a.3
- * ——2026-09-06，自 checklist.mjs 拆出：门控 + 合并 + 序列化——防 checklist.mjs 超 300
- * 行 advisory 线；本模块为纯同步机制，不持 checklist 业务状态）。
- *
- * 双端 checklist 同路径 {cwd}/.thincoder/checklist.md——多实例并发写原为裸整文件覆盖
- * （丢项）。写前 mtime 门控 + ID 键合并（评审修正 #6 基线规则：基线 = 本读-改-写链内
- * 最近一次 stat 的 mtime；本进程自写后刷新——parse 规范化写回不误触发 merged/重分配）。
- * .bak 不做（决策点② A：cwd 在 git 仓库内——git 兜底现场）。
- *
- * 冲突语义（flushWrite 内收口）：写前 stat ≠ 基线（对端并发写过）→ 重读磁盘 → 双方
- * union by ID（本端新增 + 盘上他端新增都保留；同 ID 不同文本 → 盘上保留、本端重分配
- * max+1 续分配；同 ID 仅状态不同 → in_progress 胜过 pending——标记不丢）；checklist
- * 文件合并时按 done 文件归档 ID 排除（含子任务点号 ID——并发 mark-done 的"盘上有旧
- * pending 副本"不复活已归档项——done 集合 union 的另一半）。checklist-done.md 自身
- * 合并 = 纯 union（无归档排除）。
- *
- * 调用方（checklist.mjs）通过 flushWrite 的 opts 注入：reread（磁盘无写回重读）、
- * doneFile 路径、isDone（目标文件是否为 done 文件）——避免本模块反向依赖 checklist
- * 的 parse/树结构。
- */
-import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs"
-
-const baselines = new Map() // filePath → 最近一次读的 stat mtime（null = 读时文件缺失）
-
-/** F4 测试缝（伪属主范式——T-F4a..d）：在每次写前门控处注入"对端写盘"钩子——模拟本链
- *  parse 后、write 前对端实例的真实并发写。生产不设置（null → 零行为影响）。 */
-let writeGateHook = null
-export function _setWriteGateHookForTest(fn) { writeGateHook = fn }
-
-/** 文件缺失 → null（门控 t0 基线形态）。 */
-export function statMtime(p) {
-  try { return statSync(p).mtimeMs } catch { return null }
-}
-
-/** 调用方（parse 读链）登记基线——读后写链以它为门控比对基准。 */
-export function noteReadBaseline(filePath, mtime) {
-  baselines.set(filePath, mtime)
-}
-
-/** Done 文件归档根 ID 清单（含子任务点号 ID：T1 与 T1.2 都进——归档排除用；编号预留
- *  nextRootId 的 /^T(\d+)$/ 过滤不受影响）。 */
-export function readDoneRoots(doneFile) {
-  if (!existsSync(doneFile)) return []
-  const roots = []
-  for (const line of readFileSync(doneFile, "utf-8").split("\n")) {
-    const m = line.match(/^- \[.\] ((?:T\d+)(?:\.\d+)*): /)
-    if (m) roots.push({ id: m[1] })
-  }
-  return roots
-}
-
-/** Serialize items to markdown lines (2-space indent per depth) — tree structure preserved. */
-function renderItems(nodes, depth, out) {
-  const indent = "  ".repeat(depth)
-  for (const item of nodes) {
-    const mark = item.status === "done" ? "x" : item.status === "in_progress" ? "~" : " "
-    const label = item.id ? `${item.id}: ${item.text}` : item.text
-    out.push(`${indent}- [${mark}] ${label}`)
-    if (item.children?.length) renderItems(item.children, depth + 1, out)
-  }
-}
-
-/**
- * 门控 + 合并 + 写（F4 收口——parse 规范化写回 / add / mark 双写都经它）。
- * @param filePath 目标文件（checklist.md 或 checklist-done.md）
- * @param items 本端（读-改-写链产物）的顶层 items
- * @param opts.reread 磁盘无写回重读函数（返回盘上顶层 items——合并触发时调用）
- * @param opts.doneFile done 文件路径（checklist 合并的归档排除源）
- * @param opts.isDone 目标文件是否为 done 文件（true = 纯 union，无归档排除）
- * @returns { merged, items }——merged=true 时 items 为落盘真相（本端节点原地重分配——
- *   调用方持有的引用/消息读到的即最终 ID）；merged=false 时 items 为原输入。
- */
-export function flushWrite(filePath, items, { reread, doneFile, isDone }) {
-  if (writeGateHook) writeGateHook(filePath) // 测试缝：模拟对端此刻写盘
-  const base = baselines.get(filePath) // undefined = 本链无读（防御——无基线无从门控）
-  const now = statMtime(filePath)
-  let finalItems = items
-  let merged = false
-  if (base !== undefined && now !== base) {
-    // 磁盘被对端并发改过（本链读后）→ 重读磁盘 + 合并（ID union）
-    const diskItems = reread()
-    finalItems = mergeItems(diskItems, items, doneFile, isDone)
-    merged = true
-  }
-  const out = []
-  renderItems(finalItems, 0, out)
-  writeFileSync(filePath, out.join("\n") + "\n")
-  baselines.set(filePath, statMtime(filePath)) // 自写后刷新基线（防自写误判并发）
-  return { merged, items: finalItems }
-}
-
-// ── F4 合并（ID 键 union）─────────────────────────────────────────────────────
-
-function flattenTree(nodes, out = []) {
-  for (const n of nodes) {
-    out.push(n)
-    if (n.children?.length) flattenTree(n.children, out)
-  }
-  return out
-}
-
-/** 层内递归合并（磁盘序在前；本端独有/重分配项追加尾部）——规则见文件头注释。 */
-function mergeLevel(diskNodes, ourNodes, env) {
-  const diskById = new Map(diskNodes.filter((n) => n.id != null).map((n) => [n.id, n]))
-  const ourById = new Map(ourNodes.filter((n) => n.id != null).map((n) => [n.id, n]))
-  const result = []
-  const pending = [] // 本端独有 + 同 ID 异文本（待重分配）——追加在磁盘序之后
-  for (const d of diskNodes) {
-    if (d.id != null && !env.isDone && env.doneIds.has(d.id)) continue // 已归档（对端 mark-done）→ 不复活
-    const o = d.id != null ? ourById.get(d.id) : null
-    if (!o) { result.push(d); continue } // 盘上独有 → 整棵保留
-    const childEnv = { ...env, prefix: `${d.id}.` } // 子层重分配域 = 父 ID 前缀（"T1" → "T1."）
-    if (o.text === d.text && o.status === d.status) {
-      // 双端同一节点（parse 规范化幂等场景）→ 去重；子树仍逐层合并（防丢任一端子新增）
-      d.children = mergeLevel(d.children ?? [], o.children ?? [], childEnv)
-      result.push(d)
-      continue
-    }
-    if (o.text === d.text) {
-      // 仅状态不同 → in_progress 胜过 pending（标记意图不丢；同文本不可能 pending×pending）
-      const carry = d.status === "in_progress" ? d : o
-      carry.children = mergeLevel(d.children ?? [], o.children ?? [], childEnv)
-      result.push(carry)
-      continue
-    }
-    // 同 ID 不同文本（并发 add 各自从同基线分到同号）→ 盘上保留；本端项排队重分配
-    result.push(d)
-    pending.push(o)
-  }
-  for (const o of ourNodes) {
-    if (o.id == null) { pending.push(o); continue } // 无 ID 行（理论极少——parse 已归一）→ 原样追加
-    if (!env.isDone && env.doneIds.has(o.id)) continue // 本端项已被归档 → 丢弃（不复活）
-    if (!diskById.has(o.id)) pending.push(o) // 本端独有 → 保留（含子树）
-    // 共享 ID 已在磁盘循环处理（去重/状态/文本冲突排队）
-  }
-  for (const o of pending) {
-    if (o.id != null && diskById.has(o.id)) reassignNode(o, env) // 文本冲突项 → 重分配 max+1 续分配
-    result.push(o)
-  }
-  return result
-}
-
-/** 重分配：层前缀（根 "T" / 子树 `${parentId}.`）下 max+1；子树 ID 前缀同步换新
- *  （"T4.1" → "T5.1"——ID 层级与父节点保持一致）。原地改——调用方引用即最终 ID。 */
-function reassignNode(node, env) {
-  let max = 0
-  for (const id of env.allIds) {
-    if (!id?.startsWith(env.prefix)) continue
-    const suffix = id.slice(env.prefix.length)
-    if (/^\d+$/.test(suffix)) max = Math.max(max, parseInt(suffix))
-  }
-  const oldId = node.id
-  const newId = `${env.prefix}${max + 1}`
-  node.id = newId
-  env.allIds.add(newId)
-  if (oldId) renameSubtreePrefixes(node, oldId, newId)
-}
-
-function renameSubtreePrefixes(node, oldId, newId) {
-  for (const c of node.children ?? []) {
-    if (c.id?.startsWith(`${oldId}.`)) {
-      c.id = newId + c.id.slice(oldId.length)
-      renameSubtreePrefixes(c, oldId, newId)
-    }
-  }
-}
-
-/** 合并入口：isDone = checklist-done 文件（纯 union——无归档排除）；否则按 done 文件
- *  当前归档 ID 排除（含点号子 ID——对端 mark-done 归档的项不因本端旧 parse 复活）。 */
-function mergeItems(diskItems, ourItems, doneFile, isDone) {
-  const doneRoots = isDone ? [] : readDoneRoots(doneFile)
-  const doneIds = new Set(doneRoots.map((r) => r.id))
-  const allIds = new Set() // 重分配 max 计算域：双端全树 + 归档根（根层防撞）
-  for (const n of flattenTree(diskItems).concat(flattenTree(ourItems))) {
-    if (n.id != null) allIds.add(n.id)
-  }
-  for (const id of doneIds) allIds.add(id)
-  const env = { isDone, doneIds, allIds, prefix: "T" } // 根层前缀 "T"；子层在 mergeLevel 递归时推导
-  return mergeLevel(diskItems, ourItems, env)
-}

package/src/tools/checklist.md

@@ -1,13 +0,0 @@
-Manage the task checklist in .thincoder/checklist.md. Use at these points: after requirements are confirmed — add one entry per requirement point; when starting work — mark in_progress; when verified complete — mark done. Checklist entries map to requirement/design points — project-level tracking across sessions. For in-session subtask breakdown of a single checklist item, use the `task` tool instead. Completed items are auto-archived to .thincoder/checklist-done.md.
-
-Items support tree hierarchy via indentation (2 spaces per level) and auto-assigned IDs (T1, T1.1, T1.2.1). Use the `parent` parameter to add a child under an existing task.
-
-Parameters:
-- action: "add" | "mark" | "list"
-- id: task ID to mark, e.g. "T3" (with "mark"; preferred — use the ID returned by `add`, or from `list`)
-- item: text for new item (with "add")
-- index: 1-based index (with "mark"; fallback — use only when you have no ID)
-- status: "pending" | "in_progress" | "done" (with "mark")
-- parent: parent task ID for hierarchical tasks, e.g. "T1" (with "add")
-
-Note: marking a parent "done" requires all its child tasks already done — otherwise it is rejected (complete the children before marking the parent done).

package/src/tools/checklist.mjs

@@ -1,299 +0,0 @@
-import { readFileSync, existsSync, mkdirSync } from "node:fs"
-import { join, dirname } from "node:path"
-import { DESC } from "./shared.mjs"
-// F4 并发写同步机（门控 + ID union 合并 + 序列化）在 checklist-sync.mjs——本文件只留
-// parse/树操作与工具执行；设计见 MULTI-INSTANCE-COLLAB.md §2a.3（D-F4a/b）。
-import { statMtime, noteReadBaseline, readDoneRoots, flushWrite } from "./checklist-sync.mjs"
-
-const CHECKLIST = "checklist.md"
-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 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) {
-  return readItems(filePath, { writeback: true })
-}
-
-/** 读盘 → 建树 → 无 ID 行一次性分配（assignIds）；writeback=true 时（公开 parse 语义）
- *  分配后立即经 write() 落盘（同走 F4 门控——并发写合并/放弃重分配）。基线在**读前**
- *  stat（stat→read 序：对端在读与 stat 微窗口写入只造成假合并，绝不漏检静默覆盖）。 */
-function readItems(filePath, { writeback }) {
-  const base = statMtime(filePath) // 基线 = 本链最近 stat（评审修正 #6）
-  let text = null
-  try {
-    if (existsSync(filePath)) text = readFileSync(filePath, "utf-8")
-  } catch { text = null } // 读失败（对端删/半写）→ 按缺失降级
-  noteReadBaseline(filePath, text === null ? null : base)
-  if (text === null) return []
-  const lines = text.split("\n")
-  const items = []
-  let flatIdx = 0
-  const stack = [{ children: items, depth: -1 }] // virtual root
-
-  for (const line of lines) {
-    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 text2 = m[3].trim()
-
-    // Strip ALL leading "T[\d.]+:" tokens (historical dirty data can accumulate
-    // "T15: T15: T15:"); keep the first token as the ID and the rest as text.
-    let id = null
-    let bareText = text2
-    let idTok
-    while ((idTok = bareText.match(/^(T[\d.]+):\s*/))) {
-      if (id == null) id = idTok[1]
-      bareText = bareText.slice(idTok[0].length)
-    }
-    const node = { id, index: flatIdx, depth, status, text: bareText, 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)
-    stack.push({ children: node.children, depth, id: node.id })
-  }
-
-  // Assign stable IDs to lines that lacked an explicit one, exactly once.
-  // IDs are "max existing number + 1" (not position-based) so gaps left by
-  // archived items never collide, and persisted IDs never drift on re-read.
-  let assigned = false
-  function assignIds(nodes, parentId) {
-    for (const n of nodes) {
-      if (!n.id) {
-        n.id = parentId ? nextChildId(parentId, nodes, doneIds) : nextRootId(nodes, doneRoots)
-        assigned = true
-      }
-      if (n.children?.length) assignIds(n.children, n.id)
-    }
-  }
-  // Root IDs archived to the done file also reserve numbers (mirrors the `add`
-  // path's double-file scan), so auto-assigned IDs never collide with them.
-  const doneRoots = readDoneRoots(join(dirname(filePath), DONE))
-  const doneIds = doneRoots.map((r) => r.id) // 含点号子 ID——子层分配同样预留
-  assignIds(items, null)
-  if (writeback && assigned) {
-    // 规范化写回（同走门控——F4）：合并发生时返回落盘真相——调用方（add/mark/list）在
-    // 磁盘真值上继续，避免基于过期 parse 再触发一轮合并
-    const r = write(filePath, items)
-    if (r.merged) return r.items
-  }
-  return items
-}
-
-function nextRootId(items, doneItems) {
-  let max = 0
-  for (const list of [items, doneItems]) {
-    for (const c of list ?? []) {
-      const m = c.id?.match(/^T(\d+)$/)
-      if (m) max = Math.max(max, parseInt(m[1]))
-    }
-  }
-  return `T${max + 1}`
-}
-
-function nextChildId(parentId, children, archivedIds) {
-  let max = 0
-  const prefix = `${parentId}.`
-  for (const c of children) {
-    if (c.id?.startsWith(prefix)) {
-      const suffix = c.id.slice(prefix.length)
-      if (/^\d+$/.test(suffix)) max = Math.max(max, parseInt(suffix))
-    }
-  }
-  // 归档预留（F4 补正）：已归档同前缀点号 ID 不复用——重加子项撞归档 ID 会被门控合并误删
-  for (const id of archivedIds ?? []) {
-    if (typeof id !== "string" || !id.startsWith(prefix)) continue
-    const suffix = id.slice(prefix.length)
-    if (/^\d+$/.test(suffix)) max = Math.max(max, parseInt(suffix))
-  }
-  return `${prefix}${max + 1}`
-}
-
-/** Write items back to file, preserving tree structure — F4 收口点（门控 + 合并见
- *  checklist-sync.mjs flushWrite）。返回 { merged, items }（同 flushWrite 契约）。 */
-function write(filePath, items) {
-  mkdirSync(dirname(filePath), { recursive: true })
-  return flushWrite(filePath, items, {
-    reread: () => readItems(filePath, { writeback: false }), // 合并用磁盘重读（无写回）
-    doneFile: join(dirname(filePath), DONE), // checklist 合并的归档排除源
-    isDone: filePath.endsWith(DONE), // done 文件自身 = 纯 union
-  })
-}
-
-/** 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
-    }
-  }
-  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
-}
-
-/** True if every descendant (children, grandchildren, …) is done. */
-function allChildrenDone(node) {
-  for (const c of node.children ?? []) {
-    if (c.status !== "done" || !allChildrenDone(c)) return false
-  }
-  return true
-}
-
-/** Recursively clone a subtree for archiving, forcing every status to done. */
-function archiveSubtree(node) {
-  return {
-    id: node.id,
-    index: 0,
-    depth: 0,
-    status: "done",
-    text: node.text,
-    children: (node.children ?? []).map(archiveSubtree),
-  }
-}
-
-/** Parse pending items only (for context injection) */
-export function pendingItems(cwd) {
-  const flat = flatten(parse(checklistPath(cwd)))
-  return flat.filter(i => i.status !== "done")
-}
-
-export const checklistTool = {
-  name: "checklist",
-  description: DESC("checklist"),
-  parameters: {
-    type: "object",
-    properties: {
-      action: {
-        type: "string",
-        enum: ["add", "mark", "list"],
-        description: "add a new item / mark item status / list all items"
-      },
-      id: {
-        type: "string",
-        description: "Task ID to mark (preferred — use the ID returned by add, e.g. 'T3')"
-      },
-      item: {
-        type: "string",
-        description: "Item text (required for add)"
-      },
-      index: {
-        type: "number",
-        description: "1-based item index (fallback for mark, only when id is absent)"
-      },
-      status: {
-        type: "string",
-        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"],
-  },
-  readonly: false,
-  execute(args, ctx) {
-    switch (args.action) {
-      case "add": {
-        if (!args.item || typeof args.item !== "string") return "Error: 'item' is required for add"
-        const items = parse(checklistPath(ctx.cwd))
-
-        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
-        }
-
-        // 归档预留（根 + 点号子 ID——add 父/子都扫 done 文件；防撞号 + 防合并误删）
-        const doneItems = parse(donePath(ctx.cwd))
-        const id = parentId
-          ? nextChildId(parentId, target, doneItems.map((i) => i.id))
-          : nextRootId(items, doneItems)
-        const node = { id, index: 0, depth: parentId ? 1 : 0, status: "pending", text: args.item, children: [] }
-        target.push(node)
-        write(checklistPath(ctx.cwd), items)
-        // F4：合并可能原地重分配本端新项（并发同号）——以 node.id（落盘真相）报回
-        return `Added: [ ] ${node.id}: ${args.item}${parentId ? ` (under ${parentId})` : ""}`
-      }
-      case "mark": {
-        if (args.id == null && args.index == null) return "Error: 'id' or 'index' is required for mark"
-        const status = args.status
-        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)
-        let item
-        if (args.id != null) {
-          const found = findById(items, args.id)
-          if (!found) return `Error: id '${args.id}' not found. Use 'list' to see all task IDs.`
-          item = found.item
-        } else {
-          const flat = flatten(items)
-          if (args.index < 1 || args.index > flat.length) return `Error: index ${args.index} out of range (1-${flat.length})`
-          item = flat[args.index - 1]
-        }
-        const old = item.status
-        if (old === status) return `Already ${status}: ${item.text}`
-        if (status === "done" && item.children?.length && !allChildrenDone(item)) {
-          return "Error: 父任务仍有未完成的子任务，先处理子任务再标父 done"
-        }
-        item.status = status
-        if (status === "done") {
-          // Move the whole subtree to the done file (hierarchy preserved).
-          const dp = donePath(ctx.cwd)
-          const doneItems = parse(dp)
-          doneItems.push(archiveSubtree(item))
-          write(dp, doneItems)
-          // Remove the subtree from the tree.
-          const found = findById(items, item.id)
-          if (found) found.parent.splice(found.idx, 1)
-        }
-        write(cp, items)
-        return `Marked ${item.id} ${old} → ${status}`
-      }
-      case "list": {
-        const items = parse(checklistPath(ctx.cwd))
-        if (items.length === 0) return "(checklist is empty)"
-        const marks = { pending: " ", in_progress: "~", done: "x" }
-        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/delete.md

@@ -1,13 +0,0 @@
-Delete a file. Use when the agent created a temporary or junk file that should be cleaned up, or when the user explicitly asks to delete something. Refuses to delete git-tracked files as a safety measure — tracked files should be edited or removed via bash with explicit user confirmation.
-
-**Route to delete instead of bash:** `del file` / `rm file` → delete (single files). Use bash `rm -rf` only for directories (delete is single-file).
-
-Parameters:
-- path (required): File path, relative to cwd or absolute
-- force: Allow deleting git-tracked files (default false)
-
-Notes:
-- Untracked or non-git files are deleted immediately
-- Tracked files require force=true (user must confirm separately)
-- Directories must be removed with bash (rm -rf)
-- Returns `Deleted <path>` (or `Error: ...` on failure/tracked refusal).