@indigoai-us/hq-cli 5.14.1 → 5.16.0

package/src/commands/meetings.ts

@@ -0,0 +1,487 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { vaultApiFetch } from "../utils/vault-api.js";
+
+interface MeetingListItem {
+  meetingId: string;
+  title: string;
+  startTime: string;
+  endTime: string;
+  duration: number;
+  participantCount: number;
+  status: string;
+  hasTranscript: boolean;
+  hasNotes: boolean;
+}
+
+interface MeetingDetail {
+  meetingId: string;
+  title: string;
+  startTime: string;
+  endTime: string;
+  duration: number;
+  participants: Array<{ email: string; name: string | null; role: string }>;
+  calendarEventId: string | null;
+  botProvider: string;
+  sourceApp: string;
+  companyId: string;
+  status: string;
+  recallBotId: string | null;
+  isShared: boolean;
+  createdAt: string;
+  updatedAt: string;
+  documentUrl: string;
+  hasTranscript: boolean;
+  hasNotes: boolean;
+}
+
+interface TranscriptSegment {
+  speaker: string;
+  text: string;
+  startTime: number;
+  endTime: number;
+}
+
+interface MeetingNotes {
+  summary: string;
+  keyPoints: string[];
+  decisions: string[];
+  actionItems: Array<{ task: string; assignee: string | null }>;
+  participantContributions: Array<{
+    name: string;
+    speakingTimePercent: number;
+    topicsSummary: string;
+  }>;
+  model: string;
+  generatedAt: string;
+}
+
+interface MeetingDocument {
+  meetingId: string;
+  title: string;
+  startTime: string;
+  endTime: string;
+  duration: number;
+  participants: Array<{ email: string; name: string | null; role: string }>;
+  status: string;
+  transcript: TranscriptSegment[] | null;
+  notes: MeetingNotes | null;
+}
+
+function formatDuration(seconds: number): string {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  if (h > 0) return `${h}h ${m}m`;
+  if (m > 0) return `${m}m ${s}s`;
+  return `${s}s`;
+}
+
+function formatTimestamp(ts: number): string {
+  const m = Math.floor(ts / 60);
+  const s = Math.floor(ts % 60);
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+
+function statusBadge(status: string): string {
+  switch (status) {
+    case "completed":
+      return chalk.green(status);
+    case "recording":
+      return chalk.red(status);
+    case "processing":
+      return chalk.yellow(status);
+    case "failed":
+      return chalk.red(status);
+    default:
+      return chalk.dim(status);
+  }
+}
+
+async function resolveShortId(
+  token: string,
+  prefix: string,
+  query: Record<string, string>,
+): Promise<string> {
+  if (prefix.includes("-") && prefix.length > 8) return prefix;
+  const res = await vaultApiFetch({ token, path: "/v1/meetings", query });
+  if (!res.ok) return prefix;
+  const data = (await res.json()) as { meetings: MeetingListItem[] };
+  const matches = data.meetings.filter((m) => m.meetingId.startsWith(prefix));
+  if (matches.length === 1) return matches[0].meetingId;
+  if (matches.length > 1) {
+    console.error(chalk.red(`Ambiguous ID prefix "${prefix}" — matches ${matches.length} meetings. Use a longer prefix.`));
+    process.exit(1);
+  }
+  return prefix;
+}
+
+async function handleApiError(res: Response): Promise<never> {
+  const body = (await res.json().catch(() => ({}))) as Record<string, string>;
+  if (res.status === 401) {
+    console.error(chalk.red("Not authenticated — run `hq login` first"));
+  } else if (res.status === 403) {
+    console.error(chalk.red(body.error ?? "Not authorized"));
+  } else if (res.status === 404) {
+    console.error(chalk.red(body.error ?? "Not found"));
+  } else {
+    console.error(chalk.red(`API error (${res.status}): ${body.error ?? res.statusText}`));
+  }
+  process.exit(1);
+}
+
+function printMeetingTable(meetings: MeetingListItem[]): void {
+  if (meetings.length === 0) {
+    console.log(chalk.dim("  No meetings found."));
+    return;
+  }
+
+  const ID_W = 8;
+  const TITLE_W = Math.min(40, Math.max(10, ...meetings.map((m) => m.title.length)));
+  const DATE_W = 16;
+  const DUR_W = 8;
+  const STATUS_W = 12;
+  const PARTS_W = 6;
+  const FLAGS_W = 5;
+
+  console.log(
+    chalk.bold(
+      [
+        "ID".padEnd(ID_W),
+        "TITLE".padEnd(TITLE_W),
+        "DATE".padEnd(DATE_W),
+        "DUR".padEnd(DUR_W),
+        "STATUS".padEnd(STATUS_W),
+        "PARTS".padEnd(PARTS_W),
+        "FLAGS",
+      ].join("  "),
+    ),
+  );
+
+  for (const m of meetings) {
+    const id = m.meetingId.slice(0, 8);
+    const title = m.title.length > TITLE_W ? m.title.slice(0, TITLE_W - 1) + "…" : m.title;
+    const date = new Date(m.startTime).toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+    const dur = formatDuration(m.duration);
+    const flags = [
+      m.hasTranscript ? "T" : "",
+      m.hasNotes ? "N" : "",
+    ].filter(Boolean).join("") || "-";
+
+    console.log(
+      [
+        chalk.cyan(id.padEnd(ID_W)),
+        title.padEnd(TITLE_W),
+        chalk.dim(date.padEnd(DATE_W)),
+        dur.padEnd(DUR_W),
+        statusBadge(m.status).padEnd(STATUS_W + 10), // chalk adds escape chars
+        String(m.participantCount).padEnd(PARTS_W),
+        flags,
+      ].join("  "),
+    );
+  }
+}
+
+export function registerMeetingsCommand(program: Command): void {
+  const meetings = program
+    .command("meetings")
+    .description("View and search meeting recordings, transcripts, and notes")
+    .option("--company <slug>", "Company slug (for multi-company users)")
+    .option("--json", "Output raw JSON instead of formatted text");
+
+  // ── hq meetings list ──────────────────────────────────────────────
+
+  meetings
+    .command("list")
+    .description("List recorded meetings (newest first)")
+    .option("--limit <n>", "Number of meetings to return (default: 20)")
+    .option("--next <token>", "Pagination token from a previous response")
+    .action(async (opts: { limit?: string; next?: string }) => {
+      try {
+        const token = await ensureCognitoToken();
+        const query: Record<string, string> = {};
+        const companySlug = meetings.opts().company as string | undefined;
+
+        if (opts.limit) query.limit = opts.limit;
+        if (opts.next) query.nextToken = opts.next;
+        if (companySlug) query.companyId = companySlug;
+
+        const res = await vaultApiFetch({ token, path: "/v1/meetings", query });
+        if (!res.ok) await handleApiError(res);
+
+        const data = (await res.json()) as {
+          meetings: MeetingListItem[];
+          nextToken?: string;
+        };
+
+        if (meetings.opts().json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        console.log(chalk.bold(`\nMeetings (${data.meetings.length}):\n`));
+        printMeetingTable(data.meetings);
+
+        if (data.nextToken) {
+          console.log(
+            chalk.dim(`\n  More results available. Run with --next ${data.nextToken}`),
+          );
+        }
+        console.log();
+      } catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  // ── hq meetings get <id> ──────────────────────────────────────────
+
+  meetings
+    .command("get <meetingId>")
+    .description("Show meeting details")
+    .action(async (rawId: string) => {
+      try {
+        const token = await ensureCognitoToken();
+        const query: Record<string, string> = {};
+        const companySlug = meetings.opts().company as string | undefined;
+        if (companySlug) query.companyId = companySlug;
+
+        const meetingId = await resolveShortId(token, rawId, query);
+        const res = await vaultApiFetch({
+          token,
+          path: `/v1/meetings/${encodeURIComponent(meetingId)}`,
+          query,
+        });
+        if (!res.ok) await handleApiError(res);
+
+        const detail = (await res.json()) as MeetingDetail;
+
+        if (meetings.opts().json) {
+          console.log(JSON.stringify(detail, null, 2));
+          return;
+        }
+
+        console.log(chalk.bold(`\n${detail.title}\n`));
+        console.log(`  ID:       ${chalk.cyan(detail.meetingId)}`);
+        console.log(`  Status:   ${statusBadge(detail.status)}`);
+        console.log(`  Date:     ${new Date(detail.startTime).toLocaleString()}`);
+        console.log(`  Duration: ${formatDuration(detail.duration)}`);
+        console.log(`  Source:   ${detail.sourceApp} (${detail.botProvider})`);
+        console.log(`  Shared:   ${detail.isShared ? "yes" : "no"}`);
+
+        if (detail.participants.length > 0) {
+          console.log(chalk.bold("\n  Participants:"));
+          for (const p of detail.participants) {
+            const name = p.name ?? p.email;
+            const role = p.role === "organizer" ? chalk.yellow(" (organizer)") : "";
+            console.log(`    - ${name}${role}`);
+          }
+        }
+
+        const flags = [];
+        if (detail.hasTranscript) flags.push("transcript");
+        if (detail.hasNotes) flags.push("notes");
+        if (flags.length > 0) {
+          console.log(
+            chalk.dim(`\n  Available: ${flags.join(", ")}. Use \`hq meetings transcript ${detail.meetingId.slice(0, 8)}\` or \`hq meetings notes ${detail.meetingId.slice(0, 8)}\`.`),
+          );
+        }
+        console.log();
+      } catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  // ── hq meetings search <query> ─────────────────────────────────────
+
+  meetings
+    .command("search <query>")
+    .description("Search meetings by title or participant name")
+    .action(async (query: string) => {
+      try {
+        const token = await ensureCognitoToken();
+        const params: Record<string, string> = { q: query };
+        const companySlug = meetings.opts().company as string | undefined;
+        if (companySlug) params.companyId = companySlug;
+
+        const res = await vaultApiFetch({
+          token,
+          path: "/v1/meetings/search",
+          query: params,
+        });
+        if (!res.ok) await handleApiError(res);
+
+        const data = (await res.json()) as {
+          results: MeetingListItem[];
+          query: string;
+        };
+
+        if (meetings.opts().json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        console.log(chalk.bold(`\nSearch results for "${data.query}" (${data.results.length}):\n`));
+        printMeetingTable(data.results);
+        console.log();
+      } catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  // ── hq meetings transcript <id> ────────────────────────────────────
+
+  meetings
+    .command("transcript <meetingId>")
+    .description("Print the meeting transcript")
+    .action(async (rawId: string) => {
+      try {
+        const token = await ensureCognitoToken();
+        const query: Record<string, string> = {};
+        const companySlug = meetings.opts().company as string | undefined;
+        if (companySlug) query.companyId = companySlug;
+
+        const meetingId = await resolveShortId(token, rawId, query);
+        const res = await vaultApiFetch({
+          token,
+          path: `/v1/meetings/${encodeURIComponent(meetingId)}`,
+          query,
+        });
+        if (!res.ok) await handleApiError(res);
+
+        const detail = (await res.json()) as MeetingDetail;
+        if (!detail.documentUrl) {
+          console.error(chalk.red("No document URL available for this meeting."));
+          process.exit(1);
+        }
+
+        const docRes = await fetch(detail.documentUrl);
+        if (!docRes.ok) {
+          console.error(chalk.red(`Failed to download meeting document (${docRes.status})`));
+          process.exit(1);
+        }
+
+        const doc = (await docRes.json()) as MeetingDocument;
+
+        if (meetings.opts().json) {
+          console.log(JSON.stringify(doc.transcript, null, 2));
+          return;
+        }
+
+        if (!doc.transcript || doc.transcript.length === 0) {
+          console.log(chalk.yellow("No transcript available for this meeting."));
+          return;
+        }
+
+        console.log(chalk.bold(`\nTranscript: ${doc.title}\n`));
+        for (const seg of doc.transcript) {
+          const time = formatTimestamp(seg.startTime);
+          console.log(`${chalk.dim(time)}  ${chalk.cyan(seg.speaker)}`);
+          console.log(`        ${seg.text}\n`);
+        }
+      } catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  // ── hq meetings notes <id> ─────────────────────────────────────────
+
+  meetings
+    .command("notes <meetingId>")
+    .description("Print AI-generated meeting notes")
+    .action(async (rawId: string) => {
+      try {
+        const token = await ensureCognitoToken();
+        const query: Record<string, string> = {};
+        const companySlug = meetings.opts().company as string | undefined;
+        if (companySlug) query.companyId = companySlug;
+
+        const meetingId = await resolveShortId(token, rawId, query);
+        const res = await vaultApiFetch({
+          token,
+          path: `/v1/meetings/${encodeURIComponent(meetingId)}`,
+          query,
+        });
+        if (!res.ok) await handleApiError(res);
+
+        const detail = (await res.json()) as MeetingDetail;
+        if (!detail.documentUrl) {
+          console.error(chalk.red("No document URL available for this meeting."));
+          process.exit(1);
+        }
+
+        const docRes = await fetch(detail.documentUrl);
+        if (!docRes.ok) {
+          console.error(chalk.red(`Failed to download meeting document (${docRes.status})`));
+          process.exit(1);
+        }
+
+        const doc = (await docRes.json()) as MeetingDocument;
+
+        if (meetings.opts().json) {
+          console.log(JSON.stringify(doc.notes, null, 2));
+          return;
+        }
+
+        if (!doc.notes) {
+          console.log(chalk.yellow("No notes available for this meeting."));
+          return;
+        }
+
+        const notes = doc.notes;
+        console.log(chalk.bold(`\nMeeting Notes: ${doc.title}\n`));
+
+        console.log(chalk.bold("Summary"));
+        console.log(`  ${notes.summary}\n`);
+
+        if (notes.keyPoints.length > 0) {
+          console.log(chalk.bold("Key Points"));
+          for (const point of notes.keyPoints) {
+            console.log(`  • ${point}`);
+          }
+          console.log();
+        }
+
+        if (notes.decisions.length > 0) {
+          console.log(chalk.bold("Decisions"));
+          for (const d of notes.decisions) {
+            console.log(`  ✓ ${d}`);
+          }
+          console.log();
+        }
+
+        if (notes.actionItems.length > 0) {
+          console.log(chalk.bold("Action Items"));
+          for (const item of notes.actionItems) {
+            const assignee = item.assignee ? chalk.dim(` → ${item.assignee}`) : "";
+            console.log(`  □ ${item.task}${assignee}`);
+          }
+          console.log();
+        }
+
+        if (notes.participantContributions.length > 0) {
+          console.log(chalk.bold("Participant Contributions"));
+          for (const p of notes.participantContributions) {
+            console.log(`  ${p.name} (${p.speakingTimePercent}%)`);
+            console.log(`    ${chalk.dim(p.topicsSummary)}`);
+          }
+          console.log();
+        }
+
+        console.log(chalk.dim(`Generated by ${notes.model} at ${notes.generatedAt}`));
+        console.log();
+      } catch (err) {
+        console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+}

package/src/index.ts

@@ -29,6 +29,7 @@ import { registerGroupsCommand } from "./commands/groups.js";
 import { registerFilesCommand } from "./commands/files.js";
 import { registerMembersCommand } from "./commands/members.js";
 import { registerFeedbackCommand } from "./commands/feedback.js";
+import { registerMeetingsCommand } from "./commands/meetings.js";
 import { sanitizeArgv } from "./utils/feedback-diagnostics.js";
 import {
   maybeWarnNewVersion,
@@ -130,6 +131,9 @@ registerOnboardCommand(program);
 // Feedback (subcommand group — hq feedback bug|feature)
 registerFeedbackCommand(program);
 
+// Meetings (subcommand group — hq meetings list|get|search|transcript|notes)
+registerMeetingsCommand(program);
+
 (async () => {
   try {
     Sentry.addBreadcrumb({

package/tsconfig.json

@@ -1,6 +1,17 @@
 {
-  "extends": "../../tsconfig.base.json",
   "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
     "outDir": "dist",
     "rootDir": "src"
   },