@indigoai-us/hq-cli 5.77.13 → 5.78.0

package/src/commands/cloud.selectors.test.ts

@@ -1,208 +0,0 @@
-/**
- * Unit tests for the two small helpers that underpin the new `hq sync`
- * routing flags:
- *
- *   - `assertSingleSelector`: refuses ambiguous combinations of --all,
- *     --personal, and --company.
- *   - `resolveCanonicalPersonUid`: looks up the caller's canonical person
- *     entity and surfaces a clean error when none exists.
- */
-
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  assertNoPersonalPositionalPaths,
-  assertSingleSelector,
-  resolveCanonicalPersonUid,
-  type PullAllVaultClient,
-} from "./cloud.js";
-
-// ── assertSingleSelector ────────────────────────────────────────────────────
-
-describe("assertSingleSelector", () => {
-  it("accepts no selectors (= use active company)", () => {
-    expect(() => assertSingleSelector({}, "pull")).not.toThrow();
-  });
-
-  it.each([
-    ["all only", { all: true }],
-    ["personal only", { personal: true }],
-    ["company only", { company: "acme" }],
-  ])("accepts a single selector: %s", (_label, opts) => {
-    expect(() => assertSingleSelector(opts, "push")).not.toThrow();
-  });
-
-  it.each([
-    [
-      "all + personal",
-      { all: true, personal: true },
-      ["--all", "--personal"],
-    ],
-    [
-      "all + company",
-      { all: true, company: "acme" },
-      ["--all", "--company acme"],
-    ],
-    [
-      "personal + company",
-      { personal: true, company: "acme" },
-      ["--personal", "--company acme"],
-    ],
-    [
-      "all + personal + company",
-      { all: true, personal: true, company: "acme" },
-      ["--all", "--personal", "--company acme"],
-    ],
-  ])(
-    "throws on conflicting selectors: %s",
-    (_label, opts, mentioned: string[]) => {
-      let caught: Error | null = null;
-      try {
-        assertSingleSelector(opts, "now");
-      } catch (err) {
-        caught = err as Error;
-      }
-      expect(caught).not.toBeNull();
-      expect(caught?.message).toMatch(/at most one of --all, --personal, --company/);
-      for (const flag of mentioned) {
-        expect(caught?.message).toContain(flag);
-      }
-    },
-  );
-
-  it("interpolates the command name in the error message", () => {
-    expect(() =>
-      assertSingleSelector({ all: true, personal: true }, "push"),
-    ).toThrow(/`hq sync push`/);
-  });
-});
-
-// ── assertNoPersonalPositionalPaths (hq-cli#25) ─────────────────────────────
-//
-// The combination `--personal <path>` silently bypasses
-// PERSONAL_VAULT_EXCLUDED_TOP_LEVEL (which is only applied by
-// computePersonalVaultPaths). Real incident: 196 companies/{slug}/** objects
-// uploaded to a personal vault. Refusal forces the operator to drop one of
-// the two — either `--personal` (full vault scope) or the positional paths
-// (specific subset against the active company).
-
-describe("assertNoPersonalPositionalPaths", () => {
-  it("accepts --personal alone (no positional paths)", () => {
-    expect(() => assertNoPersonalPositionalPaths({ personal: true }, undefined)).not.toThrow();
-    expect(() => assertNoPersonalPositionalPaths({ personal: true }, [])).not.toThrow();
-  });
-
-  it("accepts positional paths without --personal", () => {
-    expect(() => assertNoPersonalPositionalPaths({ personal: false }, ["./scratch"])).not.toThrow();
-    expect(() => assertNoPersonalPositionalPaths({}, ["./scratch"])).not.toThrow();
-  });
-
-  it("accepts neither --personal nor positional paths", () => {
-    expect(() => assertNoPersonalPositionalPaths({}, undefined)).not.toThrow();
-    expect(() => assertNoPersonalPositionalPaths({}, [])).not.toThrow();
-  });
-
-  it("throws when --personal combines with one positional path", () => {
-    expect(() => assertNoPersonalPositionalPaths({ personal: true }, ["./scratch"])).toThrow(
-      /--personal.*cannot be combined with explicit \[paths\]/,
-    );
-  });
-
-  it("throws when --personal combines with multiple positional paths", () => {
-    expect(() =>
-      assertNoPersonalPositionalPaths({ personal: true }, ["./a", "./b", "./c"]),
-    ).toThrow(/PERSONAL_VAULT_EXCLUDED_TOP_LEVEL/);
-  });
-
-  it("error message names the dangerous prefixes so the operator understands the risk", () => {
-    let caught: Error | null = null;
-    try {
-      assertNoPersonalPositionalPaths({ personal: true }, ["/Users/corey/Documents/HQ"]);
-    } catch (e) {
-      caught = e as Error;
-    }
-    expect(caught).not.toBeNull();
-    expect(caught!.message).toContain(".git/");
-    expect(caught!.message).toContain("companies/");
-    expect(caught!.message).toContain("repos/");
-    expect(caught!.message).toContain("workspace/");
-  });
-});
-
-// ── resolveCanonicalPersonUid ──────────────────────────────────────────────
-
-function makeClient(persons: Array<{
-  uid: string;
-  type: "person" | "company";
-  slug: string;
-  createdAt: string;
-}>): PullAllVaultClient {
-  return {
-    listMyMemberships: vi.fn().mockResolvedValue([]),
-    listPersonEntities: vi.fn().mockResolvedValue(persons),
-    getEntity: vi.fn().mockResolvedValue(null),
-  };
-}
-
-describe("resolveCanonicalPersonUid", () => {
-  it("returns the UID of the canonical (oldest) person entity", async () => {
-    const client = makeClient([
-      {
-        uid: "psn_new",
-        type: "person",
-        slug: "alice",
-        createdAt: "2026-04-01T00:00:00Z",
-      },
-      {
-        uid: "psn_old",
-        type: "person",
-        slug: "alice-old",
-        createdAt: "2025-06-01T00:00:00Z",
-      },
-    ]);
-
-    await expect(resolveCanonicalPersonUid(client)).resolves.toBe("psn_old");
-  });
-
-  it("throws a clean error when no person entity is present", async () => {
-    const client = makeClient([]);
-    await expect(resolveCanonicalPersonUid(client)).rejects.toThrow(
-      /No personal vault found/,
-    );
-  });
-
-  it("breaks createdAt ties by uid lex order (deterministic)", async () => {
-    const client = makeClient([
-      {
-        uid: "psn_zzz",
-        type: "person",
-        slug: "alice-zzz",
-        createdAt: "2026-01-01T00:00:00Z",
-      },
-      {
-        uid: "psn_aaa",
-        type: "person",
-        slug: "alice-aaa",
-        createdAt: "2026-01-01T00:00:00Z",
-      },
-    ]);
-
-    await expect(resolveCanonicalPersonUid(client)).resolves.toBe("psn_aaa");
-  });
-
-  it("ignores non-person entities returned by the client", async () => {
-    const client: PullAllVaultClient = {
-      listMyMemberships: vi.fn().mockResolvedValue([]),
-      listPersonEntities: vi.fn().mockResolvedValue([
-        // Belt-and-braces: callers today pass entity.listByType("person"),
-        // but a future caller passing a mixed list shouldn't silently pick a
-        // company entity.
-        { uid: "cmp_acme", type: "company", slug: "acme", createdAt: "2024-01-01T00:00:00Z" },
-        { uid: "psn_alice", type: "person", slug: "alice", createdAt: "2026-01-01T00:00:00Z" },
-      ]),
-      getEntity: vi.fn().mockResolvedValue(null),
-    };
-
-    await expect(resolveCanonicalPersonUid(client)).resolves.toBe("psn_alice");
-  });
-});

package/src/commands/cloud.status.test.ts

@@ -1,160 +0,0 @@
-/**
- * Regression tests for `hq sync status`.
- *
- * Bug (feedback_9fbf1f82 / DEV-1725, feedback_46288b7b / DEV-1728): status
- * reported "No sync journal yet" immediately after a SUCCESSFUL sync. Root
- * cause — the action passed the HQ-root PATH where the engine expects a journal
- * SLUG, so it looked for `sync-journal._Users_<user>_hq.json`, a slug the
- * engine never writes, while the engine shards journals by slug
- * (`__hq_personal_vault__`, per-company). The fix enumerates EVERY shard via
- * the engine's `listJournals` and only reports "no journal" when none exist.
- *
- * These tests drive the real registered `status` command against real journal
- * shards under a temp `HQ_STATE_DIR`, capturing stdout.
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { Command } from "commander";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import {
-  writeJournal,
-  PERSONAL_VAULT_JOURNAL_SLUG,
-} from "@indigoai-us/hq-cloud";
-
-import { registerCloudCommands } from "./cloud.js";
-
-/** Build a fresh program with the cloud commands registered. */
-function makeProgram(): Command {
-  const program = new Command();
-  program.exitOverride(); // throw instead of process.exit on parse errors
-  registerCloudCommands(program);
-  return program;
-}
-
-/** Run `status` and return everything written to console.log. */
-async function runStatus(stateDir: string): Promise<string> {
-  const lines: string[] = [];
-  const spy = vi
-    .spyOn(console, "log")
-    .mockImplementation((...args: unknown[]) => {
-      lines.push(args.map(String).join(" "));
-    });
-  try {
-    await makeProgram().parseAsync(
-      ["status", "--hq-root", "/home/fake/hq"],
-      { from: "user" },
-    );
-  } finally {
-    spy.mockRestore();
-  }
-  return lines.join("\n");
-}
-
-describe("hq sync status", () => {
-  let stateDir: string;
-
-  beforeEach(() => {
-    stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-status-test-"));
-    process.env.HQ_STATE_DIR = stateDir;
-  });
-
-  afterEach(() => {
-    fs.rmSync(stateDir, { recursive: true, force: true });
-    delete process.env.HQ_STATE_DIR;
-  });
-
-  function seed(slug: string, files: Record<string, unknown>): void {
-    writeJournal(slug, {
-      version: "2",
-      lastSync: "",
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      files: files as any,
-      pulls: [],
-    });
-  }
-
-  it("reports 'No sync journal yet' only when no shard exists", async () => {
-    const out = await runStatus(stateDir);
-    expect(out).toContain("No sync journal yet");
-    expect(out).toContain("sync-journal.*.json");
-  });
-
-  it("REGRESSION: shows the personal-vault journal after a `--personal` sync", async () => {
-    // This is the exact scenario both reporters hit: a successful personal
-    // sync, then status. It must NOT say "No sync journal yet".
-    seed(PERSONAL_VAULT_JOURNAL_SLUG, {
-      ".claude/skills/x/SKILL.md": {
-        hash: "a",
-        size: 1234,
-        syncedAt: "2026-06-08T10:00:00.000Z",
-        direction: "up",
-      },
-    });
-
-    const out = await runStatus(stateDir);
-    expect(out).not.toContain("No sync journal yet");
-    expect(out).toContain("personal vault");
-    expect(out).toContain("Tracked files: 1");
-  });
-
-  it("enumerates every shard with a per-scope breakdown + rollup", async () => {
-    seed(PERSONAL_VAULT_JOURNAL_SLUG, {
-      ".claude/a": {
-        hash: "a",
-        size: 1000,
-        syncedAt: "2026-06-08T10:00:00.000Z",
-        direction: "up",
-      },
-    });
-    seed("marshalops", {
-      "k/a.md": {
-        hash: "b",
-        size: 5000,
-        syncedAt: "2026-06-08T11:00:00.000Z",
-        direction: "down",
-      },
-    });
-    seed("glazeymedia", {
-      "k/b.md": {
-        hash: "c",
-        size: 777,
-        syncedAt: "2026-06-09T09:30:00.000Z",
-        direction: "down",
-      },
-    });
-
-    const out = await runStatus(stateDir);
-    expect(out).toContain("Journals:       3");
-    expect(out).toContain("personal vault");
-    expect(out).toContain("marshalops");
-    expect(out).toContain("glazeymedia");
-    expect(out).toContain("All scopes");
-    // Rollup last-sync is the max across shards.
-    expect(out).toContain("2026-06-09T09:30:00.000Z");
-  });
-
-  it("excludes tombstoned entries from tracked counts", async () => {
-    seed("glazeymedia", {
-      "k/live.md": {
-        hash: "c",
-        size: 100,
-        syncedAt: "2026-06-09T09:30:00.000Z",
-        direction: "down",
-      },
-      "k/removed.md": {
-        hash: "old",
-        size: 999,
-        syncedAt: "2026-05-01T00:00:00.000Z",
-        direction: "down",
-        removedAt: "2026-05-02T00:00:00.000Z",
-        removedReason: "scope_shrink",
-      },
-    });
-
-    const out = await runStatus(stateDir);
-    // One live file, not two — the tombstone is not "tracked".
-    expect(out).toContain("Tracked files: 1");
-  });
-});

package/src/commands/cloud.test.ts

@@ -1,41 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-
-import { configureSyncLockTimeout } from "./cloud.js";
-
-const originalLockTimeout = process.env.HQ_OP_LOCK_TIMEOUT;
-
-afterEach(() => {
-  if (originalLockTimeout === undefined) {
-    delete process.env.HQ_OP_LOCK_TIMEOUT;
-  } else {
-    process.env.HQ_OP_LOCK_TIMEOUT = originalLockTimeout;
-  }
-});
-
-describe("configureSyncLockTimeout", () => {
-  it("supplies a finite foreground wait when the caller has not configured one", () => {
-    delete process.env.HQ_OP_LOCK_TIMEOUT;
-    configureSyncLockTimeout(undefined);
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBe("300");
-  });
-
-  it("honors an explicit zero-second refusal", () => {
-    configureSyncLockTimeout("0");
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBe("0");
-  });
-
-  it("honors a valid inherited lock timeout", () => {
-    process.env.HQ_OP_LOCK_TIMEOUT = "17";
-    configureSyncLockTimeout(undefined);
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBe("17");
-  });
-
-  it("rejects an invalid timeout instead of silently waiting forever", () => {
-    expect(() => configureSyncLockTimeout("forever")).toThrow("--lock-timeout");
-  });
-
-  it("rejects an invalid inherited timeout instead of restoring an infinite wait", () => {
-    process.env.HQ_OP_LOCK_TIMEOUT = "forever";
-    expect(() => configureSyncLockTimeout(undefined)).toThrow("--lock-timeout");
-  });
-});