thincoder 0.12.62 → 0.12.63

package/src/ledger.mjs

@@ -1,227 +0,0 @@
-/**
- * ledger.mjs — 台账（需求池 / 技术待办）单源读取面（LEDGER-SURFACE 批——设计档 §2.30.3）。
- *
- * 数字单源（F7）：解析（`scanGroups`）/ 计数 / 老化 / 阈值一处实现——机检器
- * （`scripts/check-ledger.mjs`）与显示面（CLI TUI `src/tui/ledger-surface.mjs`）共用本口径；
- * VSC 端为独立实现、语义同源（不跨仓 import）。
- * 口径（需求档 §1.18）：计数 = `##` 组内 `- [ ]` 未决条目；老化 = 技术组无 `触发=` 且行龄
- * > 30 天（行龄未知不计）；阈值 = 池 ≥ 3 或任一板块 ≥ 2；可动作 = 老化 > 0 或阈值达成。
- * 行文本逐字契约 = 设计档 §2.30.3.3（本模块只产出文本，色 / 态归各端显示面）。
- */
-import { mkdirSync, opendirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs"
-import { basename, dirname, join, resolve } from "node:path"
-import { execFileSync } from "node:child_process"
-import { configDir } from "./config.mjs"
-
-/** 老化阈值（天——口径 = 需求档 §1.18；`days` 参数可覆盖）。 */
-export const AGING_DAYS = 30
-/** 「可开批」阈值：同一板块（池条目指针所指需求档文档名）未决 ≥ 2。 */
-export const THRESHOLD_BOARD = 2
-/** 「可开批」阈值：需求池未决 ≥ 3。 */
-export const THRESHOLD_POOL = 3
-/** 刷新周期（N2 实现常量；VSC 端另有换项目事件触发）。 */
-export const REFRESH_MS = 120000
-/** 变化行去重档（跨会话、跨端共享——需求档 §1.18 F5；configDir 先例 = crash-reports 同区）。 */
-export const NOTIFY_FILE = join(configDir, "ledger-notify.json")
-/** 空族提示（仅命令面——运行时面静默，N1 / 设计档 §2.30.3.3）。 */
-export const EMPTY_FAMILY_LINE = "台账：未发现台账（docs/TODO.md）。"
-
-const LEDGER_REL = join("docs", "TODO.md")
-const H2_RE = /^##\s+(.*)$/
-const DECL_RE = /（(\d+)\s*条）/
-const OPEN_ENTRY_RE = /^- \[ \]\s+/
-const TRIGGER_RE = /触发\s*=\s*([^·\n]*)/
-const BOARD_REF_RE = /requirements\/([A-Za-z0-9_.-]+\.md)/
-
-/** `##` 组扫描（与机检器 L2/L3 同源——解析唯一实现）：[{name,line,declared,entries:[{line,text}]}]。 */
-export function scanGroups(lines) {
-  const groups = []
-  lines.forEach((l, i) => {
-    const h = H2_RE.exec(l)
-    if (h) groups.push({ name: h[1].trim(), line: i + 1, declared: Number((DECL_RE.exec(h[1]) ?? [])[1] ?? NaN), entries: [] })
-    else if (groups.length && OPEN_ENTRY_RE.test(l)) groups[groups.length - 1].entries.push({ line: i + 1, text: l })
-  })
-  return groups
-}
-
-/** 条目归一化文本 = 条目键（去 `- [ ] ` 前缀 + 去首尾空白 + 连续空白折叠单空格）。
- *  位置无关（位移 / 他条编辑稳定）；自身文本变更 = 键变（最坏一次重报）。§2.30.3.2。 */
-export function normalizeEntry(text) {
-  return text.replace(/^- \[[ x]\]\s+/, "").trim().replace(/\s+/g, " ")
-}
-
-/** 条目标题：首个 `**…**` 段；无粗体段 → 归一化文本前 20 字（超出加 `…`）。§2.30.3.3 L3。 */
-export function entryTitle(text) {
-  const m = /\*\*(.+?)\*\*/.exec(text)
-  if (m) return m[1]
-  const norm = normalizeEntry(text)
-  return norm.length > 20 ? norm.slice(0, 20) + "…" : norm
-}
-
-const isFile = (p) => { try { return statSync(p).isFile() } catch { return false } }
-
-/** 向上（含自身）最近的含台账目录 → {root, ledger} / null（F4——CLI 锚 = cwd）。 */
-export function findProject(anchor) {
-  let dir = resolve(anchor)
-  for (;;) {
-    const ledger = join(dir, LEDGER_REL)
-    if (isFile(ledger)) return { root: dir, ledger }
-    const parent = dirname(dir)
-    if (parent === dir) return null
-    dir = parent
-  }
-}
-
-/** 同级枚举上限（N2 成本有界：父目录超此规模 = 缓存 / 临时等非仓族形态 → 退化空集，只显当前项目）。 */
-export const MAX_SIBLING_SCAN = 100
-
-/** 目录下含台账的直接子目录（目录名升序；不可读 → []；**惰性枚举 + 上限**——大目录零全量扫描）。 */
-function ledgerChildren(dir) {
-  const out = []
-  let handle
-  try { handle = opendirSync(dir) } catch { return out }
-  try {
-    let n = 0
-    for (;;) {
-      const ent = handle.readSync()
-      if (!ent) break
-      if (++n > MAX_SIBLING_SCAN) return []
-      if (!ent.isDirectory()) continue
-      const root = join(dir, ent.name)
-      const ledger = join(root, LEDGER_REL)
-      if (isFile(ledger)) out.push({ root, ledger })
-    }
-  } catch { /* 读中断 → 已得子集（尽力而为） */ }
-  finally { try { handle.closeSync() } catch { /* 已关 */ } }
-  return out.sort((a, b) => (a.root < b.root ? -1 : a.root > b.root ? 1 : 0))
-}
-
-/** 项目族发现：{current, projects}——projects = current + 其同级含台账目录（**发现序：current 在前**，
- *  其余按目录名升序）；current 缺（容器目录，K6）→ 上下文目录向上最近「含台账子目录」者取其子目录。 */
-export function discoverFamily(anchor) {
-  const current = findProject(anchor)
-  if (current) {
-    const siblings = ledgerChildren(dirname(current.root)).filter((p) => p.root !== current.root)
-    return { current, projects: [current, ...siblings] }
-  }
-  let dir = resolve(anchor)
-  for (;;) {
-    const kids = ledgerChildren(dir)
-    if (kids.length) return { current: null, projects: kids }
-    const parent = dirname(dir)
-    if (parent === dir) return { current: null, projects: [] }
-    dir = parent
-  }
-}
-
-/** 行龄 Map：全档一次 `git blame --porcelain` → Map<行号, 天>；非 git / 不可判定 → null（零假阳降级）。 */
-export function blameAges(abs) {
-  let out
-  try {
-    out = execFileSync("git", ["blame", "--porcelain", "--", abs], {
-      cwd: dirname(abs), encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 32 * 1024 * 1024,
-    })
-  } catch { return null }
-  const times = new Map(), ages = new Map()
-  const now = Date.now() / 1000
-  let sha = null, line = 0
-  for (const l of out.split("\n")) {
-    const h = /^([0-9a-f^]{7,40})\s+\d+\s+(\d+)(?:\s+\d+)?$/.exec(l)
-    if (h) { sha = h[1]; line = Number(h[2]); continue }
-    if (l.startsWith("author-time ")) { times.set(sha, Number(l.slice(12))); continue }
-    if (l.startsWith("\t")) {
-      const t = times.get(sha)
-      ages.set(line, t != null ? (now - t) / 86400 : null)
-    }
-  }
-  return ages
-}
-
-/** 单项目汇总 → {name,root,ledger,pool,tech,aged,agedKeys,agedTitles,thresholdReached,boards,actionable}。
- *  `ageOf(abs)` → Map<行号,天>|null（注入面——确定性用例）；**无候选条目不调 ageOf**（N2）。 */
-export function summarizeLedger(project, { days = AGING_DAYS, ageOf = blameAges } = {}) {
-  const groups = scanGroups(readFileSync(project.ledger, "utf8").split("\n"))
-  const poolEntries = groups.filter((g) => g.name.includes("需求池")).flatMap((g) => g.entries)
-  const techEntries = groups.filter((g) => g.name.includes("技术")).flatMap((g) => g.entries)
-  const candidates = techEntries.filter((e) => !TRIGGER_RE.test(e.text))
-  const ages = candidates.length ? ageOf(project.ledger) : null
-  const aged = candidates.filter((e) => { const a = ages?.get(e.line); return a != null && a > days })
-  const boards = new Map()
-  for (const e of poolEntries) {
-    const m = BOARD_REF_RE.exec(e.text)
-    if (m) boards.set(m[1], (boards.get(m[1]) ?? 0) + 1)
-  }
-  const thresholdReached = poolEntries.length >= THRESHOLD_POOL || [...boards.values()].some((n) => n >= THRESHOLD_BOARD)
-  return {
-    name: basename(project.root), root: project.root, ledger: project.ledger,
-    pool: poolEntries.length, tech: techEntries.length, aged: aged.length,
-    agedKeys: aged.map((e) => normalizeEntry(e.text)), agedTitles: aged.map((e) => entryTitle(e.text)),
-    thresholdReached, boards, actionable: aged.length > 0 || thresholdReached,
-  }
-}
-
-/** L1 状态标记（逐字——§2.30.3.3）。 */
-export function formatMarker(scan) {
-  return scan ? `台账 ${scan.pool}·${scan.tech}` : null
-}
-
-/** L2 明细行（逐字——`（老化 <n>）` 恒显；阈值达成加 ` — 可开批`）。 */
-export function formatDetailLine(scan) {
-  return `台账 ${scan.name}：需求池 ${scan.pool} · 技术待办 ${scan.tech}（老化 ${scan.aged}）${scan.thresholdReached ? " — 可开批" : ""}`
-}
-
-/** L3 变化行·老化（titles = 新增老化条目标题；> 3 条时第三项后接 `；…`）。 */
-export function formatAgingLine(scan, titles) {
-  return `台账变化：${scan.name} 老化首次越线 ${titles.length} 条（超 30 天未处置）：${titles.slice(0, 3).join("；")}${titles.length > 3 ? "；…" : ""}`
-}
-
-/** L4 变化行·阈值。 */
-export function formatThresholdLine(scan) {
-  return `台账变化：${scan.name} 需求池达阈值（${scan.pool} 条）— 可开批`
-}
-
-/** 明细行集 = {current} ∪ {可动作项目}（发现序——current 在前，其余按目录名升序；同项去重）。 */
-export function detailScans(scans, current) {
-  const out = []
-  if (current) out.push(current)
-  for (const s of scans) if (s !== current && s.actionable) out.push(s)
-  return out
-}
-
-/** 变化行规划（纯函数）：{lines:[{text,warn}], next:{aged,threshold}}（去重口径 §2.30.3.2）。 */
-export function planChangeLines(prev, scan) {
-  const p = prev && typeof prev === "object" ? prev : {}
-  const before = new Set(Array.isArray(p.aged) ? p.aged : [])
-  const freshTitles = scan.agedKeys.map((k, i) => (before.has(k) ? null : scan.agedTitles[i])).filter((t) => t != null)
-  const lines = []
-  if (freshTitles.length) lines.push({ text: formatAgingLine(scan, freshTitles), warn: true })
-  if (scan.thresholdReached && !p.threshold) lines.push({ text: formatThresholdLine(scan), warn: true })
-  return { lines, next: { aged: scan.agedKeys, threshold: scan.thresholdReached } }
-}
-
-/** 去重档键 = 台账绝对路径·正斜杠 + **盘符大写**（跨端同规则——CLI 的 `process.cwd()` 盘符大写、
- *  VSC 的 `uri.fsPath` 小写（`session-slots.mjs` `normalizeCwd` 同一契约——session / checkpoint /
- *  trace 跨端共享即赖此）；CLI 写的键 VSC 须逐字认得）。 */
-export function notifyKey(ledger) {
-  return resolve(ledger).replace(/\\/g, "/").replace(/^([a-z]):/, (_, d) => `${d.toUpperCase()}:`)
-}
-
-/** 去重档读（缺失 / 坏 JSON → 空态——N1 降级不崩）。 */
-export function loadNotifyState(file = NOTIFY_FILE) {
-  try {
-    const j = JSON.parse(readFileSync(file, "utf8"))
-    if (j && typeof j === "object" && j.ledgers && typeof j.ledgers === "object") return { version: 1, ledgers: j.ledgers }
-  } catch { /* 缺失 / 坏档 → 空态 */ }
-  return { version: 1, ledgers: {} }
-}
-
-/** 去重档写（temp + rename 防撕裂；写失败静默返回 false——唯一写面，仅送达后调）。 */
-export function saveNotifyState(file, state) {
-  try {
-    mkdirSync(dirname(file), { recursive: true })
-    const tmp = `${file}.tmp-${process.pid}`
-    writeFileSync(tmp, JSON.stringify(state), "utf8")
-    renameSync(tmp, file)
-    return true
-  } catch { return false }
-}

package/src/log.mjs

@@ -1,195 +0,0 @@
-/**
- * log.mjs — 诊断事件日志（docs/design/LOGGING.md 权威规格）。
- * 双端同构：thincoder/src/log.mjs 与 thincoder-vscode/src/log.mjs 同一实现语义
- * （共享 ~/.thincoder/logs/、同格式、同事件面——F-L6）。
- *
- * 常驻骨架日志：回合/LLM/工具/子代理/挂起的关键事件——每行一个 JSON 事件，按天轮转
- * （agent-YYYY-MM-DD.log），保留 1 天——用户零手动维护（F-L3/NF-L4）。问题发生时
- * 直接 tail/grep 定位断点（根治"临时插桩再删"循环）。
- *
- * 纪律（实现侧逐条落实）：
- * - fire-and-forget：logEvent 失败静默降级（NF-L1）——主流程零影响。进程内首次写失败
- *   即置死（_dead），当日不再尝试（磁盘满/权限错不逐事件空转）。
- * - 单事件行 <512 字符（NF-L2）：head（LLM ≤300 / 工具 ≤200）、err ≤200 由调用方截断，
- *   本模块对任意字符串字段做上限兜底（head 300 / err 200 / 其余 120）+ 超长时丢可选字段。
- * - 敏感字段零落盘（NF-L3/§2.4，2026-09-03 评审 refinement #7 匹配语义定稿）：
- *   ① 字段名精确匹配黑名单（apiKey/designToken/password/secret/token，大小写不敏感；
- *      另加防御性名称 authorization/proxy/proxyUri——防凭据型 URL/头字段泄漏——§2.5）
- *      → 整个字段丢弃；
- *   ② 内容只扫密钥形态（sk-xxx / Bearer xxx / key=… 等）→ 截断到形态之前
- *      ——宁可丢信息不漏密钥。
- *   工具事件不记 args；URL 不入事件（llm/tool 事件从不携带 URL；err 文本经形态扫描）。
- * - 摘要截断（B 方案，2026-09-03 用户裁定）：截断处带 "…" 标记（截后仍 ≤上限）。
- * - 测试隔离：node --test 进程（NODE_TEST_CONTEXT）默认不写盘——防测试事件污染真实
- *   诊断日志（两端测试套件都会跑真实 agent 管线）；显式设置 THINCODER_LOG_DIR 强制
- *   写入该目录（log.test.mjs 用它隔离临时目录——refinement #6）。
- * - 轮转清理（refinement #3——长驻进程覆盖）：非仅启动时——每进程每日**首次写事件**
- *   时顺带清理 >1 天的 agent-*.log（extension host 可长驻数月，启动清理覆盖不到）。
- * - seq：每进程单调计数器。双端同写一个文件时 seq 会各自重复——定位同文件时序以
- *   ts 为准，seq 仅进程内参照（refinement #8）。
- */
-
-import { appendFileSync, mkdirSync, readdirSync, rmSync, existsSync, statSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-/** 单行长度硬上限（NF-L2） */
-export const MAX_LINE = 512
-/** 字段名精确黑名单（NF-L3/§2.4——2026-09-03 评审 refinement #7：与 §2.4 词表一致含 token） */
-const BLACKLIST_FIELDS = new Set(["apikey", "designtoken", "password", "secret", "token", "authorization", "proxyuri", "proxy"])
-/** 内容密钥形态扫描（大小写不敏感）——命中即截断到形态前 */
-const SECRET_FORM = /(\bsk-[A-Za-z0-9_-]{6,}|\bBearer\s+[A-Za-z0-9._~+/=-]{6,}|\b(?:api[_-]?key|key|token|secret|password|pwd|passwd)\s*[=:]\s*['"]?[A-Za-z0-9._~+/=-]{6,})/i
-/** 字符串字段长度兜底：head ≤300 / err ≤200 / 其余 ≤120 */
-const FIELD_CAPS = { head: 300, err: 200 }
-
-let _seq = 0
-let _dead = false // 进程内写失败即死（NF-L1 静默降级——不逐事件重复空转）
-let _cleanupDate = null // 本进程已执行过清理的日期（每日首次写时清一次）
-
-/** 日志目录：THINCODER_LOG_DIR（测试隔离/override）> ~/.thincoder/logs（与 sessions/ 同域） */
-export function logsDir() {
-  return process.env.THINCODER_LOG_DIR ?? join(homedir(), ".thincoder", "logs")
-}
-
-/** 今日日志文件路径（agent-YYYY-MM-DD.log） */
-export function todayLogPath(now = new Date()) {
-  const ymd = now.toISOString().slice(0, 10)
-  return join(logsDir(), `agent-${ymd}.log`)
-}
-
-/** 写门（测试隔离）：test runner 进程（NODE_TEST_CONTEXT）默认跳过——除显式
- *  THINCODER_LOG_DIR override（log.test.mjs 隔离临时目录——refinement #6）。 */
-function writeEnabled() {
-  if (_dead) return false
-  if (process.env.NODE_TEST_CONTEXT && !process.env.THINCODER_LOG_DIR) return false
-  return true
-}
-
-/** 清理 >1 天的 agent-*.log（NF-L4——refinement #3：机会式，非仅启动时）。
- *  保留窗口（2026-09-03 code review #1 修正）：以文件名日期的**当日结束**为龄基准——
- *  今天+昨天的文件保留（任何事件至少留存 24h、最多 48h），早于昨天的删除。
- *  无法按名解析日期的 agent-*.log 按 mtime 兜底（>1 天未写的删除）。
- *  导出供测试直呼（T-L7/T-L7b）。静默：任何失败都不影响主流程。 */
-export const LOG_RETENTION_MS = 24 * 60 * 60 * 1000
-export function cleanupOldLogs(now = new Date()) {
-  const dir = logsDir()
-  if (!existsSync(dir)) return
-  let names
-  try {
-    names = readdirSync(dir)
-  } catch {
-    return
-  }
-  for (const name of names) {
-    if (!name.startsWith("agent-") || !name.endsWith(".log")) continue
-    const m = name.match(/^agent-(\d{4}-\d{2}-\d{2})\.log$/)
-    const ts = m ? Date.parse(m[1] + "T00:00:00Z") : NaN
-    // 文件名日期 → 龄以该日结束（ts+24h）计：事件在删除时至少已留存 24h
-    const ageMs = Number.isFinite(ts) ? now - (ts + LOG_RETENTION_MS) : (tryStatAge(dir, name, now) ?? Infinity)
-    if (ageMs > LOG_RETENTION_MS) {
-      try { rmSync(join(dir, name), { force: true }) } catch { /* 静默 */ }
-    }
-  }
-}
-
-function tryStatAge(dir, name, now) {
-  try {
-    return now - statSync(join(dir, name)).mtimeMs
-  } catch {
-    return null
-  }
-}
-
-/**
- * 写入一条事件（fire-and-forget）。fields 内所有字符串都经黑名单/截断处理。
- * 事件行结构：{"ts":ISO,"ev":kind,"seq":N,...fields}——单行 JSON <512 字符。
- */
-export function logEvent(kind, fields = {}) {
-  if (!writeEnabled()) return
-  const now = new Date()
-  // 机会式轮转清理：每进程每日首次写事件时执行一次（refinement #3——长驻进程覆盖）
-  const ymd = now.toISOString().slice(0, 10)
-  if (_cleanupDate !== ymd) {
-    _cleanupDate = ymd
-    cleanupOldLogs(now)
-  }
-  const entry = { ts: now.toISOString(), ev: kind, seq: ++_seq }
-  for (const [k, v] of Object.entries(fields ?? {})) {
-    if (v === undefined || v === null) continue
-    // ① 字段名精确黑名单 → 丢弃（token 族永不落盘）
-    if (BLACKLIST_FIELDS.has(String(k).toLowerCase())) continue
-    if (typeof v === "string") entry[k] = sanitizeString(k, v)
-    else if (typeof v === "number" || typeof v === "boolean") entry[k] = v
-  }
-  let line = JSON.stringify(entry)
-  // ② 防御性收尾（NF-L2）：字段上限后仍超长 → 丢可选字段（保留 ts/ev/seq）直至 <512
-  while (line.length > MAX_LINE && Object.keys(entry).length > 3) {
-    for (const k of Object.keys(entry)) {
-      if (k !== "ts" && k !== "ev" && k !== "seq") { delete entry[k]; break }
-    }
-    line = JSON.stringify(entry)
-  }
-  try {
-    const dir = logsDir()
-    mkdirSync(dir, { recursive: true })
-    appendFileSync(join(dir, `agent-${ymd}.log`), line + "\n", "utf8")
-  } catch {
-    _dead = true // NF-L1：写失败静默降级——主流程零影响
-  }
-}
-
-/** 共享脱敏（§18.6 D-TR2——trace-store 复用；logEvent 自身保持"丢弃字段"语义，
- *  本函数提供"遮蔽标记"语义——同一字段名黑名单 + 同一 SECRET_FORM 形态扫描，
- *  不发明新遮蔽模式）。字段名命中黑名单 → "[REDACTED]（整个字段遮蔽）；内容命中
- *  密钥形态 → 截断到形态前 + "[redacted]" 标记（宁可丢信息不漏密钥——§2.4）。 */
-export function redactSecret(fieldKey, value) {
-  const s = String(value)
-  if (BLACKLIST_FIELDS.has(String(fieldKey).toLowerCase())) return "[REDACTED]"
-  const hit = s.match(SECRET_FORM)
-  return hit ? s.slice(0, hit.index) + "[redacted]" : s
-}
-
-/** 内容级净化：密钥形态截断到形态前（②）；超长截断 + "…" 标记。 */
-export function sanitizeString(key, value) {
-  let s = String(value)
-  // 密钥形态 → 截断到形态前（宁可丢信息不漏密钥——§2.4）
-  const hit = s.match(SECRET_FORM)
-  if (hit) s = s.slice(0, hit.index)
-  const cap = FIELD_CAPS[key] ?? 120
-  if (s.length > cap) s = s.slice(0, cap - 1) + "…"
-  return s
-}
-
-/** 错误文本提取：message + cause 链首条、压成单行、≤max（默认 200——NF-L2/§2.2） */
-export function errText(err, max = 200) {
-  let msg = err?.message ?? String(err ?? "")
-  if (!msg && err?.cause) msg = String(err.cause)
-  if (err?.cause?.message && !/^LLM API error/.test(msg)) msg += ` (${err.cause.message})`
-  msg = msg.replace(/\s*\n\s*/g, " ").trim()
-  if (msg.length > max) msg = msg.slice(0, max - 1) + "…"
-  return msg
-}
-
-/** 错误 kind 分类（llm:error 字段）：timeout（网关超时/超时信号）/ abort（用户中止）/
- *  error（其余——API/网络/未分类）。signal 为请求中止信号（chat 调用点直传）。 */
-export function classifyErr(err, signal) {
-  const msg = String(err?.message ?? "").toLowerCase() + " " + String(err?.cause?.message ?? "").toLowerCase()
-  if (/timeout|timed ?out|etimedout|time limit exceeded/i.test(msg)) return "timeout"
-  if (err?.name === "AbortError" || signal?.aborted) {
-    return signal?.reason?.name === "TimeoutError" ? "timeout" : "abort"
-  }
-  return "error"
-}
-
-/** 文本头截取：前 max 字符、单行化（JSON 单行约束）、截断带 "…" 标记。
- *  paragraph=true（llm:done 响应头）：取首段（首个空行前）——B 方案"首段文本"语义。 */
-export function headText(text, max, { paragraph = false } = {}) {
-  let s = String(text ?? "")
-  if (paragraph) {
-    const p = s.split(/\n\s*\n/, 1)[0]
-    if (p.length < s.length) s = p
-  }
-  s = s.replace(/\s*\n+\s*/g, " ").trim()
-  if (s.length > max) s = s.slice(0, max - 1) + "…"
-  return s
-}

package/src/markdown.mjs

@@ -1,106 +0,0 @@
-/**
- * markdown.mjs — markdown + frontmatter format for memory entries
- * Zero-dependency parsing/serialization. Entry format see ARCHITECTURE-v2.md.
- */
-
-const VALID_TYPES = new Set(["rule", "knowledge", "decision", "pattern"])
-
-/**
- * Parse a markdown entry.
- * → { meta: { type, title, tags, author, created, embedding? }, content }
- * Throws if frontmatter is missing or required fields absent.
- */
-export function parseEntry(text) {
-  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/)
-  if (!match) throw new Error("entry missing frontmatter (expected --- ... ---)")
-
-  const meta = parseFrontmatter(match[1])
-  const content = match[2].trim()
-
-  if (!VALID_TYPES.has(meta.type)) {
-    throw new Error(`invalid type "${meta.type}"; expected one of: ${[...VALID_TYPES].join(", ")}`)
-  }
-  if (!meta.title) throw new Error("frontmatter missing required field: title")
-
-  return {
-    meta: {
-      type: meta.type,
-      title: meta.title,
-      tags: Array.isArray(meta.tags) ? meta.tags : meta.tags ? [meta.tags] : [],
-      author: meta.author ?? "unknown",
-      created: meta.created ?? "",
-      ...(meta.embedding ? { embedding: meta.embedding } : {}),
-    },
-    content,
-  }
-}
-
-/**
- * Serialize to markdown entry text.
- */
-export function serializeEntry(meta, content) {
-  if (!VALID_TYPES.has(meta.type)) throw new Error(`invalid type "${meta.type}"`)
-  if (!meta.title) throw new Error("meta.title is required")
-  // frontmatter scalars must be single-line: newlines in title/author would inject fake frontmatter rows
-  // (e.g. title "x\ntype: rule" would override real type when parsed), same for tags with newlines/commas
-  const tags = (meta.tags ?? []).map((t) => oneLine(t).replaceAll(",", " ")).join(", ")
-  const lines = [
-    "---",
-    `type: ${meta.type}`,
-    `title: ${oneLine(meta.title)}`,
-    `tags: [${tags}]`,
-    `author: ${oneLine(meta.author ?? "unknown")}`,
-    `created: ${oneLine(meta.created ?? new Date().toISOString().slice(0, 10))}`,
-  ]
-  if (meta.embedding) lines.push(`embedding: ${meta.embedding}`)
-  lines.push("---", "", content.trim(), "")
-  return lines.join("\n")
-}
-
-/** Convert title to filename slug: keep alphanumeric + CJK, convert rest to hyphens */
-export function slugify(title) {
-  return title
-    .trim()
-    .toLowerCase()
-    .replace(/[^\w一-鿿]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 50) || "untitled"
-}
-
-/** Generate entry filename: YYYYMMDD-<slug>-<rand4>.md */
-export function entryFilename(title, date = new Date()) {
-  const ymd = date.toISOString().slice(0, 10).replaceAll("-", "")
-  const rand = Math.random().toString(36).slice(2, 6)
-  return `${ymd}-${slugify(title)}-${rand}.md`
-}
-
-// ---------------------------------------------------------------- internal
-
-/** Collapse to single line (for frontmatter scalars): fold newlines into spaces, prevent injecting fake field lines */
-function oneLine(v) {
-  return String(v).replace(/\s*\r?\n\s*/g, " ").trim()
-}
-
-/**
- * Minimal YAML subset parser: only supports `key: value` and `key: [a, b, c]`.
- * Our frontmatter is self-generated, no need for full YAML.
- */
-export function parseFrontmatter(text) {
-  const meta = {}
-  for (const line of text.split(/\r?\n/)) {
-    const m = line.match(/^(\w[\w-]*)\s*:\s*(.*)$/)
-    if (!m) continue
-    const [, key, raw] = m
-    const value = raw.trim()
-    if (value.startsWith("[") && value.endsWith("]")) {
-      meta[key] = value
-        .slice(1, -1)
-        .split(",")
-        .map((s) => s.trim())
-        .filter(Boolean)
-    } else {
-      meta[key] = value
-    }
-  }
-  return meta
-}

package/src/mcp/helpers.mjs

@@ -1,51 +0,0 @@
-/**
- * mcp/helpers.mjs — MCP shared utility functions and constants
- */
-
-export const INIT_TIMEOUT_MS = 30_000
-export const CALL_TIMEOUT_MS = 120_000
-export const ENDPOINT_WAIT_MS = 5_000
-
-let nextRpcId = 0
-/** Generate a unique incrementing RPC ID string */
-export function rpcId() {
-  return String(++nextRpcId)
-}
-
-/** Race a promise against a timeout, rejecting after ms milliseconds */
-export function withTimeout(promise, ms) {
-  let timer
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms)
-    timer.unref?.()
-  })
-  return Promise.race([promise.finally(() => clearTimeout(timer)), timeout])
-}
-
-/** Quote a shell argument: wrap in double-quotes if it contains whitespace or quotes */
-export function quoteArg(s) {
-  return /[\s"]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s
-}
-
-/** Convert an Authorization Bearer token into a WebSocket subprotocol.
- *  2026-08-31 MCP 会诊 #10：原实现把 token 塞进 URL query——代理/网关日志会泄露凭证，
- *  且无标准依据。Node 内置 WebSocket（undici）无法自定义请求头，MCP 生态的标准替代
- *  通道是 subprotocol（`bearer.<token>`）。用户 URL 自带的 query token 不动（兼容）。
- *  @returns {{ url: string, protocols: string[] }} — protocols 为空数组表示无认证。 */
-export function withAuthToken(wsUrl, authorization) {
-  if (!authorization) return { url: wsUrl, protocols: [] }
-  const token = authorization.replace(/^Bearer\s+/i, "")
-  let u
-  try {
-    u = new URL(wsUrl)
-  } catch {
-    throw new Error(`Invalid WebSocket URL: ${String(wsUrl).slice(0, 120)}`)
-  }
-  // subprotocol 不进入 URL/日志，token 不再注入 query
-  return { url: u.href, protocols: [`bearer.${token}`] }
-}
-
-/** Sanitize a tool name: replace non-alphanumeric chars with underscores, cap at 64 chars */
-export function sanitizeToolName(name) {
-  return name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64)
-}