@modusensus/dsh-mneme 0.10.1 → 0.12.0

package/test/wiki-queries.test.js

@@ -0,0 +1,270 @@
+// queries.js 的回归锁（M1 读侧）。全部用例走真实 T0（fixture 仓库 apply）建数据，
+// 不手插 DB 行——读侧的契约是「DB 索引 × 磁盘真源」的对账，手插行测不出盘上缺页
+// 这类真实故障。锁的点：slug 白名单解析（查不到返回 null，绝不拿用户输入拼路径）、
+// 盘上缺页如实报 page-missing、检索分节与行号、repo 解析的歧义处理。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, unlinkSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { runChoroT0 } from "../src/wiki/t0.js";
+import { createStore } from "../src/store.js";
+import { createChoroQueries } from "../src/wiki/queries.js";
+
+const FIXED_NOW = () => "2026-11-05T00:00:00.000Z";
+
+function makeFixture() {
+  const root = mkdtempSync(join(tmpdir(), "choro-queries-"));
+  writeFileSync(join(root, "package.json"), JSON.stringify({ name: "qfix", scripts: { test: "node --test" } }, null, 2) + "\n", "utf8");
+  mkdirSync(join(root, "src"), { recursive: true });
+  writeFileSync(join(root, "src", "a.js"), 'import { b } from "./b.js";\nimport h from "left-pad";\nexport const a = () => b();\n', "utf8");
+  writeFileSync(join(root, "src", "b.js"), 'import { b2 } from "./b2.js";\nexport const b = () => b2();\n', "utf8");
+  writeFileSync(join(root, "src", "b2.js"), "export const b2 = () => 1;\n", "utf8");
+  execFileSync("git", ["init", "-b", "main"], { cwd: root, stdio: "pipe" });
+  execFileSync("git", ["-c", "user.email=t@t", "-c", "user.name=t", "add", "-A"], { cwd: root, stdio: "pipe" });
+  execFileSync("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-m", "init", "--no-gpg-sign"], { cwd: root, stdio: "pipe" });
+  return root;
+}
+
+function rmTempBestEffort(dir) {
+  for (let i = 0; i < 5; i++) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+      return;
+    } catch {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+    }
+  }
+  console.warn(`[wiki-queries.test] 临时目录清理未完成：${dir}`);
+}
+
+function setup() {
+  const root = makeFixture();
+  const store = createStore(":memory:");
+  runChoroT0({ repoRoot: root, store, apply: true, now: FIXED_NOW });
+  return { root, store, q: createChoroQueries({ store }) };
+}
+
+// stub embedder：文本含 "src" → [1,0]，否则 [0,1]（固定二维，可断言方向与失配）
+function stubEmbedder(model = "stub-1") {
+  return {
+    model,
+    embedSingle: async (text) => (/src/.test(text) ? [1, 0] : [0, 1]),
+    embed: async (text) => (/src/.test(text) ? [1, 0] : [0, 1]),
+  };
+}
+
+// --- 收尾档 P37–P39：向量惰性物化与检索 -------------------------------------
+
+test("embedPageVectors：首次全嵌，generated_at 没变就跳过，变了重嵌（staleness 两维之一）", async () => {
+  const { root, store, q } = setup();
+  try {
+    const repo = q.resolveRepo(undefined);
+    const emb = stubEmbedder();
+    const r1 = await q.embedPageVectors(repo.id, emb);
+    assert.equal(r1.embedded, 2, "两页全嵌");
+    const r2 = await q.embedPageVectors(repo.id, emb);
+    assert.equal(r2.embedded, 0);
+    assert.equal(r2.skipped, 2, "generated_at 没变 → 全跳过");
+    // 页面内容变了（generated_at 推进）→ 只重嵌变的那页
+    const pagePath = join(root, ".chorography", "modules", "src.md");
+    const before = readFileSync(pagePath, "utf8");
+    writeFileSync(pagePath, `${before}<!-- CHORO:HUMAN:START -->\n人工补充\n<!-- CHORO:HUMAN:END -->\n`, "utf8");
+    store.db.prepare(
+      "UPDATE choro_pages SET generated_at = ? WHERE generated_at IS NOT NULL AND id IN (SELECT p.id FROM choro_pages p JOIN choro_modules m ON p.module_id = m.id WHERE m.slug = 'src')"
+    ).run("2026-11-06T00:00:00.000Z");
+    const r3 = await q.embedPageVectors(repo.id, emb);
+    assert.equal(r3.embedded, 1, "只有 src 页重嵌");
+    assert.equal(r3.stale, 1, "旧向量按 stale 记账");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("dim 失配（换 embedder 模型）→ 惰性全量重嵌（P38：不锁死，代价只是几十页）", async () => {
+  const { root, store, q } = setup();
+  try {
+    const repo = q.resolveRepo(undefined);
+    await q.embedPageVectors(repo.id, stubEmbedder("stub-1"));
+    // 换模型：维度从 2 → 3。expectDim 来自查询向量（路由先嵌查询再物化）
+    const emb3 = {
+      model: "stub-2",
+      embedSingle: async () => [1, 0, 0],
+      embed: async () => [1, 0, 0],
+    };
+    const r = await q.embedPageVectors(repo.id, emb3, { expectDim: 3 });
+    assert.equal(r.embedded, 2, "维度变了 → 全部重嵌（fresh 检查被 dimDrift 压过）");
+    assert.equal(r.dimMismatch, true, "失配被记账");
+    const rows = store.getChoroPageVectors(repo.id);
+    assert.ok(rows.every((row) => row.dim === 3 && row.model === "stub-2"), "旧维度行不复存");
+    // 不给 expectDim（无查询场景）→ fresh 行照旧跳过
+    const r2 = await q.embedPageVectors(repo.id, emb3);
+    assert.equal(r2.embedded, 0);
+    assert.equal(r2.skipped, 2);
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("searchSemantic：cosine 排序 + dim 失配行被过滤 + embedder 缺席返回 null", async () => {
+  const { root, store, q } = setup();
+  try {
+    const repo = q.resolveRepo(undefined);
+    await q.embedPageVectors(repo.id, stubEmbedder("stub-1"));
+    const hits = await q.searchSemantic(repo.id, stubEmbedder("stub-1"), "src 相关的页");
+    assert.ok(Array.isArray(hits) && hits.length >= 1);
+    assert.equal(hits[0].slug, "src", "查询向量 [1,0] 与 src 页同向 → 排前");
+    // 查询向量三维：与所有行 dim 失配 → 无可比行，返回空数组而不是抛
+    const dim3 = { embedSingle: async () => [1, 0, 0], embed: async () => [1, 0, 0] };
+    const empty = await q.searchSemantic(repo.id, dim3, "x");
+    assert.deepEqual(empty, []);
+    assert.equal(await q.searchSemantic(repo.id, null, "x"), null);
+    assert.deepEqual(await q.searchSemantic(repo.id, stubEmbedder(), "  "), [], "空查询不嵌入、返回空数组");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("listRepos / resolveRepo：单仓自动收敛，多仓歧义要显式给键", () => {
+  const { root, store, q } = setup();
+  try {
+    const repos = q.listRepos();
+    assert.equal(repos.length, 1);
+    assert.equal(repos[0].module_count, 2, "src 与 root 两个模块（1 条跨模块边不触发合并）");
+    assert.equal(repos[0].page_count, 2);
+    const auto = q.resolveRepo(undefined);
+    assert.equal(auto.id, repos[0].id, "只有一个仓库时不带键也能解析");
+    assert.ok(q.resolveRepo("qfix").id, "按显示名解析");
+    assert.equal(q.resolveRepo("no-such-repo"), null);
+    // 造第二个仓库让解析变歧义
+    const root2 = makeFixture();
+    try {
+      runChoroT0({ repoRoot: root2, store, apply: true, now: FIXED_NOW });
+      const amb = q.resolveRepo(undefined);
+      assert.ok(amb.ambiguous, "多仓无键 → 歧义清单而不是猜一个");
+      assert.equal(amb.ambiguous.length, 2);
+    } finally {
+      rmTempBestEffort(root2);
+    }
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("moduleMap：模块、页面状态与跨模块边同源返回", () => {
+  const { root, store, q } = setup();
+  try {
+    const repo = q.resolveRepo(undefined);
+    const { modules, edges } = q.moduleMap(repo.id);
+    const slugs = modules.map((m) => m.slug).sort();
+    assert.deepEqual(slugs, ["root", "src"]);
+    const src = modules.find((m) => m.slug === "src");
+    assert.equal(src.page_status, "skeleton");
+    // fixture 的引用全在 src 模块内部（a→b→b2），left-pad 是外部依赖，root 只有
+    // package.json 没有代码——跨模块边应为空集。跨模块聚erge本身由 wiki-store 的
+    // 整仓替换用例与 t0 的 moduleEdges 排序覆盖。
+    assert.deepEqual(edges, []);
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("readPage：正文来自磁盘真源；盘上缺页如实报 page-missing；未知 slug 返回 null", () => {
+  const { root, store, q } = setup();
+  try {
+    const repo = q.resolveRepo(undefined);
+    const page = q.readPage(repo.id, "src");
+    assert.equal(page.slug, "src");
+    assert.ok(page.content.includes("## 文件清单"), "正文是骨架页");
+    assert.equal(page.content.split("\n").length > 10, true);
+    assert.equal(q.readPage(repo.id, "../../etc/passwd"), null, "未知 slug 一律 null（路径零用户输入）");
+    // 盘上删页：索引还在、读侧如实报缺
+    unlinkSync(join(root, ".chorography", "modules", "src.md"));
+    const missing = q.readPage(repo.id, "src");
+    assert.equal(missing.error, "page-missing");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("search：按节返回命中与行号，空 q 返回空数组，module 过滤生效", () => {
+  const { root, store, q } = setup();
+  try {
+    const repo = q.resolveRepo(undefined);
+    // 骨架页里必有「文件清单」节标题与 b2.js 文件名
+    const hits = q.search(repo.id, "文件清单");
+    assert.ok(hits.length >= 2, "两页都有文件清单节");
+    assert.ok(hits.every((h) => h.line >= 1 && typeof h.section === "string"));
+    const byFile = q.search(repo.id, "b2.js");
+    // 命中两处是契约而非巧合：frontmatter 的 sourceFiles（节=页首）+ 正文「文件
+    // 清单」表。分节让调用方能区分这两层。
+    assert.equal(byFile.length, 2);
+    assert.ok(byFile.every((h) => h.slug === "src"), "b2.js 只属于 src 页");
+    assert.equal(byFile.filter((h) => h.section.startsWith("文件清单")).length, 1, "节名带数量后缀（文件清单（N 个）），按前缀匹配");
+    assert.deepEqual(q.search(repo.id, "  "), [], "空 q 不报错返回空");
+    const inRoot = q.search(repo.id, "package.json", { moduleSlug: "root" });
+    assert.equal(inRoot.length, 2, "与 b2.js 同款两层命中：frontmatter（页首）+ 文件清单表");
+    assert.equal(inRoot[0].slug, "root");
+    assert.deepEqual(q.search(repo.id, "package.json", { moduleSlug: "src" }), [], "模块过滤真生效");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+test("repoByCwd：祖先前缀命中、最长 root 胜出、cwd 不存在返回 null", () => {
+  const { root, store, q } = setup();
+  let nested = null;
+  try {
+    // 精确根目录
+    const exact = q.repoByCwd(root);
+    assert.ok(exact, "仓库根命中");
+    // 子目录也要命中——真实会话的 cwd 常常是 D:/repo/src 这种
+    const sub = q.repoByCwd(join(root, "src"));
+    assert.equal(sub.id, exact.id, "子目录按祖先前缀命中同一个仓库");
+    assert.equal(q.repoByCwd(join(root, "no-such-dir")), null, "cwd 不存在 → null（不是抛错，注入在热路径上）");
+    assert.equal(q.repoByCwd(""), null);
+    assert.equal(q.repoByCwd(null), null);
+    // 嵌套仓库：外层先登记，内层后登记 → 内层会话必须被内层抢走（最长前缀）
+    nested = makeFixture();
+    runChoroT0({ repoRoot: nested, store, apply: true, now: FIXED_NOW });
+    const inner = q.repoByCwd(join(nested, "src"));
+    assert.equal(inner.root_path, nested, "嵌套时取最深那层，否则内层会话被外层仓库抢走");
+    assert.equal(q.repoByCwd(root).root_path, root, "外层 cwd 仍落外层");
+  } finally {
+    store.close();
+    if (nested) rmTempBestEffort(nested);
+    rmTempBestEffort(root);
+  }
+});
+
+test("outline：模块名 + 文件数 + 页状态 + 页相对路径，不读正文", () => {
+  const { root, store, q } = setup();
+  try {
+    const repo = q.resolveRepo(undefined);
+    const out = q.outline(repo.id);
+    assert.equal(out.repo.id, repo.id);
+    assert.equal(out.repo.name, "qfix");
+    assert.equal(out.modules.length, 2);
+    const srcMod = out.modules.find((m) => m.slug === "src");
+    assert.equal(srcMod.status, "skeleton");
+    assert.equal(srcMod.relPath, ".chorography/modules/src.md");
+    assert.ok(srcMod.fileCount >= 3);
+    assert.equal(srcMod.parentSlug, null);
+    assert.ok(out.generatedAt, "生成时间由页行的 generated_at 汇总");
+    // 「只注标题级」的机制锁：提纲里不许出现页正文片段（骨架页的节标题/说明行）
+    const serialized = JSON.stringify(out);
+    assert.equal(serialized.includes("## 文件清单"), false, "提纲不含正文节标题");
+    assert.equal(serialized.includes("确定性骨架"), false, "提纲不含页内说明行");
+    assert.equal(q.outline(9999), null, "未知 repo → null");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});

package/test/wiki-scan.test.js

@@ -0,0 +1,208 @@
+// scan.js 的回归锁：文件清单（默认排除 / gitignore 子集 / include 白名单）与
+// import 图（ESM 静态/动态、CJS、Vue SFC、外部包聚合、builtin 过滤、unresolved 记账）。
+// 锁的回归类型：正则提取器在「副作用 import / 再导出 / 多行 import」上漏边；
+// glob 在无斜杠模式上漏掉任意层级语义；解析失败必须记 skipped 而不是中断（spec 降级表）。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { listFiles, parseImportGraph, compileExclude, compileInclude, readRootPackage, workspacePrefixes } from "../src/wiki/scan.js";
+
+function makeRepo(files) {
+  const root = mkdtempSync(join(tmpdir(), "choro-scan-"));
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = join(root, rel);
+    mkdirSync(join(abs, ".."), { recursive: true });
+    writeFileSync(abs, content, "utf8");
+  }
+  return root;
+}
+
+test("文件清单：默认排除 node_modules/dist 与二进制/锁文件", () => {
+  const root = makeRepo({
+    "src/a.js": "export const a = 1;\n",
+    "node_modules/pkg/index.js": "module.exports = 1;\n",
+    "dist/bundle.js": "var a=1;\n",
+    "logo.png": "binary-ish",
+    "package-lock.json": "{}",
+    "README.md": "# x\n",
+  });
+  try {
+    assert.deepEqual(listFiles(root), ["README.md", "src/a.js"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// 锁的回归类型：默认排除表退化成「逐个点名已知的点目录」。V2 在三仓实测到的会话产物
+// 目录是 .qoder-credits / .superpowers / .shots / .zcode / .dsh-ops / .v2c——点名法每换一个
+// 工具就漏一批（baleen 15 模块里 6 个、study-desk 5 个里 3 个都曾是这样混进来的），
+// 所以规则改成「点开头目录整类」，本用例用一份从未在任何名单里出现过的 .whatever 来锁这条。
+// 反向断言同样重要：点开头的**文件**是仓库配置（.eslintrc.json），必须照旧进清单。
+test("文件清单：点开头目录整类排除（任意深度），点开头文件照旧扫描", () => {
+  const root = makeRepo({
+    "README.md": "# x\n",
+    "src/a.js": "export const a = 1;\n",
+    ".git/config": "",
+    ".whatever/session.md": "# 会话产物\n",
+    "nested/.qoder-credits/report.json": "{}",
+    "src/.shots/notes.md": "# 调试快照\n",
+    ".eslintrc.json": "{}",
+    "src/.prettierrc.json": "{}",
+  });
+  try {
+    assert.deepEqual(listFiles(root), [
+      ".eslintrc.json",
+      "README.md",
+      "src/.prettierrc.json",
+      "src/a.js",
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("文件清单：.gitignore 子集——无斜杠模式命中任意层级，锚定模式只命中根部", () => {
+  const root = makeRepo({
+    "keep.js": "",
+    "docs/readme.md": "",
+    "docs/inner/notes.md": "",
+    "build/out.js": "",
+    "sub/build/out.js": "",
+    "vendor/v.js": "",
+  });
+  try {
+    const m = compileExclude(["*.md", "build", "/vendor"]);
+    assert.equal(m.excludedFile("docs/readme.md"), true, "*.md 命中任意层级");
+    assert.equal(m.excludedFile("docs/inner/notes.md"), true);
+    assert.equal(m.excludedFile("keep.js"), false);
+    assert.equal(m.excludedFile("build/out.js"), true, "目录级排除连带文件");
+    assert.equal(m.excludedFile("sub/build/out.js"), true, "无斜杠目录名也是任意层级");
+    assert.equal(m.excludedFile("vendor/v.js"), true, "前导 / 锚定到根");
+    const inc = compileInclude(["docs"]);
+    assert.equal(inc.matchesFile("docs/readme.md"), true);
+    assert.equal(inc.matchesFile("src/a.js"), false);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("文件清单：include 白名单非空时只留命中的文件", () => {
+  const root = makeRepo({ "src/a.js": "", "docs/b.md": "", "c.js": "" });
+  try {
+    const files = listFiles(root, { exclude: [] });
+    const inc = compileInclude(["src/**"]);
+    const kept = files.filter((f) => inc.matchesFile(f));
+    assert.deepEqual(kept, ["src/a.js"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("import 图：ESM 静态/副作用/动态/再导出、CJS、多行 import 全部成边", () => {
+  const root = makeRepo({
+    "src/a.js": [
+      "import b, { c } from \"./b.js\";",
+      "import {",
+      "  long,",
+      "  multi,",
+      "} from \"./multi.js\";",
+      "import \"./side-effect.js\";",
+      "const lazy = () => import(\"./lazy.js\");",
+      "export * from \"./reexport.js\";",
+      "const legacy = require(\"./legacy.js\");",
+      "import path from \"node:path\";",
+      "import fp from \"lodash/fp\";",
+      "import { deep } from \"@scope/pkg/sub\";",
+      "import { gone } from \"./no-such-file.js\";",
+    ].join("\n"),
+    "src/b.js": "export default 1;\n",
+    "src/multi.js": "export const long = 1;\nexport const multi = 2;\n",
+    "src/side-effect.js": "",
+    "src/lazy.js": "",
+    "src/reexport.js": "",
+    "src/legacy.js": "",
+  });
+  try {
+    const files = listFiles(root);
+    const graph = parseImportGraph(root, files);
+    const from = (to) => graph.edges.filter((e) => e.from === "src/a.js" && e.to === to).length;
+    assert.equal(from("src/b.js"), 1);
+    assert.equal(from("src/multi.js"), 1, "多行 import 也要成边");
+    assert.equal(from("src/side-effect.js"), 1, "副作用 import 成边");
+    assert.equal(from("src/lazy.js"), 1, "动态 import 成边");
+    assert.equal(from("src/reexport.js"), 1, "再导出成边");
+    assert.equal(from("src/legacy.js"), 1, "CJS require 成边");
+    assert.ok(!graph.edges.some((e) => e.from === "src/a.js" && e.to.includes("node:path")), "node builtin 不成边");
+    assert.ok(graph.external.has("lodash"), "裸说明符按包名聚合");
+    assert.ok(graph.external.has("@scope/pkg"), "scoped 包取两段");
+    assert.ok(graph.external.has("path") === false, "builtin 不进外部依赖");
+    assert.deepEqual(graph.unresolved, [{ from: "src/a.js", spec: "./no-such-file.js" }], "解析失败记账不中断");
+    assert.equal(graph.skipped.length, 0);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("import 图：Vue SFC 的 <script> 块参与成边，模板部分不参与", () => {
+  const root = makeRepo({
+    "comp/App.vue": [
+      "<template>",
+      "  <div :src=\"'./not-a-module.js'\"></div>",
+      "</template>",
+      "<script>",
+      "import helper from \"../src/helper.js\";",
+      "export default { components: {} };",
+      "</script>",
+    ].join("\n"),
+    "src/helper.js": "export default 1;\n",
+  });
+  try {
+    const graph = parseImportGraph(root, listFiles(root));
+    assert.ok(graph.edges.some((e) => e.from === "comp/App.vue" && e.to === "src/helper.js"));
+    assert.ok(!graph.edges.some((e) => e.from === "comp/App.vue" && e.to.includes("not-a-module")));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("import 图：读不了/解析不了的文件记 skipped，不中断整轮", () => {
+  const root = makeRepo({ "ok.js": "import \"./x.js\";", "x.js": "" });
+  try {
+    // 制造一个清单里存在、磁盘上读不到的文件路径（直接喂给解析器，绕过 listFiles）
+    const graph = parseImportGraph(root, ["ok.js", "x.js", "gone/broken.js"]);
+    assert.equal(graph.skipped.some((s) => s.file === "gone/broken.js"), true);
+    assert.ok(graph.edges.length >= 1, "其他文件不受影响");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("package.json：scripts/entries/workspaces 收口，坏 JSON 返回 null 不抛", () => {
+  const root = makeRepo({
+    "package.json": JSON.stringify({
+      name: "demo",
+      main: "./lib/index.js",
+      bin: { demo: "./bin/demo.mjs" },
+      exports: { ".": "./lib/main.js" },
+      scripts: { test: "node --test" },
+      workspaces: ["packages/*", "apps/web"],
+    }),
+    "broken.js": "",
+  });
+  try {
+    const pkg = readRootPackage(root);
+    assert.equal(pkg.name, "demo");
+    assert.deepEqual(pkg.scripts, { test: "node --test" });
+    assert.ok(pkg.entries.includes("lib/index.js"));
+    assert.ok(pkg.entries.includes("bin/demo.mjs"));
+    assert.ok(pkg.entries.includes("lib/main.js"));
+    // workspacePrefixes 返回排序数组（确定性口径，与文件清单同规矩）
+    assert.deepEqual(workspacePrefixes(pkg.workspaces), ["apps/web", "packages"]);
+    writeFileSync(join(root, "package.json"), "{oops", "utf8");
+    assert.equal(readRootPackage(root), null);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/test/wiki-store.test.js

@@ -0,0 +1,190 @@
+// choro_* 五表的存储层回归锁（实现计划 P2/P7；spec §5）。
+// 锁三件事：新库/空库文件打开即建表（幂等迁移面）、整仓替换跑两遍行数不翻倍
+// （「重跑必须幂等」红线 5 的库侧语义）、唯一索引真实生效（登记表按 realpath 收敛）。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { DatabaseSync } from "node:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import { createStore } from "../src/store.js";
+
+const CHORO_TABLES = ["choro_repos", "choro_modules", "choro_pages", "choro_claims", "choro_vectors"];
+
+// Windows 上 %TEMP% 里刚写完的文件会被 Defender 短暂持锁，rmSync 撞 EPERM 是
+// 瞬时抖动不是用例失败（最小复现：同场景单独跑必过）。清理重试 2s，还不行就
+// 记警告交给系统临时目录清理——清理不在被测范围里，别让它把绿用例标红。
+async function rmTempEventually(dir) {
+  for (let i = 0; i < 10; i++) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+      return;
+    } catch (err) {
+      if (i === 9) console.warn(`[wiki-store.test] 临时目录清理未完成（${err.code}），留给系统清理：${dir}`);
+      await sleep(200);
+    }
+  }
+}
+
+function openMemory() {
+  return createStore(":memory:");
+}
+
+test("新库打开即建五张 choro 表", () => {
+  const store = openMemory();
+  for (const table of CHORO_TABLES) {
+    const row = store.db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+    ).get(table);
+    assert.ok(row, `${table} 存在`);
+  }
+  store.close();
+});
+
+test("已存在的空 db 文件（旧库形态）打开后同样补齐表（CREATE IF NOT EXISTS 幂等）", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "choro-store-"));
+  try {
+    const dbPath = join(dir, "memory.db");
+    // 空库文件（零表）：存量库升级的最简形态。刻意不造「只有 memories 一张裸表」
+    // 的夹具——那不是任何发布版本的真实旧库，且 SCHEMA 的 memories 索引会因缺列
+    // 拒绝打开（真实旧库带全列，不存在这条路）。
+    const legacy = new DatabaseSync(dbPath);
+    legacy.close();
+    const store = createStore(dbPath);
+    for (const table of CHORO_TABLES) {
+      const row = store.db.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+      ).get(table);
+      assert.ok(row, `存量库升级后 ${table} 存在`);
+    }
+    store.close();
+  } finally {
+    // 清理放在 finally 但不允许它遮蔽 try 里的真错（EPERM 时真错优先）。
+    await rmTempEventually(dir);
+  }
+});
+
+test("登记表 upsert：同名 realpath 只一行，plan/baseline 随最后一次成功 run 走", () => {
+  const store = openMemory();
+  const t1 = "2026-11-05T10:00:00.000Z";
+  const t2 = "2026-11-05T11:00:00.000Z";
+  const first = store.upsertChoroRepo("/r/mneme", "mneme", "fp1", "aaa", t1);
+  assert.ok(first.created_at === t1);
+  const second = store.upsertChoroRepo("/r/mneme", "mneme", "fp2", "bbb", t2);
+  assert.equal(second.id, first.id, "同一 root_path 是同一行");
+  assert.equal(second.created_at, t1, "created_at 只在首次插入时落");
+  assert.equal(second.plan_fingerprint, "fp2");
+  assert.equal(second.git_baseline, "bbb");
+  const rows = store.db.prepare("SELECT COUNT(*) AS c FROM choro_repos").get();
+  assert.equal(rows.c, 1);
+  store.close();
+});
+
+test("整仓替换跑两遍行数不翻倍（重跑幂等，红线 5 的库侧）", () => {
+  const store = openMemory();
+  const repo = store.upsertChoroRepo("/r/x", "x", "fp", "base", "2026-11-05T10:00:00.000Z");
+  const snapshot = {
+    updatedAt: "2026-11-05T10:00:00.000Z",
+    modules: [
+      { slug: "src", title: "src", parentSlug: null, fileCount: 2, fingerprint: "f1" },
+      { slug: "lib", title: "lib", parentSlug: null, fileCount: 1, fingerprint: "f2" },
+    ],
+    pages: [
+      { moduleSlug: "src", relPath: ".chorography/modules/src.md", status: "skeleton", gitBaseline: "base", templateVersion: "1", generatedAt: "t", humanBlockCount: 1, claims: [] },
+      { moduleSlug: "lib", relPath: ".chorography/modules/lib.md", status: "skeleton", gitBaseline: "base", templateVersion: "1", generatedAt: "t", humanBlockCount: 0, claims: [] },
+    ],
+  };
+  store.replaceChoroGraph(repo.id, snapshot);
+  store.replaceChoroGraph(repo.id, snapshot); // 重跑同一划分
+  assert.equal(store.db.prepare("SELECT COUNT(*) AS c FROM choro_modules").get().c, 2);
+  assert.equal(store.db.prepare("SELECT COUNT(*) AS c FROM choro_pages").get().c, 2);
+  assert.equal(store.db.prepare("SELECT COUNT(*) AS c FROM choro_claims").get().c, 0);
+  store.close();
+});
+
+test("划分变化不留孤儿行：旧模块的页面随模块一起被替换掉", () => {
+  const store = openMemory();
+  const repo = store.upsertChoroRepo("/r/y", "y", "fp", "base", "2026-11-05T10:00:00.000Z");
+  const t = "2026-11-05T10:00:00.000Z";
+  store.replaceChoroGraph(repo.id, {
+    updatedAt: t,
+    modules: [{ slug: "old-mod", title: "旧", parentSlug: null, fileCount: 1, fingerprint: "a" }],
+    pages: [{ moduleSlug: "old-mod", relPath: ".chorography/modules/old-mod.md", status: "skeleton", gitBaseline: "base", templateVersion: "1", generatedAt: t, humanBlockCount: 0, claims: [] }],
+  });
+  store.replaceChoroGraph(repo.id, {
+    updatedAt: t,
+    modules: [{ slug: "new-mod", title: "新", parentSlug: null, fileCount: 1, fingerprint: "b" }],
+    pages: [{ moduleSlug: "new-mod", relPath: ".chorography/modules/new-mod.md", status: "skeleton", gitBaseline: "base", templateVersion: "1", generatedAt: t, humanBlockCount: 0, claims: [] }],
+  });
+  assert.equal(store.db.prepare("SELECT COUNT(*) AS c FROM choro_modules").get().c, 1);
+  const slug = store.db.prepare("SELECT slug FROM choro_modules").get().slug;
+  assert.equal(slug, "new-mod");
+  const orphanPages = store.db.prepare(
+    "SELECT COUNT(*) AS c FROM choro_pages WHERE module_id NOT IN (SELECT id FROM choro_modules)"
+  ).get().c;
+  assert.equal(orphanPages, 0, "没有指向已删模块的孤儿页");
+  store.close();
+});
+
+test("父子链两段式落库：父在后也接得上（顺序无关）", () => {
+  const store = openMemory();
+  const repo = store.upsertChoroRepo("/r/z", "z", "fp", "base", "2026-11-05T10:00:00.000Z");
+  store.replaceChoroGraph(repo.id, {
+    updatedAt: "2026-11-05T10:00:00.000Z",
+    modules: [
+      { slug: "src-store", title: "store", parentSlug: "src", fileCount: 1, fingerprint: "a" },
+      { slug: "src", title: "src", parentSlug: null, fileCount: 1, fingerprint: "b" },
+    ],
+    pages: [],
+  });
+  const rows = store.db.prepare("SELECT slug, parent_id FROM choro_modules ORDER BY slug").all();
+  const bySlug = new Map(rows.map((r) => [r.slug, r.parent_id]));
+  const idOf = (slug) => store.db.prepare("SELECT id FROM choro_modules WHERE slug=?").get(slug).id;
+  assert.equal(bySlug.get("src-store"), idOf("src"), "子模块指向父模块行");
+  assert.equal(bySlug.get("src"), null);
+  store.close();
+});
+
+test("唯一索引真实生效：重复 (repo_id, slug) 撞库报 IntegrityError（本仓惯例：UNIQUE 走独立索引）", () => {
+  const store = openMemory();
+  const repo = store.upsertChoroRepo("/r/u", "u", "fp", "base", "2026-11-05T10:00:00.000Z");
+  const t = "2026-11-05T10:00:00.000Z";
+  store.replaceChoroGraph(repo.id, {
+    updatedAt: t,
+    modules: [{ slug: "a", title: "a", parentSlug: null, fileCount: 1, fingerprint: "a" }],
+    pages: [],
+  });
+  assert.throws(() => {
+    store.db.prepare(
+      "INSERT INTO choro_modules (repo_id, slug, title, file_count, updated_at) VALUES (?, 'a', 'dup', 1, ?)"
+    ).run(repo.id, t);
+  }, /UNIQUE/);
+  store.close();
+});
+
+test("claims 经 replaceChoroGraph 落库（M2 的路径，M0 只验形状）", () => {
+  const store = openMemory();
+  const repo = store.upsertChoroRepo("/r/c", "c", "fp", "base", "2026-11-05T10:00:00.000Z");
+  store.replaceChoroGraph(repo.id, {
+    updatedAt: "2026-11-05T10:00:00.000Z",
+    modules: [{ slug: "m", title: "m", parentSlug: null, fileCount: 1, fingerprint: "a" }],
+    pages: [{
+      moduleSlug: "m", relPath: ".chorography/modules/m.md", status: "enriched",
+      gitBaseline: "base", templateVersion: "1", generatedAt: "t", humanBlockCount: 0,
+      claims: [{
+        statement: "store.js 是唯一的手写 schema 位置",
+        kind: "architecture",
+        sourcePath: "src/store.js",
+        startLine: 25,
+        endLine: 30,
+        confidence: "high",
+      }],
+    }],
+  });
+  const claim = store.db.prepare("SELECT statement, kind, source_path, start_line FROM choro_claims").get();
+  assert.equal(claim.kind, "architecture");
+  assert.equal(claim.source_path, "src/store.js");
+  assert.equal(claim.start_line, 25);
+  store.close();
+});