kcg-code 0.0.0-stage → 0.2.0

package/src/lib/passkeys.ts

@@ -0,0 +1,113 @@
+/**
+ * Klien passkey (WebAuthn) — membungkus `@simplewebauthn/browser` + API
+ * `/api/auth/passkeys/*` agar Settings & lock screen memakai alur yang sama.
+ *
+ * Pembatalan oleh pengguna (menutup dialog sistem) bukan error: dikembalikan
+ * sebagai `{ ok: false, cancelled: true }` supaya UI tidak menampilkan pesan
+ * merah untuk tindakan yang disengaja.
+ */
+import {
+  browserSupportsWebAuthn,
+  startAuthentication,
+  startRegistration,
+} from "@simplewebauthn/browser";
+import { ApiError, apiFetch } from "@/lib/api";
+import type { PasskeyAvailability, PasskeyInfo } from "@/server/services/auth-passkeys";
+
+export type { PasskeyAvailability, PasskeyInfo };
+
+export type PasskeyResult<T> =
+  | { ok: true; data: T }
+  | { ok: false; cancelled: true }
+  | { ok: false; cancelled: false; message: string; code?: string };
+
+/** Browser ini bisa memakai passkey (API WebAuthn + secure context). */
+export function passkeysSupportedHere(): boolean {
+  if (typeof window === "undefined") return false;
+  return window.isSecureContext && browserSupportsWebAuthn();
+}
+
+/**
+ * Error dari `navigator.credentials` -> pesan ramah. `NotAllowedError` =
+ * dibatalkan / timeout oleh pengguna (diperlakukan sebagai batal).
+ */
+export function describeWebAuthnError(e: unknown): PasskeyResult<never> {
+  if (e instanceof ApiError)
+    return { ok: false, cancelled: false, message: e.message, code: e.code };
+  const name = e instanceof Error ? e.name : "";
+  if (name === "NotAllowedError" || name === "AbortError") return { ok: false, cancelled: true };
+  if (name === "InvalidStateError") {
+    return { ok: false, cancelled: false, message: "This device already has a passkey here." };
+  }
+  if (name === "SecurityError") {
+    return {
+      ok: false,
+      cancelled: false,
+      message: "Passkeys aren't allowed on this address. Use https or localhost.",
+    };
+  }
+  return { ok: false, cancelled: false, message: "Something went wrong with the passkey." };
+}
+
+export async function getPasskeyAvailability(): Promise<PasskeyAvailability> {
+  const res = await apiFetch("/api/auth/passkeys/availability");
+  return (await res.json()) as PasskeyAvailability;
+}
+
+export async function listPasskeys(): Promise<PasskeyInfo[]> {
+  const res = await apiFetch("/api/auth/passkeys");
+  return ((await res.json()) as { passkeys: PasskeyInfo[] }).passkeys;
+}
+
+/** Daftarkan passkey baru; `current` = PIN/password saat ini (konfirmasi). */
+export async function addPasskey(current: string): Promise<PasskeyResult<PasskeyInfo>> {
+  try {
+    const optRes = await apiFetch("/api/auth/passkeys/register/options", {
+      method: "POST",
+      body: JSON.stringify({ current }),
+    });
+    const { challengeId, options } = (await optRes.json()) as {
+      challengeId: string;
+      options: Parameters<typeof startRegistration>[0]["optionsJSON"];
+    };
+    const response = await startRegistration({ optionsJSON: options });
+    const res = await apiFetch("/api/auth/passkeys/register", {
+      method: "POST",
+      body: JSON.stringify({ challengeId, response }),
+    });
+    return { ok: true, data: ((await res.json()) as { passkey: PasskeyInfo }).passkey };
+  } catch (e) {
+    return describeWebAuthnError(e);
+  }
+}
+
+/** Buka kunci dengan passkey. Sukses = cookie sesi sudah diset server. */
+export async function unlockWithPasskey(): Promise<PasskeyResult<null>> {
+  try {
+    const optRes = await apiFetch("/api/auth/passkeys/login/options", { method: "POST" });
+    const { challengeId, options } = (await optRes.json()) as {
+      challengeId: string;
+      options: Parameters<typeof startAuthentication>[0]["optionsJSON"];
+    };
+    const response = await startAuthentication({ optionsJSON: options });
+    await apiFetch("/api/auth/passkeys/login", {
+      method: "POST",
+      body: JSON.stringify({ challengeId, response }),
+    });
+    return { ok: true, data: null };
+  } catch (e) {
+    return describeWebAuthnError(e);
+  }
+}
+
+export async function renamePasskey(id: string, name: string): Promise<PasskeyInfo> {
+  const res = await apiFetch(`/api/auth/passkeys/${encodeURIComponent(id)}`, {
+    method: "PATCH",
+    body: JSON.stringify({ name }),
+  });
+  return ((await res.json()) as { passkey: PasskeyInfo }).passkey;
+}
+
+export async function removePasskey(id: string): Promise<void> {
+  await apiFetch(`/api/auth/passkeys/${encodeURIComponent(id)}`, { method: "DELETE" });
+}

package/src/lib/pending-prompt.ts

@@ -0,0 +1,53 @@
+/**
+ * Prompt pertama yang diketik di homepage, dititipkan sampai Session
+ * barunya ter-attach di Session view (`useSessionChat`) lalu dikirim sekali.
+ *
+ * Disimpan di `sessionStorage` (per tab) sehingga tetap aman walau halaman
+ * Session dimuat ulang sebelum koneksi WS siap; `take` menghapusnya agar
+ * prompt tidak terkirim dua kali.
+ */
+
+const KEY_PREFIX = "kcg-pending-prompt:";
+
+/** Storage minimal — diinjeksi saat test (default `sessionStorage`). */
+export interface PendingStore {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+function defaultStore(): PendingStore | null {
+  return typeof sessionStorage === "undefined" ? null : sessionStorage;
+}
+
+export function setPendingPrompt(
+  sessionId: string,
+  text: string,
+  store: PendingStore | null = defaultStore(),
+): void {
+  const trimmed = text.trim();
+  if (store === null || trimmed === "") return;
+  store.setItem(KEY_PREFIX + sessionId, trimmed);
+}
+
+/** Baca prompt tertunda tanpa menghapusnya (untuk pesan optimistis di UI). */
+export function peekPendingPrompt(
+  sessionId: string,
+  store: PendingStore | null = defaultStore(),
+): string | null {
+  if (store === null) return null;
+  const value = store.getItem(KEY_PREFIX + sessionId);
+  return value !== null && value.trim() !== "" ? value : null;
+}
+
+/** Ambil sekaligus hapus prompt tertunda; null bila tidak ada. */
+export function takePendingPrompt(
+  sessionId: string,
+  store: PendingStore | null = defaultStore(),
+): string | null {
+  if (store === null) return null;
+  const key = KEY_PREFIX + sessionId;
+  const value = store.getItem(key);
+  if (value !== null) store.removeItem(key);
+  return value !== null && value.trim() !== "" ? value : null;
+}

package/src/lib/permission-info.ts

@@ -0,0 +1,101 @@
+/**
+ * Penjelasan izin tool untuk manusia — logika murni (tanpa DOM, diuji).
+ *
+ * Server menyimpan judul permission sebagai satu string ringkas hasil
+ * `describePermission`: `"<permission> — `pola1` — `pola2`"` (mis.
+ * ``external_directory — `/home/u/.config/opencode/*` ``). String itu
+ * akurat tapi tidak ramah: nama permission internal opencode + pola glob
+ * mentah. Helper ini memecahnya menjadi:
+ * - `label`  : kalimat singkat apa yang diminta agent ("Access a folder
+ *              outside the project").
+ * - `targets`: pola yang terdampak, tanpa backtick.
+ * - `risk`   : seberapa hati-hati pengguna perlu (menentukan warna kartu).
+ *
+ * Daftar permission mengikuti skema `PermissionConfig` opencode. Permission
+ * yang tidak dikenal (versi opencode lebih baru) tetap tampil dengan nama
+ * aslinya — tidak pernah disembunyikan.
+ */
+
+export type PermissionRisk = "low" | "medium" | "high";
+
+export interface PermissionInfo {
+  /** Nama permission opencode apa adanya (mis. `external_directory`). */
+  permission: string | null;
+  /** Kalimat ramah tentang apa yang diminta. */
+  label: string;
+  /** Pola/path/perintah yang terdampak (tanpa backtick). */
+  targets: string[];
+  risk: PermissionRisk;
+}
+
+interface PermissionMeta {
+  label: string;
+  risk: PermissionRisk;
+}
+
+/**
+ * Permission opencode -> label & risiko.
+ * - high   : bisa mengubah sistem / keluar dari batas project.
+ * - medium : mengubah file project / menjalankan agent lain / akses jaringan.
+ * - low    : hanya membaca.
+ */
+const PERMISSIONS: Record<string, PermissionMeta> = {
+  bash: { label: "Run a shell command", risk: "high" },
+  external_directory: { label: "Access a folder outside the project", risk: "high" },
+  doom_loop: { label: "Keep going after repeating the same step", risk: "medium" },
+  edit: { label: "Edit files", risk: "medium" },
+  task: { label: "Start a sub-agent", risk: "medium" },
+  webfetch: { label: "Fetch a web page", risk: "medium" },
+  websearch: { label: "Search the web", risk: "medium" },
+  skill: { label: "Use a skill", risk: "medium" },
+  read: { label: "Read files", risk: "low" },
+  list: { label: "List folder contents", risk: "low" },
+  glob: { label: "Search for files", risk: "low" },
+  grep: { label: "Search inside files", risk: "low" },
+  lsp: { label: "Use the language server", risk: "low" },
+  todowrite: { label: "Update the task list", risk: "low" },
+  question: { label: "Ask you a question", risk: "low" },
+};
+
+/** Judul fallback server saat event tidak membawa nama permission. */
+const FALLBACK_TITLES = new Set(["Izin tool", "Tool permission"]);
+
+/** Ubah `snake_case` menjadi kalimat ("external_directory" -> "External directory"). */
+function humanize(name: string): string {
+  const spaced = name.replace(/[_-]+/g, " ").trim();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+/**
+ * Pecah judul permission server menjadi info yang bisa dibaca manusia.
+ * Format masukan: `"<permission>"`, `"<permission> — `a` — `b`"`, atau
+ * judul fallback / null.
+ */
+export function parsePermissionTitle(title: string | null): PermissionInfo {
+  const raw = (title ?? "").trim();
+  if (raw === "" || FALLBACK_TITLES.has(raw)) {
+    return { permission: null, label: "Use a tool", targets: [], risk: "medium" };
+  }
+
+  const [head = "", ...rest] = raw.split(" — ");
+  const permission = head.trim();
+  // Pola dibungkus backtick oleh server; buang backtick-nya. Bagian tanpa
+  // backtick tetap diterima (format lama / pihak lain).
+  const targets = rest
+    .map((part) =>
+      part
+        .trim()
+        .replace(/^`(.*)`$/s, "$1")
+        .trim(),
+    )
+    .filter((t) => t !== "");
+
+  const meta = PERMISSIONS[permission.toLowerCase()];
+  return {
+    permission,
+    label: meta?.label ?? humanize(permission),
+    targets,
+    // Permission tak dikenal: anggap sedang — jangan meremehkan risikonya.
+    risk: meta?.risk ?? "medium",
+  };
+}

package/src/lib/project-extensions.ts

@@ -0,0 +1,136 @@
+/**
+ * Helper tampilan panel samping halaman Project (MCP & skill) — logika murni
+ * tanpa DOM, dipisah agar dapat diuji `bun test`.
+ */
+import { AGENT_TYPES } from "@/lib/agent-types";
+import type {
+  McpServerInfo,
+  McpStatus,
+  SkillInfo,
+  SkillSource,
+} from "@/server/services/opencode-client";
+import type { AgentType } from "@/types";
+
+/** Label status MCP untuk UI. */
+export const MCP_STATUS_LABEL: Record<McpStatus, string> = {
+  connected: "Connected",
+  disabled: "Disabled",
+  failed: "Failed",
+  needs_auth: "Needs auth",
+  needs_client_registration: "Needs registration",
+  unknown: "Unknown",
+};
+
+/** Warna titik status MCP (sepadan dengan titik status Session). */
+export const MCP_STATUS_DOT: Record<McpStatus, string> = {
+  connected: "bg-emerald-500",
+  disabled: "bg-muted-foreground/40",
+  failed: "bg-destructive",
+  needs_auth: "bg-amber-500",
+  needs_client_registration: "bg-amber-500",
+  unknown: "bg-muted-foreground/40",
+};
+
+/** Ringkasan singkat untuk header seksi MCP ("2 of 3 connected"). */
+export function describeMcpSummary(servers: readonly McpServerInfo[]): string {
+  if (servers.length === 0) return "None configured";
+  const connected = servers.filter((s) => s.status === "connected").length;
+  return `${connected} of ${servers.length} connected`;
+}
+
+/** Urutan perhatian status MCP: yang bermasalah lebih dulu. */
+const MCP_ATTENTION: Record<McpStatus, number> = {
+  failed: 0,
+  needs_auth: 1,
+  needs_client_registration: 1,
+  connected: 2,
+  unknown: 3,
+  disabled: 4,
+};
+
+/** Satu MCP server (per nama) beserta statusnya di tiap agent yang memakainya. */
+export interface McpServerEntry {
+  name: string;
+  /** Status per agent; hanya agent yang mengonfigurasi server ini. */
+  byAgent: Partial<Record<AgentType, McpServerInfo>>;
+  /** Agent pemakai, urut `AGENT_TYPES`. */
+  agents: AgentType[];
+  /** Status paling butuh perhatian di antara agent (untuk ikon & urutan). */
+  status: McpStatus;
+}
+
+/**
+ * Gabungkan daftar MCP per agent menjadi satu daftar per nama server,
+ * terurut: bermasalah dulu, lalu nama. Murni — diuji.
+ */
+export function mergeMcpServers(
+  byAgent: Partial<Record<AgentType, readonly McpServerInfo[]>>,
+): McpServerEntry[] {
+  const merged = new Map<string, McpServerEntry>();
+  for (const agent of AGENT_TYPES) {
+    for (const server of byAgent[agent] ?? []) {
+      const entry = merged.get(server.name) ?? {
+        name: server.name,
+        byAgent: {},
+        agents: [],
+        status: server.status,
+      };
+      entry.byAgent[agent] = server;
+      entry.agents.push(agent);
+      if (MCP_ATTENTION[server.status] < MCP_ATTENTION[entry.status]) entry.status = server.status;
+      merged.set(server.name, entry);
+    }
+  }
+  return [...merged.values()].sort(
+    (a, b) => MCP_ATTENTION[a.status] - MCP_ATTENTION[b.status] || a.name.localeCompare(b.name),
+  );
+}
+
+/**
+ * Ringkasan header seksi MCP gabungan: berapa server yang tersambung di
+ * setidaknya satu agent ("1 of 2 connected").
+ */
+export function describeMcpEntries(entries: readonly McpServerEntry[]): string {
+  if (entries.length === 0) return "None configured";
+  const connected = entries.filter((e) =>
+    Object.values(e.byAgent).some((s) => s?.status === "connected"),
+  ).length;
+  return `${connected} of ${entries.length} connected`;
+}
+
+/** Label asal skill. */
+export const SKILL_SOURCE_LABEL: Record<SkillSource, string> = {
+  project: "This project",
+  global: "Global",
+  builtin: "Built-in",
+};
+
+export interface SkillGroup<T extends SkillInfo = SkillInfo> {
+  source: SkillSource;
+  label: string;
+  skills: T[];
+}
+
+/**
+ * Kelompokkan skill per asal: Project dulu (paling relevan), lalu global,
+ * lalu bawaan. Kelompok kosong dibuang; urutan dalam kelompok dipertahankan.
+ */
+export function groupSkills<T extends SkillInfo>(skills: readonly T[]): SkillGroup<T>[] {
+  const order: SkillSource[] = ["project", "global", "builtin"];
+  return order
+    .map((source) => ({
+      source,
+      label: SKILL_SOURCE_LABEL[source],
+      skills: skills.filter((s) => s.source === source),
+    }))
+    .filter((g) => g.skills.length > 0);
+}
+
+/** Filter skill berdasarkan kata kunci (nama atau deskripsi, case-insensitive). */
+export function filterSkills<T extends SkillInfo>(skills: readonly T[], query: string): T[] {
+  const q = query.trim().toLowerCase();
+  if (q === "") return [...skills];
+  return skills.filter(
+    (s) => s.name.toLowerCase().includes(q) || (s.description ?? "").toLowerCase().includes(q),
+  );
+}

package/src/lib/project-overview.ts

@@ -0,0 +1,123 @@
+/**
+ * Ringkasan Project untuk homepage — logika murni (tanpa DOM / fetch).
+ *
+ * Homepage (`pages/projects/ProjectsPage.tsx`) menggabungkan `GET /api/projects`
+ * dengan `GET /api/sessions` agar setiap Project bisa langsung "dilanjutkan":
+ * jumlah Session, Session yang sedang berjalan, dan Session terakhir yang
+ * disentuh. Dipisah ke `lib/` supaya bisa diuji `bun test` (pola yang sama
+ * dengan `lib/routes.ts`).
+ */
+
+import type { Project, Session } from "@/types";
+
+/** Project + agregat Session miliknya, siap dirender di daftar homepage. */
+export interface ProjectOverview {
+  project: Project;
+  /** Jumlah Session milik Project ini. */
+  sessionCount: number;
+  /** Jumlah Session berstatus `running`. */
+  runningCount: number;
+  /**
+   * Session yang paling baru diperbarui (`updatedAt` terbesar) — target tombol
+   * "Lanjutkan"; `null` bila Project belum punya Session.
+   */
+  lastSession: Session | null;
+  /**
+   * Hingga `RECENT_SESSION_LIMIT` Session terbaru (`updatedAt` menurun) —
+   * daftar "lanjutkan" di bawah composer homepage.
+   */
+  recentSessions: Session[];
+  /**
+   * Waktu aktivitas terakhir: `updatedAt` Session terbaru, atau `createdAt`
+   * Project bila belum ada Session. Dipakai untuk urutan daftar.
+   */
+  lastActivityAt: number;
+}
+
+/** Jumlah Session terbaru yang dibawa tiap `ProjectOverview`. */
+export const RECENT_SESSION_LIMIT = 3;
+
+/**
+ * Gabungkan Project dengan Session-nya, terurut dari aktivitas terbaru.
+ * Session dengan `projectId` yang tidak dikenal diabaikan.
+ */
+export function buildProjectOverviews(
+  projects: readonly Project[],
+  sessions: readonly Session[],
+): ProjectOverview[] {
+  const byProject = new Map<string, Session[]>();
+  for (const session of sessions) {
+    const bucket = byProject.get(session.projectId);
+    if (bucket === undefined) byProject.set(session.projectId, [session]);
+    else bucket.push(session);
+  }
+
+  const overviews = projects.map((project) => {
+    const own = byProject.get(project.id) ?? [];
+    const runningCount = own.filter((s) => s.status === "running").length;
+    const recentSessions = [...own]
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, RECENT_SESSION_LIMIT);
+    const lastSession = recentSessions[0] ?? null;
+    return {
+      project,
+      sessionCount: own.length,
+      runningCount,
+      lastSession,
+      recentSessions,
+      lastActivityAt: lastSession?.updatedAt ?? project.createdAt,
+    };
+  });
+
+  // Aktivitas terbaru di atas; nama (case-insensitive) sebagai tie-break agar
+  // urutan stabil dan tidak berubah-ubah antar refresh.
+  return overviews.sort((a, b) => {
+    if (b.lastActivityAt !== a.lastActivityAt) return b.lastActivityAt - a.lastActivityAt;
+    return a.project.name.localeCompare(b.project.name, undefined, { sensitivity: "base" });
+  });
+}
+
+/**
+ * Filter daftar berdasarkan kata kunci (cocok pada nama atau path, tanpa
+ * membedakan huruf besar/kecil). Query kosong/whitespace -> daftar utuh.
+ */
+export function filterProjectOverviews(
+  overviews: readonly ProjectOverview[],
+  query: string,
+): ProjectOverview[] {
+  const needle = query.trim().toLowerCase();
+  if (needle === "") return [...overviews];
+  return overviews.filter(
+    ({ project }) =>
+      project.name.toLowerCase().includes(needle) || project.path.toLowerCase().includes(needle),
+  );
+}
+
+/** Total Session yang sedang berjalan di seluruh Project. */
+export function totalRunningSessions(overviews: readonly ProjectOverview[]): number {
+  return overviews.reduce((sum, o) => sum + o.runningCount, 0);
+}
+
+/**
+ * Short relative label for activity time ("just now", "3 hours ago").
+ * `now` diinjeksi agar deterministik saat diuji.
+ */
+export function formatRelativeTime(ts: number, now: number = Date.now()): string {
+  const diff = now - ts;
+  if (diff < 0) return "just now";
+
+  const minute = 60_000;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+
+  if (diff < minute) return "just now";
+  if (diff < hour) return `${Math.floor(diff / minute)} minutes ago`;
+  if (diff < day) return `${Math.floor(diff / hour)} hours ago`;
+  if (diff < 7 * day) return `${Math.floor(diff / day)} days ago`;
+
+  return new Date(ts).toLocaleDateString(undefined, {
+    day: "2-digit",
+    month: "short",
+    year: "numeric",
+  });
+}

package/src/lib/prompts.ts

@@ -0,0 +1,87 @@
+/**
+ * Interactive_Prompt — logika murni (tanpa DOM).
+ *
+ * Dipisah dari `PromptCard.tsx` agar dapat diuji `bun test` (unit test 24.6):
+ * - `getPromptActions`: aksi yang dirender untuk sebuah prompt.
+ * - `groupPrompts`: beberapa permission identik (kind + title sama) menjadi
+ *   SATU kartu (bug kartu nyepam).
+ */
+import type { InteractivePrompt, PromptQuestion, PromptResponse } from "@/types";
+
+export type PromptActionVariant = "default" | "destructive" | "outline";
+
+export interface PromptAction {
+  key: string;
+  label: string;
+  response: PromptResponse;
+  variant: PromptActionVariant;
+  /** Ikon khusus (mis. "shield-check" untuk Always allow). */
+  icon?: "shield-check";
+}
+
+/**
+ * Aksi yang dirender untuk sebuah Interactive_Prompt (murni — diuji di 24.6).
+ * Untuk `confirmation`: Approve, Always allow, Deny, dan Cancel; Cancel
+ * memakai respon yang sama dengan Deny (Requirement 8.5).
+ *
+ * Menu MULTI-SELECT tidak memakai aksi per opsi — jawaban dikumpulkan lewat
+ * checkbox lalu dikirim sekaligus `{ options: string[] }` (lihat PromptCard).
+ */
+export function getPromptActions(prompt: InteractivePrompt): PromptAction[] {
+  if (prompt.type === "menu") {
+    return (prompt.options ?? []).map((option) => ({
+      key: `option-${option.label}`,
+      label: option.label,
+      response: { option: option.label },
+      variant: "outline",
+    }));
+  }
+  return [
+    { key: "approve", label: "Approve", response: "approve", variant: "default" },
+    {
+      key: "always",
+      label: "Always allow",
+      response: "always",
+      variant: "outline",
+      icon: "shield-check",
+    },
+    { key: "deny", label: "Deny", response: "deny", variant: "destructive" },
+    // Requirement 8.5: Cancel diperlakukan sebagai respon Deny yang sama.
+    { key: "cancel", label: "Cancel", response: "deny", variant: "outline" },
+  ];
+}
+
+/**
+ * Daftar pertanyaan yang dirender kartu — multi-question memakai field
+ * `questions`; pertanyaan tunggal diwrap dari field legacy.
+ * Murni (diuji tanpa DOM) agar konsisten dengan helper lain di file ini.
+ */
+export function getPromptQuestions(prompt: InteractivePrompt): PromptQuestion[] {
+  if (prompt.questions && prompt.questions.length > 0) return prompt.questions;
+  if (prompt.kind !== "question") return [];
+  return [
+    {
+      question: prompt.title,
+      options: prompt.options ?? null,
+      multiple: prompt.multiple === true ? true : undefined,
+      custom: prompt.custom === true ? true : undefined,
+    },
+  ];
+}
+
+/**
+ * Kelompokkan prompt pending yang identik (kind + title sama) menjadi satu
+ * kartu. Kunci sama dengan sisi server (`permissionGroupKey`) agar kartu yang
+ * dijawab user persis grup yang di-fan-out server. Urutan kemunculan
+ * anggota pertama dipertahankan.
+ */
+export function groupPrompts(prompts: readonly InteractivePrompt[]): InteractivePrompt[][] {
+  const groups = new Map<string, InteractivePrompt[]>();
+  for (const p of prompts) {
+    const key = `${p.kind}\u0000${p.title ?? ""}`;
+    const g = groups.get(key);
+    if (g) g.push(p);
+    else groups.set(key, [p]);
+  }
+  return [...groups.values()];
+}