@indigoai-us/hq-cloud 6.15.0 → 6.15.2

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

@@ -1,307 +0,0 @@
-/**
- * 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);
-  });
-});