@indigoai-us/hq-cli 5.77.14 → 5.79.0

package/src/commands/people.ts

@@ -1,422 +0,0 @@
-/**
- * `hq people` — read a company's people (membership) records from the local HQ
- * tree and search/resolve over them.
- *
- *   hq people list      [--company <slug>] [--json]
- *   hq people search <keyword> [--company <slug>] [--json]
- *   hq people resolve <name>   [--company <slug>] [--json]
- *
- * 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 { parseUserYaml } from "../utils/user-yaml-error.js";
-import { findHqRoot } from "../utils/manifest.js";
-import { manifestPath, type ManifestDoc } from "./cloud-provision.js";
-import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { getCompanyUid } from "../utils/vault-api.js";
-import { listActiveMembers, type ActiveMember } from "./members.js";
-import {
-  assertSafeCompanySlug,
-  listCompanyPeople,
-  searchPeople,
-  resolveNameToEmail,
-  companyPeopleDir,
-  type PersonRecord,
-} from "../utils/people.js";
-
-interface PeopleScopeOpts {
-  company?: string;
-  hqRoot?: string;
-}
-
-export type FetchPeopleRoster = (
-  hqRoot: string,
-  companySlug: string,
-) => Promise<PersonRecord[]>;
-
-interface PeopleCommandDeps {
-  fetchRoster?: FetchPeopleRoster;
-}
-
-interface PeopleLookupOpts {
-  localOnly?: boolean;
-  json?: boolean;
-}
-
-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<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`). */
-function activeCompanySlugs(manifest: ManifestDoc): string[] {
-  const companies = manifest.companies ?? {};
-  return Object.entries(companies)
-    .filter(([, entry]) => (entry?.status ?? "active") !== "archived")
-    .map(([slug]) => slug)
-    .sort();
-}
-
-/**
- * Resolve the single company to operate on. Explicit `--company` always wins
- * (after a path-safety check). Otherwise the active company is inferred from
- * `companies/manifest.yaml`: if exactly one company exists it's used; if several
- * do, the caller must disambiguate with `--company`.
- */
-export function resolveCompanySlug(
-  hqRoot: string,
-  explicit: string | undefined,
-): string {
-  if (explicit) {
-    assertSafeCompanySlug(explicit);
-    return explicit;
-  }
-  const mPath = manifestPath(hqRoot);
-  if (!fs.existsSync(mPath)) {
-    throw new Error(
-      "Could not determine the active company — companies/manifest.yaml not found. " +
-        "Re-run with --company <slug>.",
-    );
-  }
-  const manifest = parseUserYaml<ManifestDoc>(
-    fs.readFileSync(mPath, "utf-8"),
-    mPath,
-  );
-  const slugs = activeCompanySlugs(manifest ?? {});
-  if (slugs.length === 1) return slugs[0];
-  if (slugs.length === 0) {
-    throw new Error(
-      "No companies found in companies/manifest.yaml — re-run with --company <slug>.",
-    );
-  }
-  throw new Error(
-    "Multiple companies found — re-run with --company <slug> to pick one:\n" +
-      slugs.map((s) => `  --company ${s}`).join("\n"),
-  );
-}
-
-/** Resolve the HQ root: explicit override (tests) → cwd walk-up. */
-function resolveHqRoot(opts: PeopleScopeOpts): string {
-  return opts.hqRoot ?? findHqRoot();
-}
-
-function printPeopleTable(people: PersonRecord[]): void {
-  const nameW = Math.max(4, ...people.map((p) => p.name.length));
-  const emailW = Math.max(5, ...people.map((p) => (p.email ?? "—").length));
-  const roleW = Math.max(4, ...people.map((p) => (p.role ?? "—").length));
-  console.log(
-    chalk.bold(
-      [
-        "NAME".padEnd(nameW),
-        "EMAIL".padEnd(emailW),
-        "ROLE".padEnd(roleW),
-        "TYPE",
-      ].join("  "),
-    ),
-  );
-  for (const p of people) {
-    console.log(
-      [
-        p.name.padEnd(nameW),
-        (p.email ?? "—").padEnd(emailW),
-        (p.role ?? "—").padEnd(roleW),
-        p.type ?? "—",
-      ].join("  "),
-    );
-  }
-}
-
-function fail(message: string): never {
-  console.error(chalk.red(message));
-  process.exit(1);
-}
-
-function logRosterFetchFailure(companySlug: string, err: unknown): void {
-  const message = err instanceof Error ? err.message : String(err);
-  console.error(
-    chalk.dim(
-      `  Could not fetch people roster for '${companySlug}': ${message}`,
-    ),
-  );
-}
-
-async function tryFetchRoster(
-  fetchRoster: FetchPeopleRoster,
-  hqRoot: string,
-  slug: string,
-): Promise<PersonRecord[] | null> {
-  try {
-    return await fetchRoster(hqRoot, slug);
-  } catch (err) {
-    logRosterFetchFailure(slug, err);
-    return null;
-  }
-}
-
-export async function resolvePersonWithRosterFallback(
-  input: {
-    hqRoot: string;
-    slug: string;
-    name: string;
-    opts?: PeopleLookupOpts;
-    fetchRoster?: FetchPeopleRoster;
-  },
-): Promise<ReturnType<typeof resolveNameToEmail>> {
-  const localPeople = listCompanyPeople(input.hqRoot, input.slug);
-  const local = resolveNameToEmail(localPeople, input.name);
-  if (local.status !== "not_found" || input.opts?.localOnly) return local;
-
-  const roster = await tryFetchRoster(
-    input.fetchRoster ?? fetchMembershipRoster,
-    input.hqRoot,
-    input.slug,
-  );
-  if (!roster) return local;
-  return resolveNameToEmail(mergePeople(localPeople, roster), input.name);
-}
-
-export async function searchPeopleWithRosterFallback(input: {
-  hqRoot: string;
-  slug: string;
-  keyword: string;
-  opts?: PeopleLookupOpts;
-  fetchRoster?: FetchPeopleRoster;
-}): Promise<PersonRecord[]> {
-  const localPeople = listCompanyPeople(input.hqRoot, input.slug);
-  const local = searchPeople(localPeople, input.keyword);
-  if (local.length > 0 || input.opts?.localOnly) return local;
-
-  const roster = await tryFetchRoster(
-    input.fetchRoster ?? fetchMembershipRoster,
-    input.hqRoot,
-    input.slug,
-  );
-  if (!roster) return local;
-  return searchPeople(mergePeople(localPeople, roster), input.keyword);
-}
-
-export function registerPeopleCommand(
-  program: Command,
-  deps: PeopleCommandDeps = {},
-): void {
-  const people = program
-    .command("people")
-    .description(
-      "List, search, and resolve a company's people (from companies/<co>/people)",
-    )
-    .option(
-      "--company <slug>",
-      "Company slug to scope to (defaults to the active company)",
-    )
-    // Hidden escape hatch for tests / non-standard layouts — point the reader at
-    // an explicit HQ tree root instead of walking up from cwd.
-    .addOption(
-      new Option(
-        "--hq-root <path>",
-        "Override the HQ tree root (advanced)",
-      ).hideHelp(),
-    );
-
-  people
-    .command("list")
-    .description("List all people recorded for the company")
-    .option("--json", "Output JSON instead of a table")
-    .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);
-        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));
-          return;
-        }
-        if (records.length === 0) {
-          console.log(
-            chalk.gray(
-              `No people recorded for '${slug}' (looked in ${companyPeopleDir(hqRoot, slug)}).`,
-            ),
-          );
-          return;
-        }
-        printPeopleTable(records);
-      } catch (err) {
-        fail(err instanceof Error ? err.message : String(err));
-      }
-    });
-
-  people
-    .command("search <keyword>")
-    .description("Keyword search over people names and emails")
-    .option("--json", "Output JSON instead of a table")
-    .option(
-      "--local-only",
-      "Skip network fallback; search only the local people roster",
-    )
-    .action(async (keyword: string, opts: PeopleLookupOpts) => {
-      try {
-        const scope = people.opts() as PeopleScopeOpts;
-        const hqRoot = resolveHqRoot(scope);
-        const slug = resolveCompanySlug(hqRoot, scope.company);
-        const matches = await searchPeopleWithRosterFallback({
-          hqRoot,
-          slug,
-          keyword,
-          opts,
-          fetchRoster: deps.fetchRoster,
-        });
-
-        if (opts.json) {
-          console.log(JSON.stringify(matches, null, 2));
-          return;
-        }
-        if (matches.length === 0) {
-          console.log(chalk.gray(`No people in '${slug}' match "${keyword}".`));
-          return;
-        }
-        printPeopleTable(matches);
-      } catch (err) {
-        fail(err instanceof Error ? err.message : String(err));
-      }
-    });
-
-  people
-    .command("resolve <name>")
-    .description("Resolve a person name to their email address")
-    .option("--json", "Output JSON instead of plain text")
-    .option(
-      "--local-only",
-      "Skip network fallback; resolve only from the local people roster",
-    )
-    .action(async (name: string, opts: PeopleLookupOpts) => {
-      try {
-        const scope = people.opts() as PeopleScopeOpts;
-        const hqRoot = resolveHqRoot(scope);
-        const slug = resolveCompanySlug(hqRoot, scope.company);
-        const result = await resolvePersonWithRosterFallback({
-          hqRoot,
-          slug,
-          name,
-          opts,
-          fetchRoster: deps.fetchRoster,
-        });
-
-        if (opts.json) {
-          console.log(JSON.stringify(result, null, 2));
-          if (result.status === "found") return;
-          process.exit(1);
-        }
-
-        switch (result.status) {
-          case "found":
-            // Bare email on stdout so callers can capture it directly.
-            console.log(result.email);
-            return;
-          case "no_email":
-            fail(
-              `Found '${result.person.name}' in '${slug}' but no email is recorded for them.`,
-            );
-            break;
-          case "ambiguous":
-            console.error(
-              chalk.yellow(
-                `"${name}" matches ${result.matches.length} people in '${slug}' — be more specific:`,
-              ),
-            );
-            for (const m of result.matches) {
-              console.error(`  ${m.name}${m.email ? ` <${m.email}>` : ""}`);
-            }
-            process.exit(1);
-            break;
-          case "not_found":
-            fail(`No person matching "${name}" found in '${slug}'.`);
-            break;
-        }
-      } catch (err) {
-        fail(err instanceof Error ? err.message : String(err));
-      }
-    });
-}

package/src/commands/pkg-install.dispatch.test.ts

@@ -1,103 +0,0 @@
-// @vitest-environment node
-/**
- * Regression: `hq install <bare-slug>` must resolve through the marketplace
- * listings transport (the live install path), not the legacy Cognito-gated
- * registry flow whose backend (/packages, /entitlements) was never deployed.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Command } from 'commander';
-
-// vi.mock is hoisted above imports/consts, so build the mocks via vi.hoisted()
-// to avoid a temporal-dead-zone reference inside the factory.
-const { installPack, sourceMatchesPackPattern } = vi.hoisted(() => ({
-  installPack: vi.fn(async () => {}),
-  // Mirror the real classifier: pack-pattern sources (marketplace:/@scope/git/
-  // path) match; bare slugs do not.
-  sourceMatchesPackPattern: vi.fn(
-    (s: string) =>
-      s.startsWith('marketplace:') ||
-      s.startsWith('@') ||
-      s.startsWith('./') ||
-      s.startsWith('../') ||
-      s.startsWith('/') ||
-      s.endsWith('.git') ||
-      s.startsWith('git@') ||
-      s.startsWith('http://') ||
-      s.startsWith('https://'),
-  ),
-}));
-
-vi.mock('./pack-install.js', () => ({
-  MARKETPLACE_PREFIX: 'marketplace:',
-  installPack,
-  sourceMatchesPackPattern,
-}));
-
-import { registerPackageInstallCommand } from './pkg-install.js';
-
-async function runInstall(...args: string[]): Promise<void> {
-  const program = new Command();
-  program.exitOverride();
-  registerPackageInstallCommand(program);
-  await program.parseAsync(['install', ...args], { from: 'user' });
-}
-
-describe('hq install dispatch — bare slug routes to marketplace', () => {
-  beforeEach(() => {
-    installPack.mockClear();
-    sourceMatchesPackPattern.mockClear();
-  });
-
-  afterEach(() => {
-    delete process.env.HQ_API_KEY;
-  });
-
-  it('routes a bare slug through the marketplace transport', async () => {
-    await runInstall('email-assistant');
-    expect(installPack).toHaveBeenCalledTimes(1);
-    expect(installPack.mock.calls[0][0]).toBe('marketplace:email-assistant');
-  });
-
-  it('preserves a pinned version on a bare slug', async () => {
-    await runInstall('email-assistant@0.1.0');
-    expect(installPack.mock.calls[0][0]).toBe('marketplace:email-assistant@0.1.0');
-  });
-
-  it('passes an explicit marketplace: source through unchanged', async () => {
-    await runInstall('marketplace:tdd');
-    expect(installPack.mock.calls[0][0]).toBe('marketplace:tdd');
-  });
-
-  it('passes a pack-pattern source (npm scope) through unchanged', async () => {
-    await runInstall('@indigoai-us/hq-pack-demo');
-    expect(installPack.mock.calls[0][0]).toBe('@indigoai-us/hq-pack-demo');
-  });
-});
-
-describe('hq install dispatch — HQ_API_KEY fail-closed gate', () => {
-  beforeEach(() => {
-    installPack.mockClear();
-    sourceMatchesPackPattern.mockClear();
-  });
-
-  afterEach(() => {
-    delete process.env.HQ_API_KEY;
-  });
-
-  it('rejects at the CLI entrypoint before calling installPack when HQ_API_KEY is set', async () => {
-    process.env.HQ_API_KEY = 'hqk_probe';
-    const exitSpy = vi
-      .spyOn(process, 'exit')
-      .mockImplementation((code?: number | string | null) => {
-        throw new Error(`process.exit(${code})`);
-      });
-    try {
-      await expect(runInstall('@indigoai-us/hq-pack-demo')).rejects.toThrow('process.exit(1)');
-      // The gate must fire BEFORE installPack -- a vault-key session must
-      // never reach the pack-fetch/wire path via `hq install`.
-      expect(installPack).not.toHaveBeenCalled();
-    } finally {
-      exitSpy.mockRestore();
-    }
-  });
-});