sillyspec 3.26.10 → 3.26.13

package/src/fs-atomic.js

@@ -1,69 +1,71 @@
-/**
- * fs-atomic.js — 原子文件写 + Windows 友好的 rename 重试
- *
- * 用于 .runtime/*.json、pointer、guard.json 等「会被其他进程 / hook 读取」的配置文件。
- * 保证读者要么看到旧完整内容、要么看到新完整内容，不会读到半截 JSON。
- *
- * 注意：DB 持久化由 node:sqlite 引擎承担（提交即落盘 sillyspec.db + WAL 侧车），
- * 不经此处的 writeAtomicSync；sillyspec.db 不走原子写改名。
- */
-import { writeFileSync, renameSync, unlinkSync } from 'fs';
-import { dirname, basename, join } from 'path';
-
-// Windows 上杀毒 / 索引 / IDE 占用文件时，rename 偶发这些错误，短退避重试即可
-const RENAME_RETRY_CODES = ['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY'];
-
-/** 同步退避：优先 Atomics.wait，不可用时退化忙等（仅在 rename 冲突的极端情况触发）。 */
-function sleepSync(ms) {
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-  } catch {
-    const end = Date.now() + ms;
-    while (Date.now() < end) { /* busy wait */ }
-  }
-}
-
-/**
- * rename 带退避重试，覆盖 Windows 偶发的 EPERM/EBUSY/EACCES/ENOTEMPTY。
- * 目录 rename 同样适用（归档移动目录时可复用）。
- * @param {string} from
- * @param {string} to
- * @param {number} [retries=5]
- */
-export function renameSyncRetry(from, to, retries = 5) {
-  let lastErr;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      renameSync(from, to);
-      return;
-    } catch (err) {
-      lastErr = err;
-      const code = err && err.code;
-      // 非可重试错误码立即抛出，不浪费时间
-      if (!code || !RENAME_RETRY_CODES.includes(code)) throw err;
-      if (attempt < retries) sleepSync(15 * (attempt + 1));
-    }
-  }
-  throw lastErr;
-}
-
-/**
- * 原子写文本文件：同目录 tmp 写入 → rename 覆盖目标（带 Windows 退避重试）。
- * - tmp 名含 pid，避免多进程并发写同一目标时 tmp 名碰撞（如多会话写 local.yaml）。
- * - rename 失败时清理 tmp，避免留下孤儿 .tmp 文件。
- * - Node 的 rename 在 Windows 上用 MoveFileEx(REPLACE_EXISTING)，可覆盖已存在目标；
- *   EPERM 仅在文件被其他进程锁定时出现，由 renameSyncRetry 退避重试。
- * @param {string} filePath - 目标文件绝对路径
- * @param {string} content - 文件内容
- */
-export function writeAtomicSync(filePath, content) {
-  const dir = dirname(filePath);
-  const tmpPath = join(dir, `.${basename(filePath)}.${process.pid}.tmp`);
-  writeFileSync(tmpPath, content);
-  try {
-    renameSyncRetry(tmpPath, filePath);
-  } catch (err) {
-    try { unlinkSync(tmpPath); } catch { /* tmp 可能已被 rename 走，忽略 */ }
-    throw err;
-  }
-}
+/**
+ * fs-atomic.js — 原子文件写 + Windows 友好的 rename 重试
+ *
+ * 用于 .runtime/*.json、pointer、guard.json 等「会被其他进程 / hook 读取」的配置文件。
+ * 保证读者要么看到旧完整内容、要么看到新完整内容，不会读到半截 JSON。
+ *
+ * 注意：DB 持久化由 node:sqlite 引擎承担（提交即落盘 sillyspec.db + WAL 侧车），
+ * 不经此处的 writeAtomicSync；sillyspec.db 不走原子写改名。
+ */
+import { writeFileSync, renameSync, unlinkSync } from 'fs';
+import { dirname, basename, join } from 'path';
+
+// Windows 上杀毒 / 索引 / IDE 占用文件时，rename 偶发这些错误，短退避重试即可
+const RENAME_RETRY_CODES = ['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY'];
+
+/** 同步退避：优先 Atomics.wait，不可用时退化忙等（仅在 rename 冲突的极端情况触发）。 */
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { /* busy wait */ }
+  }
+}
+
+/**
+ * rename 带退避重试，覆盖 Windows 偶发的 EPERM/EBUSY/EACCES/ENOTEMPTY。
+ * 目录 rename 同样适用（归档移动目录时可复用）。
+ * @param {string} from
+ * @param {string} to
+ * @param {number} [retries=5]
+ */
+export function renameSyncRetry(from, to, retries = 5) {
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err && err.code;
+      // 非可重试错误码立即抛出，不浪费时间
+      if (!code || !RENAME_RETRY_CODES.includes(code)) throw err;
+      if (attempt < retries) sleepSync(15 * (attempt + 1));
+    }
+  }
+  throw lastErr;
+}
+
+/**
+ * 原子写文本文件：同目录 tmp 写入 → rename 覆盖目标（带 Windows 退避重试）。
+ * - tmp 名含 pid，避免多进程并发写同一目标时 tmp 名碰撞（如多会话写 local.yaml）。
+ * - rename 失败时清理 tmp，避免留下孤儿 .tmp 文件。
+ * - Node 的 rename 在 Windows 上用 MoveFileEx(REPLACE_EXISTING)，可覆盖已存在目标；
+ *   EPERM 仅在文件被其他进程锁定时出现，由 renameSyncRetry 退避重试。
+ * @param {string} filePath - 目标文件绝对路径
+ * @param {string} content - 文件内容
+ */
+export function writeAtomicSync(filePath, content) {
+  const dir = dirname(filePath);
+  // pid + 随机段双因子：Windows PID 重用激进，两进程可能撞同 pid，tmp 名碰撞 rename 互相覆盖
+  const rnd = Math.random().toString(36).slice(2, 10);
+  const tmpPath = join(dir, `.${basename(filePath)}.${process.pid}.${rnd}.tmp`);
+  writeFileSync(tmpPath, content);
+  try {
+    renameSyncRetry(tmpPath, filePath);
+  } catch (err) {
+    try { unlinkSync(tmpPath); } catch { /* tmp 可能已被 rename 走，忽略 */ }
+    throw err;
+  }
+}

package/src/git-helper.js

@@ -1,79 +1,82 @@
-/**
- * 统一公共 git 调用入口（数组形式 execFileSync，不经 shell）。
- *
- * 背景：worktree 链路原用 `execSync(\`git ${args}\`)` 字符串拼接（经 shell），
- * 文件名/路径/用户输入插值进 shell 存在空格拆词 + 命令注入面；
- * run/shared.js 的 safeGit 已用 execFileSync 数组形式（注释明示避免拆词）。
- * 本模块把 safeGit 收口为单一实现，并补抛错版 git / 静默版 gitQuiet，
- * 供 worktree 链与 run 层共用，消除口径分裂。
- *
- * 三者统一带 `-c safe.directory=<cwd>` per-command（不污染全局 config）+ `-C cwd` 前缀；
- * 默认 timeout 5000ms（opts.timeout 可覆盖），默认 trim（opts.trim:false 保留原样输出）。
- * 数组形式天然规避 shell 拆词，路径含空格 / 元字符安全。
- * safeGit 额外支持 opts.retryOnTimeout：ETIMEDOUT（机器忙瞬时抖动）时用 2× timeout 重试一次。
- */
-import { execFileSync } from 'node:child_process'
-
-/**
- * 安全执行 git：失败不抛，返回 { value, error } 结构。
- * @param {string} cwd
- * @param {string[]} args
- * @param {{ trim?: boolean, timeout?: number, retryOnTimeout?: boolean }} [opts]
- *   - trim:false 保留原样输出（git status --porcelain 首行前导空格
- *     是状态码的一部分，trim 会削掉致 parsePorcelainPath 丢首字符，坑见 auditQuickCompletion 注释）
- *   - timeout 默认 5000ms，长操作（大 diff / worktree list）可传更大值
- *   - retryOnTimeout:true 时，ETIMEDOUT 用 2× timeout 重试一次（默认 false 向后兼容）。
- *     机器忙时 git 子进程启动慢易瞬时超时；审计锚点 git 调用失败即 blocked 中断 quick，
- *     重试一次能消化绝大多数瞬时抖动，免去用户手工重跑。权限 / 损坏等非超时错误不重试（救不回）。
- * @returns {{ value: string|null, error: string|null }}
- */
-export function safeGit(cwd, args, opts = {}) {
-  const { trim = true, timeout = 5000, retryOnTimeout = false } = opts
-  const fullArgs = ['-c', `safe.directory=${cwd}`, '-C', cwd, ...args]
-  // 单次尝试：返回 { value, errorObj }（errorObj 为原始 Error 或 null），不在内部格式化 message。
-  // 格式化（取首行）推迟到最终返回，避免重试分支重复格式化，并保留原始 code 供重试判定。
-  const attempt = (t) => {
-    try {
-      let value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout: t, stdio: ['ignore', 'pipe', 'pipe'] })
-      if (trim) value = value.trim()
-      return { value, errorObj: null }
-    } catch (e) {
-      return { value: null, errorObj: e }
-    }
-  }
-  let { value, errorObj } = attempt(timeout)
-  if (errorObj && retryOnTimeout && errorObj.code === 'ETIMEDOUT') {
-    ({ value, errorObj } = attempt(timeout * 2))
-  }
-  return { value, error: errorObj ? errorObj.message.split('\n')[0] : null }
-}
-
-/**
- * 抛错版 git：失败抛异常，成功返回 trim 后 string（对齐 worktree 本地 git() 语义）。
- * 调用方自行 catch；不经 shell，参数以数组元素传递。
- * @param {string} cwd
- * @param {string[]} args
- * @param {{ trim?: boolean, timeout?: number }} [opts]
- * @returns {string}
- */
-export function git(cwd, args, opts = {}) {
-  const { trim = true, timeout = 5000 } = opts
-  const fullArgs = ['-c', `safe.directory=${cwd}`, '-C', cwd, ...args]
-  const value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout, stdio: ['ignore', 'pipe', 'pipe'] })
-  return trim ? value.trim() : value
-}
-
-/**
- * 静默版 git：内部调 git，失败 catch 返回 null（对齐 worktree 本地 gitQuiet() 语义）。
- * @param {string} cwd
- * @param {string[]} args
- * @param {{ trim?: boolean, timeout?: number }} [opts]
- * @returns {string|null}
- */
-export function gitQuiet(cwd, args, opts = {}) {
-  try {
-    return git(cwd, args, opts)
-  } catch {
-    return null
-  }
-}
+/**
+ * 统一公共 git 调用入口（数组形式 execFileSync，不经 shell）。
+ *
+ * 背景：worktree 链路原用 `execSync(\`git ${args}\`)` 字符串拼接（经 shell），
+ * 文件名/路径/用户输入插值进 shell 存在空格拆词 + 命令注入面；
+ * run/shared.js 的 safeGit 已用 execFileSync 数组形式（注释明示避免拆词）。
+ * 本模块把 safeGit 收口为单一实现，并补抛错版 git / 静默版 gitQuiet，
+ * 供 worktree 链与 run 层共用，消除口径分裂。
+ *
+ * 三者统一带 `-c safe.directory=<cwd>` per-command（不污染全局 config）+ `-C cwd` 前缀；
+ * 默认 timeout 5000ms（opts.timeout 可覆盖），默认 trim（opts.trim:false 保留原样输出）。
+ * 数组形式天然规避 shell 拆词，路径含空格 / 元字符安全。
+ * safeGit 额外支持 opts.retryOnTimeout：ETIMEDOUT（机器忙瞬时抖动）时用 2× timeout 重试一次。
+ */
+import { execFileSync } from 'node:child_process'
+
+/**
+ * 安全执行 git：失败不抛，返回 { value, error } 结构。
+ * @param {string} cwd
+ * @param {string[]} args
+ * @param {{ trim?: boolean, timeout?: number, retryOnTimeout?: boolean }} [opts]
+ *   - trim:false 保留原样输出（git status --porcelain 首行前导空格
+ *     是状态码的一部分，trim 会削掉致 parsePorcelainPath 丢首字符，坑见 auditQuickCompletion 注释）
+ *   - timeout 默认 5000ms，长操作（大 diff / worktree list）可传更大值
+ *   - retryOnTimeout:true 时，ETIMEDOUT 用 2× timeout 重试一次（默认 false 向后兼容）。
+ *     机器忙时 git 子进程启动慢易瞬时超时；审计锚点 git 调用失败即 blocked 中断 quick，
+ *     重试一次能消化绝大多数瞬时抖动，免去用户手工重跑。权限 / 损坏等非超时错误不重试（救不回）。
+ * @returns {{ value: string|null, error: string|null }}
+ */
+export function safeGit(cwd, args, opts = {}) {
+  const { trim = true, timeout = 5000, retryOnTimeout = false } = opts
+  const fullArgs = ['-c', `safe.directory=${cwd}`, '-C', cwd, ...args]
+  // 单次尝试：返回 { value, errorObj }（errorObj 为原始 Error 或 null），不在内部格式化 message。
+  // 格式化（取首行）推迟到最终返回，避免重试分支重复格式化，并保留原始 code 供重试判定。
+  const attempt = (t) => {
+    try {
+      let value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout: t, stdio: ['ignore', 'pipe', 'pipe'] })
+      if (trim) value = value.trim()
+      return { value, errorObj: null }
+    } catch (e) {
+      return { value: null, errorObj: e }
+    }
+  }
+  let { value, errorObj } = attempt(timeout)
+  if (errorObj && retryOnTimeout && errorObj.code === 'ETIMEDOUT') {
+    ({ value, errorObj } = attempt(timeout * 2))
+  }
+  return { value, error: errorObj ? errorObj.message.split('\n')[0] : null }
+}
+
+/**
+ * 抛错版 git：失败抛异常，成功返回 trim 后 string（对齐 worktree 本地 git() 语义）。
+ * 调用方自行 catch；不经 shell，参数以数组元素传递。
+ * @param {string} cwd
+ * @param {string[]} args
+ * @param {{ trim?: boolean, timeout?: number, encoding?: string }} [opts]
+ *   - encoding:'buffer' 返回原始 Buffer（git diff --binary 等**二进制输出**专用——
+ *     utf8 解码会破坏 NUL 字节使补丁不可应用；Buffer 输出跳过 trim）
+ * @returns {string|Buffer}
+ */
+export function git(cwd, args, opts = {}) {
+  const { trim = true, timeout = 5000, encoding = 'utf8' } = opts
+  const fullArgs = ['-c', `safe.directory=${cwd}`, '-C', cwd, ...args]
+  const value = execFileSync('git', fullArgs, { encoding, timeout, stdio: ['ignore', 'pipe', 'pipe'] })
+  if (Buffer.isBuffer(value)) return value
+  return trim ? value.trim() : value
+}
+
+/**
+ * 静默版 git：内部调 git，失败 catch 返回 null（对齐 worktree 本地 gitQuiet() 语义）。
+ * @param {string} cwd
+ * @param {string[]} args
+ * @param {{ trim?: boolean, timeout?: number }} [opts]
+ * @returns {string|null}
+ */
+export function gitQuiet(cwd, args, opts = {}) {
+  try {
+    return git(cwd, args, opts)
+  } catch {
+    return null
+  }
+}

package/src/hooks/claude-pre-tool-use.cjs

@@ -1,125 +1,125 @@
-#!/usr/bin/env node
-/**
- * Claude Code PreToolUse hook 入口
- *
- * 从 stdin 读取 JSON，调用 worktree-guard 判断是否拦截。
- *
- * Claude Code hooks.json 配置：
- * {
- *   "hooks": {
- *     "PreToolUse": [
- *       {
- *         "matcher": "Edit|Write|MultiEdit|Bash",
- *         "hooks": [
- *           {
- *             "type": "command",
- *             "command": "node /path/to/sillyspec/src/hooks/claude-pre-tool-use.cjs"
- *           }
- *         ]
- *       }
- *     ]
- *   }
- * }
- */
-
-'use strict'
-
-const path = require('path')
-const fs = require('fs')
-
-// 动态 import ESM 模块
-async function main() {
-  // Claude Code hook 通过 stdin 传入 JSON
-  let input = ''
-  try {
-    input = await readStdin()
-  } catch {
-    // 无法读取 stdin → 放行（安全优先于阻断）
-    process.exit(0)
-  }
-
-  let parsed
-  try {
-    parsed = JSON.parse(input)
-  } catch {
-    // 非法 JSON → 放行
-    process.exit(0)
-  }
-
-  // 解析 Claude Code hook 输入格式
-  // 格式：{ tool_name: string, tool_input: { ... } }
-  const toolName = parsed.tool_name || parsed.tool || ''
-  const toolInput = parsed.tool_input || {}
-
-  // 转换为 shouldBlock 的输入格式
-  const toolMap = {
-    'Write': 'Write',
-    'Edit': 'Edit',
-    'MultiEdit': 'MultiEdit',
-    'Bash': 'Bash',
-  }
-
-  const mappedTool = toolMap[toolName]
-  if (!mappedTool) {
-    // 不在拦截范围内的工具 → 放行
-    process.exit(0)
-  }
-
-  // 构造 opts
-  const opts = { tool: mappedTool }
-  if (mappedTool === 'Bash') {
-    opts.command = toolInput.command || ''
-  } else {
-    // Write/Edit/MultiEdit
-    const fp = toolInput.file_path || toolInput.filePath
-    if (fp) opts.filePath = fp
-    // MultiEdit 可能有多个文件
-    if (mappedTool === 'MultiEdit') {
-      const fps = toolInput.edits
-        ? toolInput.edits.map(e => e.file_path || e.filePath).filter(Boolean)
-        : []
-      if (fps.length > 0) opts.filePaths = fps
-    }
-  }
-
-  // 加载 worktree-guard（ESM）
-  let shouldBlock
-  try {
-    const mod = await import('./worktree-guard.js')
-    shouldBlock = mod.shouldBlock
-  } catch (e) {
-    // 模块加载失败 → 放行（不因为 hook 出错阻断工作流）
-    // eslint-disable-next-line no-console
-    console.error(`[sillyspec-hook] 模块加载失败: ${e.message}`)
-    process.exit(0)
-  }
-
-  const result = shouldBlock(opts)
-
-  if (result.blocked) {
-    // 输出错误信息（Claude Code 会显示给 agent）
-    // eslint-disable-next-line no-console
-    console.error(`[sillyspec] ❌ ${result.reason || 'blocked by worktree guard'}`)
-    process.exit(2) // exit code 2 = 阻止工具执行
-  }
-
-  // 放行
-  process.exit(0)
-}
-
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    const chunks = []
-    process.stdin.setEncoding('utf8')
-    process.stdin.on('data', chunk => chunks.push(chunk))
-    process.stdin.on('end', () => resolve(chunks.join('')))
-    process.stdin.on('error', reject)
-    // 超时保护（3秒）
-    setTimeout(() => {
-      process.stdin.destroy()
-      resolve('')
-    }, 3000)
-  })
-}
-
-main().catch(() => process.exit(0))
+#!/usr/bin/env node
+/**
+ * Claude Code PreToolUse hook 入口
+ *
+ * 从 stdin 读取 JSON，调用 worktree-guard 判断是否拦截。
+ *
+ * Claude Code hooks.json 配置：
+ * {
+ *   "hooks": {
+ *     "PreToolUse": [
+ *       {
+ *         "matcher": "Edit|Write|MultiEdit|Bash",
+ *         "hooks": [
+ *           {
+ *             "type": "command",
+ *             "command": "node /path/to/sillyspec/src/hooks/claude-pre-tool-use.cjs"
+ *           }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * }
+ */
+
+'use strict'
+
+const path = require('path')
+const fs = require('fs')
+
+// 动态 import ESM 模块
+async function main() {
+  // Claude Code hook 通过 stdin 传入 JSON
+  let input = ''
+  try {
+    input = await readStdin()
+  } catch {
+    // 无法读取 stdin → 放行（安全优先于阻断）
+    process.exit(0)
+  }
+
+  let parsed
+  try {
+    parsed = JSON.parse(input)
+  } catch {
+    // 非法 JSON → 放行
+    process.exit(0)
+  }
+
+  // 解析 Claude Code hook 输入格式
+  // 格式：{ tool_name: string, tool_input: { ... } }
+  const toolName = parsed.tool_name || parsed.tool || ''
+  const toolInput = parsed.tool_input || {}
+
+  // 转换为 shouldBlock 的输入格式
+  const toolMap = {
+    'Write': 'Write',
+    'Edit': 'Edit',
+    'MultiEdit': 'MultiEdit',
+    'Bash': 'Bash',
+  }
+
+  const mappedTool = toolMap[toolName]
+  if (!mappedTool) {
+    // 不在拦截范围内的工具 → 放行
+    process.exit(0)
+  }
+
+  // 构造 opts
+  const opts = { tool: mappedTool }
+  if (mappedTool === 'Bash') {
+    opts.command = toolInput.command || ''
+  } else {
+    // Write/Edit/MultiEdit
+    const fp = toolInput.file_path || toolInput.filePath
+    if (fp) opts.filePath = fp
+    // MultiEdit 可能有多个文件
+    if (mappedTool === 'MultiEdit') {
+      const fps = toolInput.edits
+        ? toolInput.edits.map(e => e.file_path || e.filePath).filter(Boolean)
+        : []
+      if (fps.length > 0) opts.filePaths = fps
+    }
+  }
+
+  // 加载 worktree-guard（ESM）
+  let shouldBlock
+  try {
+    const mod = await import('./worktree-guard.js')
+    shouldBlock = mod.shouldBlock
+  } catch (e) {
+    // 模块加载失败 → 放行（不因为 hook 出错阻断工作流）
+    // eslint-disable-next-line no-console
+    console.error(`[sillyspec-hook] 模块加载失败: ${e.message}`)
+    process.exit(0)
+  }
+
+  const result = shouldBlock(opts)
+
+  if (result.blocked) {
+    // 输出错误信息（Claude Code 会显示给 agent）
+    // eslint-disable-next-line no-console
+    console.error(`[sillyspec] ❌ ${result.reason || 'blocked by worktree guard'}`)
+    process.exit(2) // exit code 2 = 阻止工具执行
+  }
+
+  // 放行
+  process.exit(0)
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', chunk => chunks.push(chunk))
+    process.stdin.on('end', () => resolve(chunks.join('')))
+    process.stdin.on('error', reject)
+    // 超时保护（3秒）
+    setTimeout(() => {
+      process.stdin.destroy()
+      resolve('')
+    }, 3000)
+  })
+}
+
+main().catch(() => process.exit(0))