@indigoai-us/hq-cloud 6.14.49 → 6.15.0

package/src/cli/reindex-knowledge.test.ts

@@ -0,0 +1,307 @@
+/**
+ * Tests for the legacy knowledge-repo materialization pass (`hq reindex`).
+ *
+ * Each test builds a temp HQ tree with the layout under test, runs
+ * materializeLegacyKnowledgeRepos() (or full reindex() for the integration
+ * case), and asserts observable filesystem outcomes: canonical knowledge
+ * paths become real directories with their content (and history) inline, and
+ * fully-migrated legacy repos under repos/ are removed — while supported
+ * layouts (pack mounts, embedded repos, in-tree aliases) are untouched.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { materializeLegacyKnowledgeRepos } from "./reindex-knowledge.js";
+import { reindex } from "./reindex.js";
+
+let root: string;
+
+function git(dir: string, ...args: string[]): string {
+  const res = spawnSync("git", ["-C", dir, ...args], { encoding: "utf8" });
+  expect(res.status, `git ${args.join(" ")} in ${dir}: ${res.stderr}`).toBe(0);
+  return res.stdout.trim();
+}
+
+/** Init a standalone git repo at `dir` with one committed file per `files`. */
+function makeRepo(dir: string, files: Record<string, string>): void {
+  fs.mkdirSync(dir, { recursive: true });
+  git(dir, "init", "-q");
+  git(dir, "config", "user.email", "test@example.com");
+  git(dir, "config", "user.name", "test");
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content);
+  }
+  git(dir, "add", "-A");
+  git(dir, "commit", "-qm", "init");
+}
+
+function isRealDir(p: string): boolean {
+  const st = fs.lstatSync(p);
+  return st.isDirectory() && !st.isSymbolicLink();
+}
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-reindex-knowledge-"));
+  fs.mkdirSync(path.join(root, "companies"), { recursive: true });
+});
+
+afterEach(() => {
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("materializeLegacyKnowledgeRepos", () => {
+  it("materializes a company knowledge symlink and removes the legacy repo", () => {
+    const legacy = path.join(root, "repos", "private", "knowledge-acme");
+    makeRepo(legacy, { "notes.md": "# Acme notes\n", "sub/deep.md": "deep\n" });
+    fs.mkdirSync(path.join(root, "companies", "acme"), { recursive: true });
+    const link = path.join(root, "companies", "acme", "knowledge");
+    fs.symlinkSync(path.join("..", "..", "repos", "private", "knowledge-acme"), link);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.readFileSync(path.join(link, "notes.md"), "utf8")).toBe("# Acme notes\n");
+    expect(fs.readFileSync(path.join(link, "sub", "deep.md"), "utf8")).toBe("deep\n");
+    // History preserved as a supported embedded repo at the canonical path.
+    expect(fs.existsSync(path.join(link, ".git"))).toBe(true);
+    expect(git(link, "log", "--oneline")).toContain("init");
+    // Legacy repo fully materialized → removed.
+    expect(fs.existsSync(legacy)).toBe(false);
+  });
+
+  it("pulls the legacy repo before copying so the inline content is current", () => {
+    const upstream = path.join(root, "upstream.git");
+    makeRepo(upstream, { "notes.md": "v1\n" });
+    const legacy = path.join(root, "repos", "public", "knowledge-team");
+    fs.mkdirSync(path.dirname(legacy), { recursive: true });
+    git(path.dirname(legacy), "clone", "-q", upstream, legacy);
+    // Upstream advances after the clone.
+    fs.writeFileSync(path.join(upstream, "notes.md"), "v2\n");
+    git(upstream, "commit", "-aqm", "v2");
+
+    fs.mkdirSync(path.join(root, "core", "knowledge", "public"), { recursive: true });
+    const link = path.join(root, "core", "knowledge", "public", "team");
+    fs.symlinkSync(legacy, link);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.readFileSync(path.join(link, "notes.md"), "utf8")).toBe("v2\n");
+    expect(fs.existsSync(legacy)).toBe(false);
+  });
+
+  it("keeps a legacy repo whose knowledge is only a subdirectory, and warns", () => {
+    const legacy = path.join(root, "repos", "public", "ralph-methodology");
+    makeRepo(legacy, { "docs/guide.md": "guide\n", "src/code.ts": "code\n" });
+    fs.mkdirSync(path.join(root, "core", "knowledge", "public"), { recursive: true });
+    const link = path.join(root, "core", "knowledge", "public", "Ralph");
+    fs.symlinkSync(path.join(legacy, "docs"), link);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.readFileSync(path.join(link, "guide.md"), "utf8")).toBe("guide\n");
+    // The repo also holds non-knowledge content → left in place.
+    expect(fs.existsSync(path.join(legacy, "src", "code.ts"))).toBe(true);
+  });
+
+  it("materializes every alias of one repo before removing it", () => {
+    const legacy = path.join(root, "repos", "public", "knowledge-hq-core");
+    makeRepo(legacy, { "README.md": "hq\n" });
+    fs.mkdirSync(path.join(root, "core", "knowledge", "public"), { recursive: true });
+    const canonical = path.join(root, "core", "knowledge", "public", "hq-core");
+    const alias = path.join(root, "core", "knowledge", "public", "hq");
+    fs.symlinkSync(legacy, canonical);
+    fs.symlinkSync(legacy, alias);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(canonical)).toBe(true);
+    expect(isRealDir(alias)).toBe(true);
+    expect(fs.readFileSync(path.join(canonical, "README.md"), "utf8")).toBe("hq\n");
+    expect(fs.readFileSync(path.join(alias, "README.md"), "utf8")).toBe("hq\n");
+    expect(fs.existsSync(legacy)).toBe(false);
+  });
+
+  it("migrates a personal knowledge entry symlinked outside repos/ but keeps the external repo", () => {
+    const external = path.join(root, "..", path.basename(root) + "-external-knowledge");
+    makeRepo(external, { "me.md": "personal\n" });
+    try {
+      fs.mkdirSync(path.join(root, "personal", "knowledge"), { recursive: true });
+      const link = path.join(root, "personal", "knowledge", "me");
+      fs.symlinkSync(external, link);
+
+      materializeLegacyKnowledgeRepos(root);
+
+      expect(isRealDir(link)).toBe(true);
+      expect(fs.readFileSync(path.join(link, "me.md"), "utf8")).toBe("personal\n");
+      // Outside this HQ's repos/ → never deleted automatically.
+      expect(fs.existsSync(path.join(external, "me.md"))).toBe(true);
+    } finally {
+      fs.rmSync(external, { recursive: true, force: true });
+    }
+  });
+
+  it("leaves pack mounts, embedded repos, in-tree aliases, and broken links alone", () => {
+    // Pack mount: core/knowledge/public/<x> → core/packages/<pack>/knowledge.
+    const packKnowledge = path.join(root, "core", "packages", "hq-pack-demo", "knowledge");
+    fs.mkdirSync(packKnowledge, { recursive: true });
+    fs.writeFileSync(path.join(packKnowledge, "pack.md"), "pack\n");
+    fs.mkdirSync(path.join(root, "core", "knowledge", "public"), { recursive: true });
+    const packLink = path.join(root, "core", "knowledge", "public", "demo-pack");
+    fs.symlinkSync(packKnowledge, packLink);
+
+    // Supported embedded repo at the canonical path.
+    const embedded = path.join(root, "companies", "beta", "knowledge");
+    makeRepo(embedded, { "beta.md": "beta\n" });
+
+    // In-tree alias: symlink to a plain directory inside this HQ tree.
+    const inTree = path.join(root, "core", "knowledge", "public", "shared-notes");
+    fs.mkdirSync(inTree, { recursive: true });
+    fs.writeFileSync(path.join(inTree, "a.md"), "a\n");
+    const aliasLink = path.join(root, "core", "knowledge", "public", "notes-alias");
+    fs.symlinkSync(inTree, aliasLink);
+
+    // Broken symlink.
+    const broken = path.join(root, "core", "knowledge", "public", "gone");
+    fs.symlinkSync(path.join(root, "does-not-exist"), broken);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(fs.lstatSync(packLink).isSymbolicLink()).toBe(true);
+    expect(isRealDir(embedded)).toBe(true);
+    expect(fs.existsSync(path.join(embedded, ".git"))).toBe(true);
+    expect(fs.lstatSync(aliasLink).isSymbolicLink()).toBe(true);
+    expect(fs.lstatSync(broken).isSymbolicLink()).toBe(true);
+  });
+
+  it("copies internal relative symlinks verbatim so they survive legacy-repo removal", () => {
+    const legacy = path.join(root, "repos", "private", "knowledge-linked");
+    makeRepo(legacy, { "b.md": "content\n" });
+    fs.symlinkSync("./b.md", path.join(legacy, "a.md"));
+    git(legacy, "add", "-A");
+    git(legacy, "commit", "-qm", "add link");
+    fs.mkdirSync(path.join(root, "companies", "linked"), { recursive: true });
+    const link = path.join(root, "companies", "linked", "knowledge");
+    fs.symlinkSync(legacy, link);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.existsSync(legacy)).toBe(false);
+    // The internal link must still be relative — an absolute rewrite would
+    // point into the (now removed) legacy repo.
+    expect(fs.readlinkSync(path.join(link, "a.md"))).toBe("./b.md");
+    expect(fs.readFileSync(path.join(link, "a.md"), "utf8")).toBe("content\n");
+  });
+
+  it("leaves an in-HQ mirror link to an embedded personal repo for the mirror cleanup", () => {
+    // Retired-release shape: core/knowledge/<x> → ../../personal/knowledge/<x>
+    // where the personal side is an embedded git repo. That link is the
+    // mirror-cleanup pass's to prune — materializing it would duplicate the
+    // knowledge as a real directory.
+    const personalRepo = path.join(root, "personal", "knowledge", "notes");
+    makeRepo(personalRepo, { "n.md": "notes\n" });
+    fs.mkdirSync(path.join(root, "core", "knowledge"), { recursive: true });
+    const mirror = path.join(root, "core", "knowledge", "notes");
+    fs.symlinkSync(path.join("..", "..", "personal", "knowledge", "notes"), mirror);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(fs.lstatSync(mirror).isSymbolicLink()).toBe(true);
+    expect(isRealDir(personalRepo)).toBe(true);
+  });
+
+  it("keeps git-ignored local files out of the copy and preserves the legacy repo", () => {
+    const legacy = path.join(root, "repos", "private", "knowledge-secrets");
+    makeRepo(legacy, { "notes.md": "notes\n", ".gitignore": "credentials.json\n" });
+    fs.writeFileSync(path.join(legacy, "credentials.json"), "{\"secret\":true}\n");
+    fs.mkdirSync(path.join(root, "companies", "sec"), { recursive: true });
+    const link = path.join(root, "companies", "sec", "knowledge");
+    fs.symlinkSync(legacy, link);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.readFileSync(path.join(link, "notes.md"), "utf8")).toBe("notes\n");
+    // The repo-ignored local file must not land under a cloud-synced path…
+    expect(fs.existsSync(path.join(link, "credentials.json"))).toBe(false);
+    // …and the legacy repo survives so that local-only file is never destroyed.
+    expect(fs.existsSync(path.join(legacy, "credentials.json"))).toBe(true);
+  });
+
+  it("migrates a linked git worktree without its .git pointer and keeps the worktree", () => {
+    const mainRepo = path.join(root, "repos", "private", "knowledge-main");
+    makeRepo(mainRepo, { "w.md": "worktree\n" });
+    const worktree = path.join(root, "repos", "private", "knowledge-wt");
+    git(mainRepo, "worktree", "add", "-q", worktree);
+    fs.mkdirSync(path.join(root, "companies", "wt"), { recursive: true });
+    const link = path.join(root, "companies", "wt", "knowledge");
+    fs.symlinkSync(worktree, link);
+
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.readFileSync(path.join(link, "w.md"), "utf8")).toBe("worktree\n");
+    // The gitdir pointer file must not be copied (it references metadata in
+    // the main repo), and the worktree stays for `git worktree remove`.
+    expect(fs.existsSync(path.join(link, ".git"))).toBe(false);
+    expect(fs.existsSync(worktree)).toBe(true);
+    expect(fs.existsSync(mainRepo)).toBe(true);
+  });
+
+  it("honors the HQ_REINDEX_SKIP_KNOWLEDGE_MIGRATION escape hatch", () => {
+    const legacy = path.join(root, "repos", "private", "knowledge-x");
+    makeRepo(legacy, { "x.md": "x\n" });
+    fs.mkdirSync(path.join(root, "companies", "x"), { recursive: true });
+    const link = path.join(root, "companies", "x", "knowledge");
+    fs.symlinkSync(legacy, link);
+
+    process.env.HQ_REINDEX_SKIP_KNOWLEDGE_MIGRATION = "1";
+    try {
+      materializeLegacyKnowledgeRepos(root);
+    } finally {
+      delete process.env.HQ_REINDEX_SKIP_KNOWLEDGE_MIGRATION;
+    }
+
+    expect(fs.lstatSync(link).isSymbolicLink()).toBe(true);
+    expect(fs.existsSync(legacy)).toBe(true);
+  });
+
+  it("is idempotent — a second run over a migrated tree changes nothing", () => {
+    const legacy = path.join(root, "repos", "private", "knowledge-acme");
+    makeRepo(legacy, { "notes.md": "notes\n" });
+    fs.mkdirSync(path.join(root, "companies", "acme"), { recursive: true });
+    const link = path.join(root, "companies", "acme", "knowledge");
+    fs.symlinkSync(legacy, link);
+
+    materializeLegacyKnowledgeRepos(root);
+    const before = fs.readdirSync(link).sort();
+    materializeLegacyKnowledgeRepos(root);
+
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.readdirSync(link).sort()).toEqual(before);
+  });
+
+  it("runs as part of reindex() against a legacy tree", () => {
+    // Minimal reindex-able HQ tree plus one legacy knowledge symlink.
+    fs.mkdirSync(path.join(root, ".claude", "skills"), { recursive: true });
+    const legacy = path.join(root, "repos", "private", "knowledge-gamma");
+    makeRepo(legacy, { "g.md": "gamma\n" });
+    fs.mkdirSync(path.join(root, "companies", "gamma"), { recursive: true });
+    const link = path.join(root, "companies", "gamma", "knowledge");
+    fs.symlinkSync(legacy, link);
+
+    const result = reindex({ repoRoot: root, skipLock: true });
+
+    expect(result.status).toBe(0);
+    expect(isRealDir(link)).toBe(true);
+    expect(fs.readFileSync(path.join(link, "g.md"), "utf8")).toBe("gamma\n");
+    expect(fs.existsSync(legacy)).toBe(false);
+  });
+});