@indigoai-us/hq-cli 5.58.0 → 5.59.0

package/src/commands/people.ts

@@ -6,25 +6,21 @@
  *   hq people search <keyword> [--company <slug>] [--json]
  *   hq people resolve <name>   [--company <slug>] [--json]
  *
- * Source of truth is `companies/<company>/people/<person>/meta.yaml`. Every
- * subcommand operates on exactly ONE company (the active company, or the one
- * named by `--company`); nothing reads across company boundaries.
+ * Local records from `companies/<company>/people/<person>/meta.yaml` are the
+ * curated primary source. On misses, commands may fall back to the membership
+ * roster for exactly ONE company (the active company, or the one named by
+ * `--company`); nothing reads across company boundaries.
  */
 
 import * as fs from "fs";
 import { Command, Option } from "commander";
 import chalk from "chalk";
-import { VaultClient } from "@indigoai-us/hq-cloud";
 import * as yaml from "js-yaml";
 import { findHqRoot } from "../utils/manifest.js";
 import { manifestPath, type ManifestDoc } from "./cloud-provision.js";
-import {
-  DEFAULT_COGNITO,
-  buildVaultConfig,
-  ensureCognitoToken,
-} from "../utils/cognito-session.js";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { getCompanyUid } from "../utils/vault-api.js";
-import { createCompanyPresignClient, runGet } from "./files-browse.js";
+import { listActiveMembers, type ActiveMember } from "./members.js";
 import {
   assertSafeCompanySlug,
   listCompanyPeople,
@@ -39,13 +35,13 @@ interface PeopleScopeOpts {
   hqRoot?: string;
 }
 
-export type RefreshPeopleRoster = (
+export type FetchPeopleRoster = (
   hqRoot: string,
   companySlug: string,
-) => Promise<void>;
+) => Promise<PersonRecord[]>;
 
 interface PeopleCommandDeps {
-  refreshRoster?: RefreshPeopleRoster;
+  fetchRoster?: FetchPeopleRoster;
 }
 
 interface PeopleLookupOpts {
@@ -53,23 +49,71 @@ interface PeopleLookupOpts {
   json?: boolean;
 }
 
-export async function refreshPeopleRosterFromCloud(
+function slugify(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+export function activeMemberToPersonRecord(
+  m: ActiveMember,
+): PersonRecord | null {
+  const name =
+    m.personName?.trim() ||
+    m.personEmail?.trim() ||
+    m.personSlug?.trim() ||
+    "";
+  if (!name) return null;
+
+  const email = m.personEmail?.trim() || undefined;
+  const slug = m.personSlug?.trim() || slugify(name) || m.personUid;
+
+  return {
+    slug,
+    name,
+    email,
+    role: m.role || undefined,
+    type: "internal",
+    source: `hq-pro membership: /membership/company/${m.companyUid}`,
+  };
+}
+
+export async function fetchMembershipRoster(
   hqRoot: string,
   companySlug: string,
-): Promise<void> {
-  const accessToken = await ensureCognitoToken();
-  const client = new VaultClient(buildVaultConfig(accessToken));
-  await getCompanyUid(accessToken, companySlug);
-
-  await runGet({
-    path: `companies/${companySlug}/people/`,
-    hqRoot,
-    companySlug,
-    vaultClient: client,
-    companyClient: ({ companyUid }) =>
-      createCompanyPresignClient({ token: accessToken, companyUid }),
-    region: DEFAULT_COGNITO.region,
-  });
+): Promise<PersonRecord[]> {
+  void hqRoot;
+  const token = await ensureCognitoToken();
+  const companyUid = await getCompanyUid(token, companySlug);
+  const members = await listActiveMembers(token, companyUid);
+  return members
+    .map(activeMemberToPersonRecord)
+    .filter((r): r is PersonRecord => r !== null);
+}
+
+function personIdentityKey(person: PersonRecord): string {
+  return (
+    person.email?.toLowerCase() ||
+    person.slug?.toLowerCase() ||
+    person.name.toLowerCase()
+  );
+}
+
+export function mergePeople(
+  primary: PersonRecord[],
+  extra: PersonRecord[],
+): PersonRecord[] {
+  const seen = new Set(primary.map(personIdentityKey));
+  const merged = [...primary];
+  for (const person of extra) {
+    const key = personIdentityKey(person);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(person);
+  }
+  return merged;
 }
 
 /** Companies that still exist (anything not explicitly `status: archived`). */
@@ -159,26 +203,25 @@ function fail(message: string): never {
   process.exit(1);
 }
 
-function logRefreshFailure(companySlug: string, err: unknown): void {
+function logRosterFetchFailure(companySlug: string, err: unknown): void {
   const message = err instanceof Error ? err.message : String(err);
   console.error(
     chalk.dim(
-      `  Could not refresh people roster for '${companySlug}': ${message}`,
+      `  Could not fetch people roster for '${companySlug}': ${message}`,
     ),
   );
 }
 
-async function tryRefreshRoster(
-  refreshRoster: RefreshPeopleRoster,
+async function tryFetchRoster(
+  fetchRoster: FetchPeopleRoster,
   hqRoot: string,
   slug: string,
-): Promise<boolean> {
+): Promise<PersonRecord[] | null> {
   try {
-    await refreshRoster(hqRoot, slug);
-    return true;
+    return await fetchRoster(hqRoot, slug);
   } catch (err) {
-    logRefreshFailure(slug, err);
-    return false;
+    logRosterFetchFailure(slug, err);
+    return null;
   }
 }
 
@@ -188,25 +231,20 @@ export async function resolvePersonWithRosterFallback(
     slug: string;
     name: string;
     opts?: PeopleLookupOpts;
-    refreshRoster?: RefreshPeopleRoster;
+    fetchRoster?: FetchPeopleRoster;
   },
 ): Promise<ReturnType<typeof resolveNameToEmail>> {
-  const local = resolveNameToEmail(
-    listCompanyPeople(input.hqRoot, input.slug),
-    input.name,
-  );
+  const localPeople = listCompanyPeople(input.hqRoot, input.slug);
+  const local = resolveNameToEmail(localPeople, input.name);
   if (local.status !== "not_found" || input.opts?.localOnly) return local;
 
-  const refreshed = await tryRefreshRoster(
-    input.refreshRoster ?? refreshPeopleRosterFromCloud,
+  const roster = await tryFetchRoster(
+    input.fetchRoster ?? fetchMembershipRoster,
     input.hqRoot,
     input.slug,
   );
-  if (!refreshed) return local;
-  return resolveNameToEmail(
-    listCompanyPeople(input.hqRoot, input.slug),
-    input.name,
-  );
+  if (!roster) return local;
+  return resolveNameToEmail(mergePeople(localPeople, roster), input.name);
 }
 
 export async function searchPeopleWithRosterFallback(input: {
@@ -214,21 +252,19 @@ export async function searchPeopleWithRosterFallback(input: {
   slug: string;
   keyword: string;
   opts?: PeopleLookupOpts;
-  refreshRoster?: RefreshPeopleRoster;
+  fetchRoster?: FetchPeopleRoster;
 }): Promise<PersonRecord[]> {
-  const local = searchPeople(
-    listCompanyPeople(input.hqRoot, input.slug),
-    input.keyword,
-  );
+  const localPeople = listCompanyPeople(input.hqRoot, input.slug);
+  const local = searchPeople(localPeople, input.keyword);
   if (local.length > 0 || input.opts?.localOnly) return local;
 
-  const refreshed = await tryRefreshRoster(
-    input.refreshRoster ?? refreshPeopleRosterFromCloud,
+  const roster = await tryFetchRoster(
+    input.fetchRoster ?? fetchMembershipRoster,
     input.hqRoot,
     input.slug,
   );
-  if (!refreshed) return local;
-  return searchPeople(listCompanyPeople(input.hqRoot, input.slug), input.keyword);
+  if (!roster) return local;
+  return searchPeople(mergePeople(localPeople, roster), input.keyword);
 }
 
 export function registerPeopleCommand(
@@ -257,12 +293,26 @@ export function registerPeopleCommand(
     .command("list")
     .description("List all people recorded for the company")
     .option("--json", "Output JSON instead of a table")
-    .action((opts: { json?: boolean }) => {
+    .option(
+      "--local-only",
+      "Skip network fallback; list only the local people roster",
+    )
+    .action(async (opts: PeopleLookupOpts) => {
       try {
         const scope = people.opts() as PeopleScopeOpts;
         const hqRoot = resolveHqRoot(scope);
         const slug = resolveCompanySlug(hqRoot, scope.company);
-        const records = listCompanyPeople(hqRoot, slug);
+        let records = listCompanyPeople(hqRoot, slug);
+
+        if (!opts.localOnly) {
+          const roster = await tryFetchRoster(
+            deps.fetchRoster ?? fetchMembershipRoster,
+            hqRoot,
+            slug,
+          );
+          if (roster) records = mergePeople(records, roster);
+        }
+        records = records.sort((a, b) => a.name.localeCompare(b.name));
 
         if (opts.json) {
           console.log(JSON.stringify(records, null, 2));
@@ -288,7 +338,7 @@ export function registerPeopleCommand(
     .option("--json", "Output JSON instead of a table")
     .option(
       "--local-only",
-      "Skip cloud fallback; search only the local people roster",
+      "Skip network fallback; search only the local people roster",
     )
     .action(async (keyword: string, opts: PeopleLookupOpts) => {
       try {
@@ -300,7 +350,7 @@ export function registerPeopleCommand(
           slug,
           keyword,
           opts,
-          refreshRoster: deps.refreshRoster,
+          fetchRoster: deps.fetchRoster,
         });
 
         if (opts.json) {
@@ -323,7 +373,7 @@ export function registerPeopleCommand(
     .option("--json", "Output JSON instead of plain text")
     .option(
       "--local-only",
-      "Skip cloud fallback; resolve only from the local people roster",
+      "Skip network fallback; resolve only from the local people roster",
     )
     .action(async (name: string, opts: PeopleLookupOpts) => {
       try {
@@ -335,7 +385,7 @@ export function registerPeopleCommand(
           slug,
           name,
           opts,
-          refreshRoster: deps.refreshRoster,
+          fetchRoster: deps.fetchRoster,
         });
 
         if (opts.json) {

package/src/index.ts

@@ -41,6 +41,7 @@ import { registerFilesBrowseCommands } from "./commands/files-browse.js";
 import { registerMembersCommand } from "./commands/members.js";
 import { registerPeopleCommand } from "./commands/people.js";
 import { registerDmCommand } from "./commands/dm.js";
+import { registerChannelsCommand } from "./commands/channels.js";
 import { registerFeedbackCommand } from "./commands/feedback.js";
 import { registerMeetingsCommand } from "./commands/meetings.js";
 import { registerSourcesCommand } from "./commands/sources.js";
@@ -184,6 +185,7 @@ registerMembersCommand(program);
 // the local companies/<co>/people store scoped to one company.
 registerPeopleCommand(program);
 registerDmCommand(program);
+registerChannelsCommand(program);
 
 // Onboarding (top-level — Cognito + vault-service provisioning)
 registerOnboardCommand(program);