@paircode/tool-project-info 1.0.2 → 1.1.0

package/index.js

@@ -1,191 +1,102 @@
 // ═══════════════════════════════════════════════════════════════
-// tool-project-info — 项目知识库（project_info_write/read/list/search/delete/explore）
+// tool-project-info — 项目知识库（单工具 project_info(op=write/read/list/tree/search/delete/explore)；2026-09 由 7 工具合并）
 //
-// ★ 2026-08-22 JS 原生化：调用实现（JS 编排 ctx.fs 读写 .pair/project-info/、
-//   目录扫描建树、explore 结构概览）完全在插件内——不再依赖独立二进制。
-// 工具清单：project_info_write、project_info_read、project_info_list、project_info_tree、project_info_search、project_info_delete、project_info_explore
+// 迁移（2026-08-22 Round2）：binary 形态 → JS 原生（对齐 tool-core 模式）。
+// 原 execute 调 ctx.binary.exec 复用插件目录 bin/ 下独立二进制（已归档
+// bin/legacy-plugin-bins/），现实现完全在插件内（ctx.fs 读写 .pair/project-info/），
+// 不再依赖 ctx.binary。行为复刻 internal/agent/projectinfo.go（树形路径分级、
+// notes/ 前缀镜像、渐进式披露、多项目 project 路由）。
+// 工具清单：project_info（op=write/read/list/tree/search/delete/explore）
 // ═══════════════════════════════════════════════════════════════
+// ★ 2026-08-29（候选 A 创造需求）：改用 mini Node API——require('path')
+//   统一路径拼接（手工 d+'/'+name 在 Windows 分隔符下有隐患）。
+const path = require('path')
 const tools = [
   {
-    "name": "project_info_write",
-    "description": "写入/更新项目知识库的一篇（.pair/project-info/\u003c路径\u003e.md）——记录项目架构/模块职责/数据流/设计决策等结构化理解，跨会话复用、你和用户都能看。★树形路径：顶层分支 目标/架构/实现/关键点/设计思想，根条目用 概览（如 架构/模块-agent / 设计思想/决策-渲染架构）；兼容参考项目 notes/ 前缀路径（自动映射分支+镜像 .agents/notes/）。",
-    "usageGuide": "写入/更新项目知识库条目，跨会话复用。★知识库是树：顶层分支 = 目标/架构/实现/关键点/设计思想（根为 概览）——路径带分支前缀（如 架构/模块-agent / 设计思想/决策-渲染架构）。也可用参考项目风格路径 notes/implemented/architecture/x（自动归入树分支 架构/x 并镜像 .agents/notes/）。读完关键文件后立即写入，积累项目的结构化理解。比记在脑子里可靠（持久化+跨会话可见）。多项目工作区可用 project 参数指定目标项目。",
+    "name": "project_info",
+    "description": "项目知识库（.pair/project-info/ 树形文档）统一入口。op=write 写入/更新条目（path+content）；op=read 读某篇全文（path）；op=list 列出全部条目的总览；op=tree 返回完整树形结构；op=search 按关键词搜索（query）；op=delete 删除某篇（path）；op=explore 返回项目目录结构概览（构建知识库的起点）。",
+    "usageGuide": "项目知识库操作（渐进式披露）：先 list/tree 看有哪些文档，search 查关键词，read 读全文；explore 扫描项目结构起步；write 记录结构化理解（顶层分支：目标/架构/实现/关键点/设计思想，根为 概览；path 带分支前缀如 架构/模块-agent，兼容 notes/ 前缀镜像 .agents/notes/）；delete 清理过时条目。比记在脑子里可靠（持久化+跨会话可见）。多项目工作区用 project 指定项目。",
     "parameters": {
       "properties": {
         "content": {
-          "description": "Markdown 正文（首行用 # 标题）",
+          "description": "write 用：Markdown 正文（首行用 # 标题）",
           "type": "string"
         },
-        "path": {
-          "description": "条目路径（中文，带顶层分支前缀：目标/架构/实现/关键点/设计思想，如 架构/模块-agent），不含 .md；用 / 嵌套为细节篇",
+        "op": {
+          "description": "操作：write 写入/read 读取/list 总览/tree 树形/search 搜索/delete 删除/explore 项目结构扫描",
+          "enum": [
+            "write",
+            "read",
+            "list",
+            "tree",
+            "search",
+            "delete",
+            "explore"
+          ],
           "type": "string"
         },
-        "project": {
-          "description": "可选：目标项目（工作区项目目录名如 wb-ui，或相对主项目的路径/绝对路径）。省略 = 主项目。多项目工作区：gou-ide、wb-ui、ref 等。",
-          "type": "string"
-        }
-      },
-      "required": [
-        "path",
-        "content"
-      ],
-      "type": "object"
-    }
-  },
-  {
-    "name": "project_info_read",
-    "description": "读取知识库某篇的全文（按路径，如 概览 / 模块-agent）。渐进式披露的细节层。",
-    "usageGuide": "读取知识库某篇全文。渐进式披露：先 project_info_list 看总览，再用此工具读具体细则。比翻目录更方便（自动解析路径+内容格式化）。",
-    "parameters": {
-      "properties": {
         "path": {
-          "description": "条目路径，不含 .md",
+          "description": "write/read/delete 用：条目路径（中文，带顶层分支前缀：目标/架构/实现/关键点/设计思想，如 架构/模块-agent），不含 .md；用 / 嵌套为细节篇",
           "type": "string"
         },
-        "project": {
-          "description": "可选：目标项目（工作区项目目录名如 wb-ui，或相对主项目的路径/绝对路径）。省略 = 主项目。多项目工作区：gou-ide、wb-ui、ref 等。",
-          "type": "string"
-        }
-      },
-      "required": [
-        "path"
-      ],
-      "type": "object"
-    },
-    "readOnly": true
-  },
-  {
-    "name": "project_info_list",
-    "description": "列出知识库所有条目的【总览】（路径 + 标题 + 分级）。渐进式披露的总览层。",
-    "usageGuide": "列出知识库所有条目的总览（路径+标题+分级）。新项目先调此工具查看已有哪些文档，避免重复写入。",
-    "parameters": {
-      "properties": {
-        "project": {
-          "description": "可选：目标项目（工作区项目目录名如 wb-ui，或相对主项目的路径/绝对路径）。省略 = 主项目。多项目工作区：gou-ide、wb-ui、ref 等。",
-          "type": "string"
-        }
-      },
-      "type": "object"
-    },
-    "readOnly": true
-  },
-  {
-    "name": "project_info_tree",
-    "description": "返回知识库完整树形结构（缩进树：目标/架构/实现/关键点/设计思想 分支 + 条目）。人可读的树形导航。",
-    "usageGuide": "查看知识库完整树形结构（分支/子类/条目缩进树）。比 project_info_list 更直观：先看树定位条目，再 project_info_read 读全文。",
-    "parameters": {
-      "properties": {
-        "project": {
-          "description": "可选：目标项目（工作区项目目录名如 wb-ui，或相对主项目的路径/绝对路径）。省略 = 主项目。多项目工作区：gou-ide、wb-ui、ref 等。",
-          "type": "string"
-        }
-      },
-      "type": "object"
-    },
-    "readOnly": true
-  },
-  {
-    "name": "project_info_search",
-    "description": "按关键词搜索知识库（匹配路径/标题/正文），返回命中条目。",
-    "usageGuide": "按关键词搜索知识库（匹配路径/标题/正文）。想查某个模块/概念是否已有文档时优先用此工具。",
-    "parameters": {
-      "properties": {
         "project": {
           "description": "可选：目标项目（工作区项目目录名如 wb-ui，或相对主项目的路径/绝对路径）。省略 = 主项目。多项目工作区：gou-ide、wb-ui、ref 等。",
           "type": "string"
         },
         "query": {
-          "description": "关键词",
+          "description": "search 用：关键词",
           "type": "string"
         }
       },
       "required": [
-        "query"
-      ],
-      "type": "object"
-    },
-    "readOnly": true
-  },
-  {
-    "name": "project_info_delete",
-    "description": "删除知识库某篇（按路径）。",
-    "usageGuide": "删除知识库某篇（按路径）。知识库条目过时/错误时用此工具清理。删除前建议先 project_info_read 确认。",
-    "parameters": {
-      "properties": {
-        "path": {
-          "description": "条目路径，不含 .md",
-          "type": "string"
-        },
-        "project": {
-          "description": "可选：目标项目（工作区项目目录名如 wb-ui，或相对主项目的路径/绝对路径）。省略 = 主项目。多项目工作区：gou-ide、wb-ui、ref 等。",
-          "type": "string"
-        }
-      },
-      "required": [
-        "path"
+        "op"
       ],
       "type": "object"
     }
   },
-  {
-    "name": "project_info_explore",
-    "description": "返回项目目录结构概览（根目录关键文件、顶层目录及文件数）——构建知识库的起点；据此用 read_file 读关键文件分析，再 project_info_write 写入 概览/模块-*/决策-*。",
-    "usageGuide": "扫描项目目录结构概览——构建知识库的起点。新项目首次接触时先调此工具了解项目全貌，再用 read_file 读关键文件，最后 project_info_write 写入结构化理解。",
-    "parameters": {
-      "properties": {},
-      "type": "object"
-    },
-    "readOnly": true
-  }
+  // （project_info_read / project_info_list 已并入单工具 project_info——op=read/list）
+  // （project_info_tree / project_info_search 已并入单工具 project_info——op=tree/search）
+  // （project_info_delete / project_info_explore 已并入单工具 project_info——op=delete/explore）
 ];
 
-// ─── JS 原生化实现（ctx.fs 读写 .pair/project-info/） ─────────
 
-// 知识库根：project 非空 → ../<project>/.pair/project-info（多根归属由 resolve 检查）；绝对路径直接传。
-function infoRoot(ctx, args) {
-  const project = args.project
-  if (!project) return '.pair/project-info'
-  if (/^[a-zA-Z]:[\\/]/.test(project) || project.startsWith('/')) {
-    return String(project).replace(/[\\/]+$/, '') + '/.pair/project-info'
+// ─── JS 原生化实现（ctx.fs） ────────────────────
+
+// infoDirFromArgs 解析 project 参数 → 目标项目知识库目录（缺省 = 主项目）。
+// 多项目工作区中知识库按项目隔离（.pair/project-info/ 在各项目根下）。
+function infoDir(ctx, args) {
+  const project = args && args.project
+  if (project && !/^[a-zA-Z]:[\/]/.test(project) && !project.startsWith('/')) {
+    return '../' + String(project).replace(/[\/]+$/, '') + '/.pair/project-info'
   }
-  return '../' + String(project).replace(/[\\/]+$/, '') + '/.pair/project-info'
+  return '.pair/project-info'
 }
 
-const infoBranches = { 目标: 1, 架构: 1, 实现: 1, 关键点: 1, 设计思想: 1 }
-function isInfoBranch(head) { return !!infoBranches[head] }
-
 // safeInfoPath 规范化条目路径：去 .md、清理、禁路径穿越（..、绝对路径），允许 / 嵌套。
-function safeInfoPath(p) {
-  p = String(p || '').replace(/\.md$/, '').trim().replace(/\\/g, '/')
-  // path.Clean 近似：拆段抵消 ...
-  const segs = []
-  for (const s of p.split('/')) {
+function cleanSegs(p) {
+  const out = []
+  for (const s of String(p).split('/')) {
     if (s === '' || s === '.') continue
-    if (s === '..') { segs.pop(); continue }
-    segs.push(s)
+    if (s === '..') { out.pop(); continue }
+    out.push(s)
   }
-  return segs.join('/')
+  return out.join('/')
 }
-
-function infoLevel(rel) {
-  const low = String(rel).toLowerCase()
-  if (low === 'overview' || rel === '概览' || rel === '项目概览') return 'overview'
-  if ((rel.match(/\//g) || []).length >= 2) return 'detail'
-  return 'module'
+function safeInfoPath(p) {
+  let s = String(p == null ? '' : p).replace(/\.md\s*$/, '').trim()
+  s = s.replace(/\\/g, '/')
+  return cleanSegs('/' + s).replace(/^\/+|\/+$/g, '')
 }
 
-function firstHeading(md, fallback) {
-  for (const ln of String(md).split('\n')) {
-    const s = ln.trim()
-    if (s.startsWith('# ')) return s.slice(2).trim()
-  }
-  return fallback
+const infoBranches = ['目标', '架构', '实现', '关键点', '设计思想']
+function isInfoBranch(head) {
+  return infoBranches.indexOf(head) >= 0
 }
 
-// notesToBranchRel 参考项目决策树路径 → 知识库树分支路径（与 Go 版同映射）。
+// notesToBranchRel 把决策树路径映射到知识库树分支路径（复刻 Go 实现）。
 function notesToBranchRel(n) {
   n = String(n).replace(/^notes\//, '').replace(/^\//, '')
-  if (!n) return null
+  if (n === '') return null
   const segs = n.split('/')
   const leaf = segs[segs.length - 1]
   let branch
@@ -196,186 +107,283 @@ function notesToBranchRel(n) {
   else if (segs[0] === 'decision' || segs[0] === 'decisions') branch = '设计思想'
   else if (segs.length >= 2 && segs[0] === 'inbox') branch = '实现'
   else branch = '实现'
-  return branch + '/' + leaf
+  return path.join(branch, leaf)
+}
+
+// firstHeading 取 Markdown 首行 # 标题。
+function firstHeading(md, fallback) {
+  for (const ln of String(md).split('\n')) {
+    const s = ln.trim()
+    if (s.startsWith('# ')) return s.slice(2).trim()
+  }
+  return fallback
+}
+
+// infoLevel 按路径分级：overview = 根条目；module = 1 层；detail = 2+ 层。
+function infoLevel(rel) {
+  const low = String(rel).toLowerCase()
+  if (low === 'overview' || rel === '概览' || rel === '项目概览') return 'overview'
+  if (String(rel).split('/').length >= 3) return 'detail'
+  return 'module'
 }
 
-// scanInfoEntries 递归扫描知识库目录（.md），返回 [{path,title,level,content}]。
-// 附加源：工作区 .agents/notes/ 存在时并入（路径前缀 notes/；树中已有镜像则跳过）。
-function scanInfoEntries(ctx, args) {
-  const rootDir = infoRoot(ctx, args)
+// walkMd 递归扫描目录下的 .md 条目（返回 {rel, title, content} 列表）。
+function walkMd(ctx, base, prefix) {
+  let names = []
+  try { names = ctx.fs.readdir(base) } catch (e) { return [] }
   const out = []
-  const walkDir = (base, prefix, skip) => {
-    let names = []
-    try { names = ctx.fs.readdir(base) } catch { return }
-    for (const n of names.sort()) {
-      const p = base + '/' + n
-      let st
-      try { st = ctx.fs.stat(p) } catch { continue }
-      const rel = (prefix ? prefix + '/' : '') + n.replace(/\.md$/, '')
-      if (st.isDir) {
-        walkDir(p, rel, skip)
-      } else if (n.endsWith('.md')) {
-        if (skip && skip(rel)) continue
-        const content = ctx.fs.readFile(p)
-        out.push({ path: rel, title: firstHeading(content, rel), level: infoLevel(rel), content })
-      }
+  for (const n of names) {
+    const full = path.join(base, n)
+    let st = null
+    try { st = ctx.fs.stat(full) } catch (e) { continue }
+    if (st.isDir) {
+      out.push(...walkMd(ctx, full, path.join(prefix, n)))
+      continue
     }
+    if (!n.endsWith('.md')) continue
+    let content = ''
+    try { content = ctx.fs.readFile(full) } catch (e) { continue }
+    const rel = (prefix ? prefix + '/' : '') + n.slice(0, -3)
+    out.push({ rel, title: firstHeading(content, rel), level: infoLevel(rel), content })
   }
-  walkDir(rootDir, '', null)
-  // .agents/notes 附加源：rootDir 为 <projRoot>/.pair/project-info → 项目根 = 去掉该尾缀
-  const projRoot = rootDir.replace(/\/\.pair\/project-info$/, '')
-  const notes = (projRoot ? projRoot + '/' : '') + '.agents/notes'
-  if (notes !== rootDir) {
-    walkDir(notes, 'notes', (nrel) => {
-      const br = notesToBranchRel(nrel)
-      if (!br) return false
-      try { ctx.fs.exists(rootDir + '/' + br + '.md'); return ctx.fs.exists(rootDir + '/' + br + '.md') } catch { return false }
-    })
+  return out
+}
+
+// scanInfoEntries 递归扫描知识库目录；附加源 .agents/notes/ 并入（路径前缀 notes/）。
+function scanInfoEntries(ctx, dir) {
+  const out = walkMd(ctx, dir, '')
+  // 项目根：dir 为 <root>/.pair/project-info → root = 去掉后缀
+  const root = String(dir).replace(/\/\.pair\/project-info$/, '')
+  const notes = root + '/.agents/notes'
+  if (notes !== dir) {
+    for (const e of walkMd(ctx, notes, 'notes')) {
+      const br = notesToBranchRel(e.rel)
+      if (!br) continue
+      // 树中已有镜像副本 → 跳过，避免重复
+      if (ctx.fs.exists(path.join(dir, br + '.md'))) continue
+      out.push({ rel: e.rel, title: e.title, level: infoLevel(e.rel), content: e.content })
+    }
   }
-  out.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
+  out.sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0))
   return out
 }
 
-// infoTree 构建知识库缩进树文本（分支=目录，叶子=条目）。showLevel 时叶子带分级标记。
+// partsOf 取条目路径末段（文件名段）。
+function partsOf(rel) {
+  const i = String(rel).lastIndexOf('/')
+  return i >= 0 ? rel.slice(i + 1) : rel
+}
+
+// infoTree 构建知识库条目树（分支=目录，叶子=条目），返回缩进树文本。
 function infoTree(entries, showLevel) {
-  const root = { children: {}, entry: null }
-  const ensure = (node, name) => {
-    if (!node.children[name]) node.children[name] = { children: {}, entry: null, name }
-    return node.children[name]
-  }
+  const root = { children: {} }
   for (const e of entries) {
-    const parts = e.path.split('/')
+    const parts = e.rel.split('/')
     let cur = root
-    for (let i = 0; i < parts.length - 1; i++) cur = ensure(cur, parts[i])
+    for (let i = 0; i < parts.length - 1; i++) {
+      const seg = parts[i]
+      if (!cur.children[seg]) cur.children[seg] = { name: seg, children: {} }
+      cur = cur.children[seg]
+    }
     const leaf = parts[parts.length - 1]
-    const n = ensure(cur, leaf)
-    n.entry = e
+    if (!cur.children[leaf]) cur.children[leaf] = { name: leaf, children: {} }
+    cur.children[leaf].entry = e
   }
-  let text = ''
-  const walk = (node, prefix) => {
-    const keys = Object.keys(node.children).sort()
-    keys.forEach((k, i) => {
-      const ch = node.children[k]
+  let b = ''
+  const walk = (n, prefix) => {
+    const keys = Object.keys(n.children).sort()
+    for (let i = 0; i < keys.length; i++) {
+      const ch = n.children[keys[i]]
       const last = i === keys.length - 1
-      const conn = last ? '└── ' : '├── '
-      const nextPrefix = prefix + (last ? '    ' : '│   ')
+      let conn = '├── ', nextPrefix = prefix + '│   '
+      if (last) { conn = '└── '; nextPrefix = prefix + '    ' }
       if (ch.entry) {
         let mark = ''
         if (showLevel) mark = ' [' + ch.entry.level + ']'
         let title = ch.entry.title
-        const leaf = ch.entry.path.split('/').pop()
+        const leaf = partsOf(ch.entry.rel)
         if (leaf && leaf !== title) title += '（' + leaf + '）'
-        text += prefix + conn + title + mark + '\n'
+        b += prefix + conn + title + mark + '\n'
       } else {
-        text += prefix + conn + k + '/\n'
+        b += prefix + conn + keys[i] + '/\n'
       }
       walk(ch, nextPrefix)
-    })
+    }
   }
   walk(root, '')
-  return text
+  return b
 }
 
-const infoKeyFiles = { 'go.mod': 1, 'package.json': 1, 'cargo.toml': 1, 'pyproject.toml': 1, 'pom.xml': 1, 'main.go': 1, 'agents.md': 1, 'claude.md': 1, 'go.sum': 1, 'tsconfig.json': 1 }
+// infoKeyFile 是否为「根目录关键文件」。
+function infoKeyFile(n) {
+  const low = String(n).toLowerCase()
+  if (low.startsWith('readme') || low.startsWith('makefile')) return true
+  return ['go.mod', 'package.json', 'cargo.toml', 'pyproject.toml', 'pom.xml',
+    'main.go', 'agents.md', 'claude.md', 'go.sum', 'tsconfig.json'].indexOf(low) >= 0
+}
 
-// exploreProjectStructure 轻量项目结构概览（根目录关键文件 + 顶层目录及文件数）。
+// isSkipDir 常见忽略目录（explore/文件树统计用）。
+// ★ 与内核搜索忽略集（internal/agent/search.go defaultSkipDirs/rootLevelSkipDirs）
+//   保持同源：依赖库/构建产物/VCS + IDE 运行数据目录（_temp/logs/bin/release/…）。
+const skipDirs = new Set([
+  '.git', '.svn', '.hg', '.idea', '.vscode', '.vs',
+  'node_modules', 'bower_components', 'jspm_packages', 'vendor', 'pods',
+  '.pnpm-store', '.yarn', '.dart_tool', '.bundle',
+  'venv', '.venv', '__pycache__', '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox',
+  'dist', 'build', 'out', 'target', '.next', '.nuxt', '.svelte-kit', '.output', '.angular',
+  '.gradle', '.cache', '.turbo', '.parcel-cache', '.eslintcache', 'coverage', '.nyc_output', '.terraform',
+  '.pair', '源码备份', '.agents',
+  '.agent-teams', '.chrome-test', '.verify-tmp', '_temp', '_desktop-archive',
+  'tmp', 'logs', 'gocache', 'screenshots', 'release', 'bin', 'obj', 'gomod', 'gomodcache',
+])
+function isSkipDir(n) {
+  return skipDirs.has(String(n).toLowerCase())
+}
+
+// countDirFiles 数目录下文件（递归，跳过依赖/产物目录，上限 2000 防卡）。
+function countDirFiles(ctx, dir) {
+  let n = 0
+  const walk = (d) => {
+    let names = []
+    try { names = ctx.fs.readdir(d) } catch (e) { return }
+    for (const name of names) {
+      if (n >= 2000) return
+      let st = null
+      try { st = ctx.fs.stat(path.join(d, name)) } catch (e) { continue }
+      if (st.isDir) {
+        if (!isSkipDir(name)) walk(path.join(d, name))
+      } else {
+        n++
+      }
+    }
+  }
+  walk(dir)
+  return n
+}
+
+// exploreProjectStructure 轻量项目结构概览（复刻 Go exploreProjectStructure）。
 function exploreProjectStructure(ctx) {
   let names = []
-  try { names = ctx.fs.readdir('.') } catch (e) { return '无法读取项目根目录：' + e.message }
-  let out = '# 项目结构概览（供分析后写入知识库）\n\n## 根目录关键文件\n'
-  for (const n of names.sort()) {
-    let st
-    try { st = ctx.fs.stat(n) } catch { continue }
-    if (!st.isDir && (/(readme|makefile)/i.test(n) || infoKeyFiles[n.toLowerCase()])) out += '- ' + n + '\n'
+  try { names = ctx.fs.readdir('.') } catch (e) {
+    return '无法读取项目根目录：' + (e && e.message ? e.message : String(e))
   }
-  out += '\n## 顶层目录（文件数）\n'
-  const dirs = []
-  for (const n of names.sort()) {
-    let st
-    try { st = ctx.fs.stat(n) } catch { continue }
-    if (st.isDir) {
-      let cnt = 0
-      try { cnt = (ctx.fs.readdir(n) || []).length } catch { cnt = 0 }
-      dirs.push(n + ' (' + cnt + ')')
-    }
+  const keyFiles = names.filter(n => !isSkipDir(n) && !n.startsWith('.') && infoKeyFile(n))
+  const dirs = names.filter(n => !isSkipDir(n) && !n.startsWith('.'))
+  let b = '# 项目结构概览（供分析后写入知识库）\n\n## 根目录关键文件\n'
+  for (const f of keyFiles) b += '- ' + f + '\n'
+  b += '\n## 顶层目录（约略文件数）\n'
+  for (const d of dirs) {
+    let st = null
+    try { st = ctx.fs.stat(d) } catch (e) { continue }
+    if (!st.isDir) continue
+    b += '- ' + d + '/（约 ' + countDirFiles(ctx, d) + ' 文件）\n'
   }
-  if (dirs.length) out += '- ' + dirs.join('\n- ') + '\n'
-  return out
+  b += '\n建议：用 read 读关键文件分析后，project_info(op=write) 写入「概览」「模块-<名>」「决策-<主题>」等中文条目。'
+  return b
 }
 
-const impls = {
-  project_info_write(ctx, args) {
-    const dir = infoRoot(ctx, args)
-    let rel = safeInfoPath(args.path)
-    if (!rel) throw new Error('path 不能为空')
-    let branchRel = rel, mirrorRel = ''
-    if (rel.startsWith('notes/')) {
-      if (notesToBranchRel(rel)) branchRel = notesToBranchRel(rel)
-      mirrorRel = rel.replace(/^notes\//, '')
-    }
-    const fp = dir + '/' + branchRel + '.md'
-    const parentDir = fp.slice(0, fp.lastIndexOf('/'))
-    if (parentDir && !ctx.fs.exists(parentDir)) ctx.fs.mkdir(parentDir, true)
-    const updating = ctx.fs.exists(fp)
-    ctx.fs.writeFile(fp, String(args.content || ''))
-    if (mirrorRel) {
-      // 镜像 .agents/notes/<原相对路径>.md（项目根 = dir 去掉尾缀）
-      const projRoot = dir.replace(/\/\.pair\/project-info$/, '')
-      const nfp = (projRoot ? projRoot + '/' : '') + '.agents/notes/' + mirrorRel + '.md'
-      const npd = nfp.slice(0, nfp.lastIndexOf('/'))
+// projectInfoWrite（op=write）：写/更新 + notes/ 镜像 + 非分支路径提示。
+function projectInfoWrite(ctx, args) {
+  const dir = infoDir(ctx, args)
+  const rel = safeInfoPath(args.path)
+  if (rel === '') throw new Error('path 不能为空')
+  let branchRel = rel, mirrorRel = ''
+  if (rel.startsWith('notes/')) {
+    const br = notesToBranchRel(rel)
+    if (br) branchRel = br
+    mirrorRel = rel.replace(/^notes\//, '')
+  }
+  const fp = path.join(dir, branchRel + '.md')
+  const slash = Math.max(fp.lastIndexOf('/'), fp.lastIndexOf('\\'))
+  if (slash > 0) {
+    const pd = fp.slice(0, slash)
+    if (pd && !ctx.fs.exists(pd)) ctx.fs.mkdir(pd, true)
+  }
+  const updating = ctx.fs.exists(fp)
+  ctx.fs.writeFile(fp, String(args.content == null ? '' : args.content))
+  if (mirrorRel) { // 镜像：.agents/notes/<原相对路径>.md
+    const root = String(dir).replace(/\/\.pair\/project-info$/, '')
+    const nfp = root + '/.agents/notes/' + mirrorRel + '.md'
+    const nsl = Math.max(nfp.lastIndexOf('/'), nfp.lastIndexOf('\\'))
+    if (nsl > 0) {
+      const npd = nfp.slice(0, nsl)
       if (npd && !ctx.fs.exists(npd)) ctx.fs.mkdir(npd, true)
-      ctx.fs.writeFile(nfp, String(args.content || ''))
     }
-    const head = branchRel.includes('/') ? branchRel.slice(0, branchRel.indexOf('/')) : branchRel
-    let hint = ''
-    if (!rel.startsWith('notes/') && head !== '概览' && !isInfoBranch(head)) {
-      hint = '（提示：知识库是树，建议用顶层分支 目标/架构/实现/关键点/设计思想 开头，如 架构/' + branchRel + '）'
-    }
-    const verb = updating ? '已更新知识库' : '已写入知识库'
-    if (mirrorRel) return verb + '：' + branchRel + '（notes/ 参考路径已镜像 .agents/notes/' + mirrorRel + '）'
-    return verb + '：' + branchRel + hint
-  },
-  project_info_read(ctx, args) {
-    const rel = safeInfoPath(args.path)
-    const fp = infoRoot(ctx, args) + '/' + rel + '.md'
-    if (!ctx.fs.exists(fp)) throw new Error('无此知识库条目：' + rel + '（用 project_info_list 看全部）')
-    return ctx.fs.readFile(fp)
-  },
-  project_info_list(ctx, args) {
-    const entries = scanInfoEntries(ctx, args)
-    if (entries.length === 0) return '（知识库为空。用 project_info_explore 起步、project_info_write 写入，或菜单「探索项目知识库」。）'
-    return infoTree(entries, true)
-  },
-  project_info_tree(ctx, args) {
-    const entries = scanInfoEntries(ctx, args)
-    if (entries.length === 0) return '（知识库为空）'
-    return '# 项目知识库（树）\n' + infoTree(entries, false)
-  },
-  project_info_search(ctx, args) {
-    const q = String(args.query || '').trim().toLowerCase()
-    if (!q) throw new Error('query 不能为空')
-    const lines = []
-    for (const e of scanInfoEntries(ctx, args)) {
-      if ((e.path + e.title + e.content).toLowerCase().includes(q)) lines.push('- ' + e.title + '（' + e.path + '）')
+    ctx.fs.writeFile(nfp, String(args.content == null ? '' : args.content))
+  }
+  let head = branchRel
+  const hi = head.indexOf('/')
+  if (hi > 0) head = head.slice(0, hi)
+  let hint = ''
+  if (!rel.startsWith('notes/') && head !== '概览' && !isInfoBranch(head)) {
+    hint = '（提示：知识库是树，建议用顶层分支 目标/架构/实现/关键点/设计思想 开头，如 架构/' + branchRel + '）'
+  }
+  const verb = updating ? '已更新知识库' : '已写入知识库'
+  if (mirrorRel) return verb + '：' + branchRel + '（notes/ 参考路径已镜像 .agents/notes/' + mirrorRel + '）'
+  return verb + '：' + branchRel + hint
+}
+
+function projectInfoRead(ctx, args) {
+  const dir = infoDir(ctx, args)
+  const rel = safeInfoPath(args.path)
+  const fp = path.join(dir, rel + '.md')
+  if (!ctx.fs.exists(fp)) throw new Error('无此知识库条目：' + rel + '（用 project_info(op=list) 看全部）')
+  return ctx.fs.readFile(fp)
+}
+
+function projectInfoList(ctx, args) {
+  const entries = scanInfoEntries(ctx, infoDir(ctx, args))
+  if (entries.length === 0) return '（知识库为空。用 project_info(op=explore) 起步、project_info(op=write) 写入，或菜单「探索项目知识库」。）'
+  return infoTree(entries, true)
+}
+
+function projectInfoTree(ctx, args) {
+  const entries = scanInfoEntries(ctx, infoDir(ctx, args))
+  if (entries.length === 0) return '（知识库为空）'
+  return '# 项目知识库（树）\n' + infoTree(entries, false)
+}
+
+function projectInfoSearch(ctx, args) {
+  const q = String(args.query == null ? '' : args.query).toLowerCase().trim()
+  if (q === '') throw new Error('query 不能为空')
+  const lines = []
+  for (const e of scanInfoEntries(ctx, infoDir(ctx, args))) {
+    if ((e.rel + e.title + e.content).toLowerCase().includes(q)) {
+      lines.push('- ' + e.title + '（' + e.rel + '）')
     }
-    return lines.length === 0 ? '（无匹配条目）' : lines.join('\n')
-  },
-  project_info_delete(ctx, args) {
-    const rel = safeInfoPath(args.path)
-    const fp = infoRoot(ctx, args) + '/' + rel + '.md'
-    if (!ctx.fs.exists(fp)) throw new Error('无此知识库条目：' + rel)
-    ctx.fs.rm(fp, false)
-    return '已删除知识库条目：' + rel
-  },
-  project_info_explore(ctx, args) {
-    return exploreProjectStructure(ctx)
-  },
+  }
+  if (lines.length === 0) return '（无匹配条目）'
+  return lines.join('\n')
 }
 
+function projectInfoDelete(ctx, args) {
+  const dir = infoDir(ctx, args)
+  const rel = safeInfoPath(args.path)
+  const fp = path.join(dir, rel + '.md')
+  if (!ctx.fs.exists(fp)) throw new Error('无此知识库条目：' + rel)
+  ctx.fs.rm(fp, false)
+  return '已删除知识库条目：' + rel
+}
+
+function projectInfoExplore(ctx, args) {
+  return exploreProjectStructure(ctx)
+}
+
+const impls = {
+  write: projectInfoWrite,
+  read: projectInfoRead,
+  list: projectInfoList,
+  tree: projectInfoTree,
+  search: projectInfoSearch,
+  delete: projectInfoDelete,
+  explore: projectInfoExplore,
+}
+
+
 return {
   name: 'tool-project-info',
   inject: ['fs'],
-  purpose: '项目知识库（project_info_write/read/list/search/delete/explore）——2026-08-22 JS 原生化：调用实现（JS 编排 ctx.fs）完全在插件内，不再依赖独立二进制',
+  purpose: '项目知识库（project_info(op=write/read/list/tree/search/delete/explore)）——迁移自内置 Go 工具组；调用实现（JS 编排 ctx.fs）完全在插件内（Round2 JS 原生化；2026-09 由 7 工具合并为单工具）',
   apply(ctx) {
     for (const t of tools) {
       ctx.tools.register({
@@ -387,7 +395,16 @@ return {
         requiresApproval: t.requiresApproval,
         systemTool: t.systemTool,
         parameters: t.parameters,
-        execute: (args) => impls[t.name](ctx, args || {}),
+        execute: (args) => {
+          const a = args || {}
+          const fn = impls[a.op]
+          if (!fn) {
+            return Promise.resolve(
+              'project_info：op 无效（可用 write/read/list/tree/search/delete/explore）——未执行任何操作'
+            )
+          }
+          return fn(ctx, a)
+        },
       })
     }
   },

package/package.json

@@ -3,8 +3,8 @@
   "name": "@paircode/tool-project-info",
   "scope": "global",
   "type": "plugin",
-  "version": "1.0.2",
-  "description": "项目知识库（project_info_write/read/list/search/delete/explore）（自动生成，迁移自内置 Go 工具组）",
+  "version": "1.1.0",
+  "description": "项目知识库（project_info(op=write/read/list/tree/search/delete/explore)，2026-09 由 7 工具合并；JS 原生实现，非生成物）",
   "keywords": [
     "paircode"
   ],