@modusensus/dsh-mneme 0.10.0 → 0.11.0

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();
+});