@indigoai-us/hq-cli 5.57.0 → 5.58.1

package/src/commands/people.test.ts

@@ -20,10 +20,13 @@ import {
   type PersonRecord,
 } from "../utils/people.js";
 import {
+  activeMemberToPersonRecord,
+  mergePeople,
   registerPeopleCommand,
   resolveCompanySlug,
-  type RefreshPeopleRoster,
+  type FetchPeopleRoster,
 } from "./people.js";
+import type { ActiveMember } from "./members.js";
 
 // ---------------------------------------------------------------------------
 // Filesystem fixture helpers
@@ -335,11 +338,119 @@ describe("companyPeopleDir", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Membership roster fallback helpers
+// ---------------------------------------------------------------------------
+
+function rosterPerson(overrides: Partial<PersonRecord>): PersonRecord {
+  return {
+    slug: "ada-lovelace",
+    name: "Ada Lovelace",
+    email: "ada@acme.com",
+    type: "internal",
+    source: "test roster",
+    ...overrides,
+  };
+}
+
+describe("activeMemberToPersonRecord", () => {
+  const base: ActiveMember = {
+    membershipKey: "m_1",
+    personUid: "prs_123",
+    companyUid: "co_123",
+    role: "admin",
+    status: "active",
+  };
+
+  it("maps membership person fields into an internal person record", () => {
+    expect(
+      activeMemberToPersonRecord({
+        ...base,
+        personName: " Ada Lovelace ",
+        personEmail: " ada@acme.com ",
+        personSlug: " ada ",
+      }),
+    ).toEqual({
+      slug: "ada",
+      name: "Ada Lovelace",
+      email: "ada@acme.com",
+      role: "admin",
+      type: "internal",
+      source: "hq-pro membership: /membership/company/co_123",
+    });
+  });
+
+  it("falls back from name to email to slug, and slugifies names", () => {
+    expect(
+      activeMemberToPersonRecord({
+        ...base,
+        personName: "Grace Hopper",
+        personEmail: "grace@acme.com",
+      }),
+    ).toMatchObject({ name: "Grace Hopper", slug: "grace-hopper" });
+
+    expect(
+      activeMemberToPersonRecord({
+        ...base,
+        personEmail: "only-email@acme.com",
+      }),
+    ).toMatchObject({ name: "only-email@acme.com", slug: "only-email-acme-com" });
+
+    expect(
+      activeMemberToPersonRecord({
+        ...base,
+        personSlug: "only-slug",
+      }),
+    ).toMatchObject({ name: "only-slug", slug: "only-slug" });
+  });
+
+  it("returns null when all name-like fields are empty", () => {
+    expect(
+      activeMemberToPersonRecord({
+        ...base,
+        personName: " ",
+        personEmail: "",
+        personSlug: "   ",
+      }),
+    ).toBeNull();
+  });
+});
+
+describe("mergePeople", () => {
+  it("deduplicates by email, slug, then name with primary records winning", () => {
+    const primary = [
+      rosterPerson({
+        slug: "local-email",
+        name: "Local Email",
+        email: "same@acme.com",
+        role: "CEO",
+      }),
+      rosterPerson({ slug: "same-slug", name: "Local Slug", email: undefined }),
+      rosterPerson({ slug: "", name: "Same Name", email: undefined }),
+    ];
+    const extra = [
+      rosterPerson({
+        slug: "remote-email",
+        name: "Remote Email",
+        email: "SAME@acme.com",
+      }),
+      rosterPerson({ slug: "SAME-SLUG", name: "Remote Slug", email: undefined }),
+      rosterPerson({ slug: "", name: "same name", email: undefined }),
+      rosterPerson({ slug: "new-person", name: "New Person", email: undefined }),
+    ];
+
+    expect(mergePeople(primary, extra)).toEqual([
+      ...primary,
+      rosterPerson({ slug: "new-person", name: "New Person", email: undefined }),
+    ]);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Wired CLI surface (list / search / resolve)
 // ---------------------------------------------------------------------------
 
-function buildProgram(deps?: { refreshRoster?: RefreshPeopleRoster }): Command {
+function buildProgram(deps?: { fetchRoster?: FetchPeopleRoster }): Command {
   const program = new Command();
   program.exitOverride(); // throw instead of process.exit on commander errors
   registerPeopleCommand(program, deps);
@@ -348,8 +459,8 @@ function buildProgram(deps?: { refreshRoster?: RefreshPeopleRoster }): Command {
 
 async function run(
   args: string[],
-  deps: { refreshRoster?: RefreshPeopleRoster } = {
-    refreshRoster: async () => {},
+  deps: { fetchRoster?: FetchPeopleRoster } = {
+    fetchRoster: async () => [],
   },
 ): Promise<void> {
   await buildProgram(deps).parseAsync(["node", "hq", ...args]);
@@ -389,6 +500,68 @@ describe("hq people (wired)", () => {
     ]);
   });
 
+  it("list includes roster people, sorts them, and deduplicates with local winning", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
+      rosterPerson({
+        slug: "remote-jane",
+        name: "Remote Jane",
+        email: "JANE@acme.com",
+        role: "member",
+      }),
+      rosterPerson({
+        slug: "ada-lovelace",
+        name: "Ada Lovelace",
+        email: "ada@acme.com",
+        role: "admin",
+      }),
+    ]);
+
+    await run(
+      ["people", "list", "--company", "acme", "--hq-root", tmpRoot, "--json"],
+      { fetchRoster },
+    );
+
+    expect(fetchRoster).toHaveBeenCalledTimes(1);
+    expect(fetchRoster).toHaveBeenCalledWith(tmpRoot, "acme");
+    const out = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(out.map((p: PersonRecord) => p.name)).toEqual([
+      "Ada Lovelace",
+      "Jane Smith",
+      "John Doe",
+    ]);
+    expect(out.find((p: PersonRecord) => p.email === "jane@acme.com")).toMatchObject({
+      name: "Jane Smith",
+      role: "CEO",
+    });
+  });
+
+  it("list --local-only skips roster fetch", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
+      rosterPerson({ slug: "ada-lovelace", name: "Ada Lovelace" }),
+    ]);
+
+    await run(
+      [
+        "people",
+        "list",
+        "--company",
+        "acme",
+        "--hq-root",
+        tmpRoot,
+        "--json",
+        "--local-only",
+      ],
+      { fetchRoster },
+    );
+
+    expect(fetchRoster).not.toHaveBeenCalled();
+    const out = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(out.map((p: PersonRecord) => p.name).sort()).toEqual([
+      "Jane Smith",
+      "John Doe",
+    ]);
+  });
+
   it("search narrows to the matching person", async () => {
     await run([
       "people",
@@ -405,8 +578,8 @@ describe("hq people (wired)", () => {
     expect(out[0].email).toBe("jane@acme.com");
   });
 
-  it("search local hit does not refresh the roster", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>();
+  it("search local hit does not fetch the roster", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>();
     await run(
       [
         "people",
@@ -418,19 +591,15 @@ describe("hq people (wired)", () => {
         tmpRoot,
         "--json",
       ],
-      { refreshRoster },
+      { fetchRoster },
     );
-    expect(refreshRoster).not.toHaveBeenCalled();
+    expect(fetchRoster).not.toHaveBeenCalled();
   });
 
-  it("search local miss refreshes once and retries from the refreshed roster", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>(async () => {
-      makePerson("acme", "ada-lovelace", {
-        name: "Ada Lovelace",
-        email: "ada@acme.com",
-        type: "internal",
-      });
-    });
+  it("search finds a teammate from the roster on a local miss", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
+      rosterPerson({ slug: "ada-lovelace", name: "Ada Lovelace" }),
+    ]);
 
     await run(
       [
@@ -443,11 +612,11 @@ describe("hq people (wired)", () => {
         tmpRoot,
         "--json",
       ],
-      { refreshRoster },
+      { fetchRoster },
     );
 
-    expect(refreshRoster).toHaveBeenCalledTimes(1);
-    expect(refreshRoster).toHaveBeenCalledWith(tmpRoot, "acme");
+    expect(fetchRoster).toHaveBeenCalledTimes(1);
+    expect(fetchRoster).toHaveBeenCalledWith(tmpRoot, "acme");
     const out = JSON.parse(logSpy.mock.calls[0][0] as string);
     expect(out).toHaveLength(1);
     expect(out[0]).toMatchObject({
@@ -456,8 +625,8 @@ describe("hq people (wired)", () => {
     });
   });
 
-  it("search local miss with refresh failure reports the original empty JSON and logs a note", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>(async () => {
+  it("search local miss with fetch failure reports the original empty JSON and logs a note", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => {
       throw new Error("offline");
     });
 
@@ -472,18 +641,18 @@ describe("hq people (wired)", () => {
         tmpRoot,
         "--json",
       ],
-      { refreshRoster },
+      { fetchRoster },
     );
 
-    expect(refreshRoster).toHaveBeenCalledTimes(1);
+    expect(fetchRoster).toHaveBeenCalledTimes(1);
     expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual([]);
     expect(errSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Could not refresh people roster"),
+      expect.stringContaining("Could not fetch people roster"),
     );
   });
 
-  it("search --local-only skips refresh on a miss", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>();
+  it("search --local-only skips fetch on a miss", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>();
     await run(
       [
         "people",
@@ -496,10 +665,10 @@ describe("hq people (wired)", () => {
         "--json",
         "--local-only",
       ],
-      { refreshRoster },
+      { fetchRoster },
     );
 
-    expect(refreshRoster).not.toHaveBeenCalled();
+    expect(fetchRoster).not.toHaveBeenCalled();
     expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual([]);
   });
 
@@ -516,8 +685,8 @@ describe("hq people (wired)", () => {
     expect(logSpy).toHaveBeenCalledWith("jane@acme.com");
   });
 
-  it("resolve local hit does not refresh the roster", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>();
+  it("resolve local hit does not fetch the roster", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>();
     await run(
       [
         "people",
@@ -528,19 +697,15 @@ describe("hq people (wired)", () => {
         "--hq-root",
         tmpRoot,
       ],
-      { refreshRoster },
+      { fetchRoster },
     );
-    expect(refreshRoster).not.toHaveBeenCalled();
+    expect(fetchRoster).not.toHaveBeenCalled();
   });
 
-  it("resolve local miss refreshes once and retries from the refreshed roster", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>(async () => {
-      makePerson("acme", "ada-lovelace", {
-        name: "Ada Lovelace",
-        email: "ada@acme.com",
-        type: "internal",
-      });
-    });
+  it("resolve finds a teammate that exists only in the fetched roster", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => [
+      rosterPerson({ slug: "ada-lovelace", name: "Ada Lovelace" }),
+    ]);
 
     await run(
       [
@@ -552,16 +717,16 @@ describe("hq people (wired)", () => {
         "--hq-root",
         tmpRoot,
       ],
-      { refreshRoster },
+      { fetchRoster },
     );
 
-    expect(refreshRoster).toHaveBeenCalledTimes(1);
-    expect(refreshRoster).toHaveBeenCalledWith(tmpRoot, "acme");
+    expect(fetchRoster).toHaveBeenCalledTimes(1);
+    expect(fetchRoster).toHaveBeenCalledWith(tmpRoot, "acme");
     expect(logSpy).toHaveBeenCalledWith("ada@acme.com");
   });
 
-  it("resolve local miss with refresh failure reports unchanged not_found JSON and logs a note", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>(async () => {
+  it("resolve local miss with fetch failure reports unchanged not_found JSON and logs a note", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>(async () => {
       throw new Error("not signed in");
     });
 
@@ -577,22 +742,22 @@ describe("hq people (wired)", () => {
           tmpRoot,
           "--json",
         ],
-        { refreshRoster },
+        { fetchRoster },
       ),
     ).rejects.toThrow("__exit__");
 
-    expect(refreshRoster).toHaveBeenCalledTimes(1);
+    expect(fetchRoster).toHaveBeenCalledTimes(1);
     expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual({
       status: "not_found",
     });
     expect(errSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Could not refresh people roster"),
+      expect.stringContaining("Could not fetch people roster"),
     );
     expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
-  it("resolve --local-only skips refresh on a miss", async () => {
-    const refreshRoster = vi.fn<RefreshPeopleRoster>();
+  it("resolve --local-only skips fetch on a miss", async () => {
+    const fetchRoster = vi.fn<FetchPeopleRoster>();
     await expect(
       run(
         [
@@ -606,11 +771,11 @@ describe("hq people (wired)", () => {
           "--json",
           "--local-only",
         ],
-        { refreshRoster },
+        { fetchRoster },
       ),
     ).rejects.toThrow("__exit__");
 
-    expect(refreshRoster).not.toHaveBeenCalled();
+    expect(fetchRoster).not.toHaveBeenCalled();
     expect(JSON.parse(logSpy.mock.calls[0][0] as string)).toEqual({
       status: "not_found",
     });