kcg-code 0.0.0-stage → 0.1.0

package/src/lib/session-summary.ts

@@ -0,0 +1,68 @@
+/**
+ * Ringkasan Session untuk halaman detail Project — logika murni (tanpa DOM /
+ * fetch), dipisah agar dapat diuji `bun test` seperti `lib/routes.ts` dan
+ * `lib/project-overview.ts`.
+ *
+ * Dipakai `components/sessions/SessionList.tsx`: mengurutkan Session sehingga
+ * yang paling relevan untuk dilanjutkan berada di atas, dan menyediakan
+ * ringkasan status untuk header Project.
+ */
+
+import type { Session, SessionStatus } from "@/types";
+
+/** Ringkasan status seluruh Session milik satu Project. */
+export interface SessionSummary {
+  total: number;
+  running: number;
+  stopped: number;
+  crashed: number;
+}
+
+/** Prioritas urutan status: yang berjalan paling relevan untuk dilanjutkan. */
+const STATUS_RANK: Record<SessionStatus, number> = {
+  running: 0,
+  crashed: 1,
+  stopped: 2,
+};
+
+/**
+ * Urutkan Session: `running` lebih dulu, lalu `crashed` (perlu perhatian),
+ * lalu `stopped`; di dalam tiap kelompok yang terakhir diperbarui di atas.
+ * Input tidak dimutasi.
+ */
+export function sortSessions(sessions: readonly Session[]): Session[] {
+  return [...sessions].sort((a, b) => {
+    const rank = STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    if (rank !== 0) return rank;
+    if (b.updatedAt !== a.updatedAt) return b.updatedAt - a.updatedAt;
+    return a.id.localeCompare(b.id);
+  });
+}
+
+/** Hitung jumlah Session per status. */
+export function summarizeSessions(sessions: readonly Session[]): SessionSummary {
+  const summary: SessionSummary = { total: sessions.length, running: 0, stopped: 0, crashed: 0 };
+  for (const s of sessions) {
+    if (s.status === "running") summary.running += 1;
+    else if (s.status === "stopped") summary.stopped += 1;
+    else summary.crashed += 1;
+  }
+  return summary;
+}
+
+/**
+ * Kalimat ringkas status Project untuk header ("2 sessions · 1 running").
+ * Tanpa Session -> teks pengarah, bukan "0 sessions".
+ */
+export function describeSessionSummary(summary: SessionSummary): string {
+  if (summary.total === 0) return "No sessions yet";
+  const parts = [`${summary.total} session${summary.total === 1 ? "" : "s"}`];
+  if (summary.running > 0) parts.push(`${summary.running} running`);
+  if (summary.crashed > 0) parts.push(`${summary.crashed} crashed`);
+  return parts.join(" · ");
+}
+
+/** Label model Session untuk baris daftar. */
+export function describeSessionModel(session: Session): string {
+  return session.model ? session.model.modelID : "default model";
+}

package/src/lib/session-title.ts

@@ -0,0 +1,63 @@
+/**
+ * Helper judul Session — dipakai Client & Server agar placeholder
+ * konsisten diperlakukan sebagai "belum ada judul".
+ *
+ * Alur (sama seperti opencode):
+ * 1. Session dibuat di opencode TANPA judul -> opencode memberi placeholder
+ *    `New session - <ISO>`. Hanya judul berpola itu yang memicu opencode
+ *    meng-generate judul (agent `title`, setelah langkah pertama prompt
+ *    pertama), lalu dikirim lewat SSE `session.updated`.
+ * 2. Sambil menunggu (biasanya beberapa detik), KCG Code menampilkan judul
+ *    sementara dari baris pertama prompt (`deriveSessionTitle`).
+ * 3. Judul hasil opencode selalu menggantikan judul sementara.
+ *
+ * `SESSION_TITLE_PLACEHOLDERS` = judul lama yang dulu dikirim KCG Code saat
+ * membuat Session (opencode tidak pernah meng-generate judul untuk itu).
+ */
+
+export const SESSION_TITLE_PLACEHOLDERS = new Set<string>([
+  "KCG Code Session",
+  "KCG Code Session (resumed)",
+]);
+
+/**
+ * Judul default opencode (`packages/opencode/src/session/session.ts`,
+ * `isDefaultTitle`): `New session - ` / `Child session - ` + ISO timestamp.
+ */
+const OPENCODE_DEFAULT_TITLE =
+  /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+export function isOpencodeDefaultTitle(title: string): boolean {
+  return OPENCODE_DEFAULT_TITLE.test(title.trim());
+}
+
+export function isPlaceholderTitle(title: string | null | undefined): boolean {
+  if (title === null || title === undefined) return true;
+  const t = title.trim();
+  if (t === "") return true;
+  return SESSION_TITLE_PLACEHOLDERS.has(t) || isOpencodeDefaultTitle(t);
+}
+
+/**
+ * Turunkan judul Session dari teks prompt pertama.
+ * Ambil baris pertama, rapikan spasi, potong di batas kata dengan elipsis.
+ * @returns judul siap simpan, atau null bila teks kosong.
+ */
+export function deriveSessionTitle(text: string, maxLength = 50): string | null {
+  const trimmed = text.trim();
+  if (trimmed === "") return null;
+  const firstLine = (trimmed.split("\n")[0] ?? "").trim();
+  const collapsed = firstLine.replace(/\s+/g, " ").trim();
+  if (collapsed === "") return null;
+  if (collapsed.length <= maxLength) return collapsed;
+  const slice = collapsed.slice(0, maxLength);
+  const lastSpace = slice.lastIndexOf(" ");
+  const cut = lastSpace > maxLength * 0.6 ? slice.slice(0, lastSpace) : slice;
+  return `${cut.trim()}…`;
+}
+
+/** Judul untuk ditampilkan di daftar — placeholder difallback ke "New session". */
+export function displaySessionTitle(title: string | null | undefined): string {
+  if (isPlaceholderTitle(title ?? null)) return "New session";
+  return (title as string).trim();
+}

package/src/lib/sidebar-groups.ts

@@ -0,0 +1,78 @@
+/**
+ * Pengelompokan Session per Project untuk sidebar aplikasi — logika murni
+ * (tanpa DOM / fetch), dipisah agar dapat diuji `bun test` seperti
+ * `lib/project-overview.ts` dan `lib/session-summary.ts`.
+ */
+
+import { sortSessions } from "@/lib/session-summary";
+import type { Project, Session } from "@/types";
+
+/** Satu grup sidebar: Project + seluruh Session miliknya (terurut). */
+export interface SidebarProjectGroup {
+  project: Project;
+  /** Running -> crashed -> stopped, terbaru di atas (`sortSessions`). */
+  sessions: Session[];
+  runningCount: number;
+}
+
+/**
+ * Kelompokkan Session per Project. Grup diurutkan dari aktivitas terbaru
+ * (Session `updatedAt` terbesar, atau `createdAt` Project bila kosong);
+ * nama sebagai tie-break agar urutan stabil. Session dengan `projectId`
+ * tak dikenal diabaikan. Input tidak dimutasi.
+ */
+export function groupSessionsByProject(
+  projects: readonly Project[],
+  sessions: readonly Session[],
+): SidebarProjectGroup[] {
+  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 groups = projects.map((project) => {
+    const own = byProject.get(project.id) ?? [];
+    let lastActivity = project.createdAt;
+    let runningCount = 0;
+    for (const s of own) {
+      if (s.status === "running") runningCount += 1;
+      if (s.updatedAt > lastActivity) lastActivity = s.updatedAt;
+    }
+    return { group: { project, sessions: sortSessions(own), runningCount }, lastActivity };
+  });
+
+  return groups
+    .sort((a, b) => {
+      if (b.lastActivity !== a.lastActivity) return b.lastActivity - a.lastActivity;
+      return a.group.project.name.localeCompare(b.group.project.name, undefined, {
+        sensitivity: "base",
+      });
+    })
+    .map((g) => g.group);
+}
+
+/**
+ * Filter grup berdasarkan kata kunci: Project yang namanya cocok tampil
+ * utuh; selain itu hanya Session yang judulnya cocok yang dipertahankan.
+ * Grup tanpa kecocokan dibuang. Query kosong -> grup utuh.
+ */
+export function filterSidebarGroups(
+  groups: readonly SidebarProjectGroup[],
+  query: string,
+  titleOf: (session: Session) => string,
+): SidebarProjectGroup[] {
+  const needle = query.trim().toLowerCase();
+  if (needle === "") return [...groups];
+  const out: SidebarProjectGroup[] = [];
+  for (const group of groups) {
+    if (group.project.name.toLowerCase().includes(needle)) {
+      out.push(group);
+      continue;
+    }
+    const sessions = group.sessions.filter((s) => titleOf(s).toLowerCase().includes(needle));
+    if (sessions.length > 0) out.push({ ...group, sessions });
+  }
+  return out;
+}

package/src/lib/skill-installs.ts

@@ -0,0 +1,360 @@
+/**
+ * Store global job instalasi skill (FE) — sumber data notifikasi instalasi.
+ *
+ * - `startInstall()` memanggil `POST /api/projects/:id/skills/install` (202)
+ *   lalu mem-poll `GET /api/skills/installs/:id?from=<n>` sampai selesai;
+ *   baris log baru ditambahkan bertahap (output "live").
+ * - Store hidup di modul (bukan komponen) sehingga instalasi & notifikasinya
+ *   tetap berjalan saat user pindah halaman atau menutup dialog.
+ * - `hydrateInstalls()` memulihkan notifikasi setelah reload: job berjalan
+ *   DAN job selesai yang belum ditutup (server menyimpannya ~10 menit), lengkap
+ *   dengan log. Status tampilan (disembunyikan / panel output terbuka) disimpan
+ *   di localStorage sehingga kembali persis seperti sebelum refresh.
+ * - Selesai sukses -> `onInstallFinished` (mis. halaman Skills memuat ulang
+ *   daftar terpasang).
+ * - Sukses tapi belum aktif (`refreshed: false`, ada chat berjalan) -> polling
+ *   pelan berlanjut sampai server mengaktifkannya otomatis setelah chat selesai.
+ *
+ * `useSyncExternalStore` membaca snapshot; setiap perubahan membuat objek
+ * baru (immutable) agar React me-render ulang.
+ */
+import { useSyncExternalStore } from "react";
+import { ApiError, apiFetch } from "@/lib/api";
+import type { InstallJob, InstallJobLog } from "@/server/services/skill-install-jobs";
+
+/** Interval polling saat job berjalan. */
+const POLL_MS = 700;
+/**
+ * Interval polling job sukses yang skill-nya belum aktif (menunggu chat di
+ * Project selesai lalu agent memuat ulang skill otomatis).
+ */
+const PENDING_ACTIVATION_POLL_MS = 3000;
+/** Berhenti menunggu aktivasi setelah selama ini (chat sangat panjang). */
+const PENDING_ACTIVATION_MAX_MS = 30 * 60_000;
+/** Batas baris log yang disimpan di client (server juga membatasi). */
+const MAX_CLIENT_LINES = 500;
+
+export interface InstallEntry {
+  job: InstallJob;
+  lines: string[];
+  /** Indeks absolut baris berikutnya yang diminta ke server. */
+  next: number;
+  /** Sebagian baris awal sudah terbuang di server. */
+  truncated: boolean;
+  /** User menyembunyikan notifikasi ini. */
+  dismissed: boolean;
+  /** Panel log dibuka. */
+  expanded: boolean;
+  /** Pesan error jaringan saat polling (job mungkin tetap berjalan). */
+  pollError: string | null;
+  /** Permintaan pembatalan sudah dikirim (menunggu proses berhenti). */
+  cancelling: boolean;
+}
+
+type Listener = () => void;
+
+let entries: InstallEntry[] = [];
+const listeners = new Set<Listener>();
+const finishListeners = new Set<(job: InstallJob) => void>();
+const polling = new Set<string>();
+
+function emit(): void {
+  for (const l of listeners) l();
+}
+
+function update(jobId: string, fn: (e: InstallEntry) => InstallEntry): void {
+  let changed = false;
+  entries = entries.map((e) => {
+    if (e.job.id !== jobId) return e;
+    changed = true;
+    return fn(e);
+  });
+  if (changed) emit();
+}
+
+function upsert(entry: InstallEntry): void {
+  const exists = entries.some((e) => e.job.id === entry.job.id);
+  entries = exists
+    ? entries.map((e) => (e.job.id === entry.job.id ? entry : e))
+    : [entry, ...entries];
+  emit();
+}
+
+function newEntry(job: InstallJob, expanded: boolean, dismissed = false): InstallEntry {
+  return {
+    job,
+    lines: [],
+    next: 0,
+    truncated: false,
+    dismissed,
+    expanded,
+    pollError: null,
+    cancelling: false,
+  };
+}
+
+// ------------------------------------------------ status tampilan (persist) ----
+
+const UI_STATE_KEY = "kcg-skill-installs-ui";
+
+/** Status tampilan per job yang bertahan melewati refresh. */
+export interface InstallUiState {
+  /** Job yang notifikasinya disembunyikan / ditutup user. */
+  dismissed: string[];
+  /** Job yang panel output-nya terbuka. */
+  expanded: string[];
+}
+
+function readUiState(): InstallUiState {
+  try {
+    const raw = localStorage.getItem(UI_STATE_KEY);
+    if (!raw) return { dismissed: [], expanded: [] };
+    const v = JSON.parse(raw) as Partial<InstallUiState>;
+    const ids = (x: unknown) => (Array.isArray(x) ? x.filter((i) => typeof i === "string") : []);
+    return { dismissed: ids(v.dismissed), expanded: ids(v.expanded) };
+  } catch {
+    return { dismissed: [], expanded: [] };
+  }
+}
+
+/** Job selesai yang ditutup tidak ada lagi di `entries`; ingat id-nya di sini. */
+let closedIds = new Set<string>(readUiState().dismissed);
+
+function saveUiState(): void {
+  const state: InstallUiState = {
+    dismissed: [
+      ...new Set([...closedIds, ...entries.filter((e) => e.dismissed).map((e) => e.job.id)]),
+    ],
+    expanded: entries.filter((e) => e.expanded).map((e) => e.job.id),
+  };
+  try {
+    localStorage.setItem(UI_STATE_KEY, JSON.stringify(state));
+  } catch {
+    // Storage tidak tersedia (mode privat) — status hanya di memori.
+  }
+}
+
+/**
+ * Entry yang dipulihkan dari daftar job server (murni — diuji). Job berjalan
+ * selalu dipulihkan (walau disembunyikan, agar kartu tetap tahu statusnya);
+ * job selesai hanya bila belum ditutup. Urutan: terbaru dulu.
+ */
+export function hydrationEntries(
+  jobs: readonly InstallJob[],
+  ui: InstallUiState,
+  existingIds: ReadonlySet<string>,
+): InstallEntry[] {
+  const dismissed = new Set(ui.dismissed);
+  const expanded = new Set(ui.expanded);
+  return jobs
+    .filter((job) => !existingIds.has(job.id))
+    .filter((job) => job.status === "running" || !dismissed.has(job.id))
+    .map((job) => newEntry(job, expanded.has(job.id), dismissed.has(job.id)));
+}
+
+/** Gabungkan potongan log baru ke entry (murni — diuji). */
+export function mergeLog(entry: InstallEntry, log: InstallJobLog): InstallEntry {
+  // Hanya ambil baris yang belum kita punya (polling bisa tumpang tindih).
+  const skip = Math.max(0, entry.next - log.from);
+  const fresh = log.lines.slice(skip);
+  let lines = fresh.length > 0 ? [...entry.lines, ...fresh] : entry.lines;
+  let truncated = entry.truncated || log.truncated;
+  if (lines.length > MAX_CLIENT_LINES) {
+    lines = lines.slice(lines.length - MAX_CLIENT_LINES);
+    truncated = true;
+  }
+  return {
+    ...entry,
+    job: log.job,
+    lines,
+    next: Math.max(entry.next, log.from + log.lines.length),
+    truncated,
+    pollError: null,
+  };
+}
+
+async function poll(jobId: string): Promise<void> {
+  if (polling.has(jobId)) return;
+  polling.add(jobId);
+  try {
+    for (;;) {
+      const cur = entries.find((e) => e.job.id === jobId);
+      if (!cur) return;
+      try {
+        const res = await apiFetch(`/api/skills/installs/${jobId}?from=${cur.next}`);
+        const log = (await res.json()) as InstallJobLog;
+        const wasRunning = cur.job.status === "running";
+        update(jobId, (e) => mergeLog(e, log));
+        if (log.job.status !== "running") {
+          if (wasRunning) for (const l of finishListeners) l(log.job);
+          // Terpasang tapi belum aktif (ada chat berjalan) -> terus pantau
+          // pelan sampai server menandai aktif, agar notifikasi ikut berubah.
+          const waiting =
+            log.job.status === "succeeded" &&
+            log.job.refreshed === false &&
+            Date.now() - (log.job.finishedAt ?? Date.now()) < PENDING_ACTIVATION_MAX_MS;
+          if (!waiting) return;
+          await new Promise((r) => setTimeout(r, PENDING_ACTIVATION_POLL_MS));
+          continue;
+        }
+      } catch (e) {
+        if (e instanceof ApiError && e.status === 404) {
+          // Job sudah sukses (sedang menunggu aktivasi) lalu kedaluwarsa /
+          // server restart: skill tetap terpasang — jangan ubah jadi gagal.
+          // Restart server juga memuat ulang skill, jadi anggap aktif.
+          if (cur.job.status === "succeeded") {
+            update(jobId, (en) => ({ ...en, job: { ...en.job, refreshed: true } }));
+            return;
+          }
+          // Server restart saat instalasi berjalan: job hilang bersama prosesnya.
+          update(jobId, (en) => ({
+            ...en,
+            job: { ...en.job, status: "failed", error: "INSTALL_JOB_LOST", finishedAt: Date.now() },
+            pollError: null,
+          }));
+          return;
+        }
+        update(jobId, (en) => ({ ...en, pollError: "Connection lost — retrying…" }));
+      }
+      await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+  } finally {
+    polling.delete(jobId);
+  }
+}
+
+/**
+ * Mulai instalasi. Melempar `ApiError` bila server menolak sebelum job dibuat
+ * (validasi, Project tak dikenal, instalasi lain sedang berjalan).
+ */
+export async function startInstall(
+  projectId: string,
+  source: string,
+  skill: string,
+): Promise<InstallJob> {
+  const res = await apiFetch(`/api/projects/${projectId}/skills/install`, {
+    method: "POST",
+    body: JSON.stringify({ source, skill }),
+  });
+  const { job } = (await res.json()) as { job: InstallJob };
+  upsert(newEntry(job, true));
+  saveUiState();
+  void poll(job.id);
+  return job;
+}
+
+let hydrated = false;
+
+/**
+ * Pulihkan notifikasi setelah reload (sekali per muat halaman): job berjalan
+ * + job selesai yang belum ditutup, beserta status tampilannya. Log diambil
+ * ulang dari awal; job selesai cukup satu kali ambil.
+ */
+export async function hydrateInstalls(): Promise<void> {
+  if (hydrated) return;
+  hydrated = true;
+  try {
+    const res = await apiFetch("/api/skills/installs");
+    const { jobs } = (await res.json()) as { jobs: InstallJob[] };
+    const ui = readUiState();
+    const restored = hydrationEntries(jobs, ui, new Set(entries.map((e) => e.job.id)));
+    // Id yang tidak dikenal server lagi (kedaluwarsa) dibuang dari storage.
+    const known = new Set(jobs.map((j) => j.id));
+    closedIds = new Set(ui.dismissed.filter((id) => known.has(id)));
+    if (restored.length > 0) {
+      entries = [...entries, ...restored];
+      emit();
+    }
+    saveUiState();
+    for (const e of restored) void poll(e.job.id);
+  } catch {
+    hydrated = false; // coba lagi di kesempatan berikutnya
+  }
+}
+
+export function dismissInstall(jobId: string): void {
+  update(jobId, (e) => ({ ...e, dismissed: true }));
+  // Job selesai yang ditutup tidak perlu disimpan lagi — cukup ingat id-nya
+  // agar tidak muncul kembali setelah refresh.
+  const e = entries.find((x) => x.job.id === jobId);
+  if (e && e.job.status !== "running") {
+    closedIds.add(jobId);
+    entries = entries.filter((x) => x.job.id !== jobId);
+    emit();
+  }
+  saveUiState();
+}
+
+/** Minta server membatalkan job; status akhir datang lewat polling. */
+export async function cancelInstall(jobId: string): Promise<void> {
+  update(jobId, (e) => ({ ...e, cancelling: true, expanded: true }));
+  saveUiState();
+  try {
+    await apiFetch(`/api/skills/installs/${jobId}/cancel`, { method: "POST" });
+  } catch (e) {
+    // 409 = sudah selesai duluan; biarkan polling membawa status akhirnya.
+    if (!(e instanceof ApiError && e.status === 409)) {
+      update(jobId, (en) => ({
+        ...en,
+        cancelling: false,
+        pollError: "Couldn't cancel — try again.",
+      }));
+    }
+  }
+}
+
+export function toggleInstallLog(jobId: string): void {
+  update(jobId, (e) => ({ ...e, expanded: !e.expanded }));
+  saveUiState();
+}
+
+/** Tampilkan lagi notifikasi job (mis. klik "Installing…" pada kartu). */
+export function revealInstall(jobId: string): void {
+  closedIds.delete(jobId);
+  update(jobId, (e) => ({ ...e, dismissed: false, expanded: true }));
+  saveUiState();
+}
+
+/** Berlangganan event "job selesai"; mengembalikan fungsi berhenti. */
+export function onInstallFinished(cb: (job: InstallJob) => void): () => void {
+  finishListeners.add(cb);
+  return () => finishListeners.delete(cb);
+}
+
+function subscribe(l: Listener): () => void {
+  listeners.add(l);
+  return () => listeners.delete(l);
+}
+
+function snapshot(): InstallEntry[] {
+  return entries;
+}
+
+export function useInstalls(): InstallEntry[] {
+  return useSyncExternalStore(subscribe, snapshot, snapshot);
+}
+
+/** Job berjalan untuk Project + skill tertentu (untuk status tombol kartu). */
+export function findRunningInstall(
+  list: readonly InstallEntry[],
+  projectId: string,
+  source: string,
+  skillId: string,
+): InstallEntry | undefined {
+  return list.find(
+    (e) =>
+      e.job.status === "running" &&
+      e.job.projectId === projectId &&
+      e.job.source === source &&
+      e.job.skillId === skillId,
+  );
+}
+
+/** Hanya untuk test: kosongkan store. */
+export function __resetInstallsForTest(): void {
+  entries = [];
+  closedIds = new Set();
+  hydrated = false;
+  polling.clear();
+  emit();
+}

package/src/lib/skills-catalog.ts

@@ -0,0 +1,99 @@
+/**
+ * Helper tampilan katalog skill (skills.sh) di halaman Skills — logika murni
+ * tanpa DOM, dipisah agar dapat diuji `bun test`.
+ */
+import type { SkillInfo } from "@/server/services/opencode-client";
+import type { AuditStatus, RegistrySkill } from "@/server/services/skills-registry";
+import type { Project } from "@/types";
+
+/** Kunci localStorage Project terakhir yang dipilih di halaman Skills. */
+export const LAST_SKILLS_PROJECT_KEY = "kcg-skills-project";
+
+/** Saran kata kunci saat kolom cari masih kosong (tab Browse). */
+export const SEARCH_SUGGESTIONS = [
+  "react",
+  "nextjs",
+  "testing",
+  "typescript",
+  "python",
+  "design",
+  "docs",
+  "git",
+] as const;
+
+/**
+ * Project terpilih di halaman Skills: `?project=` (dari sidebar) menang, lalu
+ * pilihan terakhir yang diingat, lalu satu-satunya Project bila hanya ada
+ * satu. Id yang tidak dikenal (Project terhapus) dilewati.
+ */
+export function resolveSkillsProject(
+  projects: readonly Project[],
+  urlId: string | null,
+  storedId: string | null,
+): Project | null {
+  for (const id of [urlId, storedId]) {
+    if (id === null) continue;
+    const hit = projects.find((p) => p.id === id);
+    if (hit) return hit;
+  }
+  return projects.length === 1 ? (projects[0] ?? null) : null;
+}
+
+/** Owner GitHub dari `owner/repo`; `null` untuk sumber well-known (domain). */
+export function githubOwner(source: string): string | null {
+  const [owner, repo, ...rest] = source.split("/");
+  if (!owner || !repo || rest.length > 0) return null;
+  return owner;
+}
+
+/**
+ * Skill terpasang yang relevan untuk halaman Skills: tanpa bawaan opencode,
+ * Project dulu lalu global, difilter kata kunci (nama / deskripsi).
+ */
+export function visibleInstalledSkills(skills: readonly SkillInfo[], query: string): SkillInfo[] {
+  const q = query.trim().toLowerCase();
+  const match = (s: SkillInfo) =>
+    q === "" || s.name.toLowerCase().includes(q) || (s.description ?? "").toLowerCase().includes(q);
+  return [
+    ...skills.filter((s) => s.source === "project" && match(s)),
+    ...skills.filter((s) => s.source === "global" && match(s)),
+  ];
+}
+
+/** Jumlah install ringkas: 950, 1.2K, 752K, 1.3M. */
+export function formatInstalls(n: number): string {
+  if (n < 1000) return String(n);
+  const fmt = (v: number, unit: string) => {
+    const s = v >= 100 ? Math.round(v).toString() : v.toFixed(1).replace(/\.0$/, "");
+    return `${s}${unit}`;
+  };
+  if (n < 1_000_000) return fmt(n / 1000, "K");
+  return fmt(n / 1_000_000, "M");
+}
+
+/**
+ * Nama skill yang sudah terpasang di Project (sumber `project`). Skill global
+ * sengaja tidak dihitung: instalasi di halaman ini memasang ke folder Project,
+ * jadi skill global bernama sama tetap boleh dipasang per Project.
+ */
+export function installedProjectSkillNames(skills: readonly SkillInfo[]): Set<string> {
+  return new Set(skills.filter((s) => s.source === "project").map((s) => s.name.toLowerCase()));
+}
+
+/** Apakah skill katalog sudah terpasang di Project (cocokkan nama folder / nama). */
+export function isInstalled(skill: RegistrySkill, installed: ReadonlySet<string>): boolean {
+  return installed.has(skill.skillId.toLowerCase()) || installed.has(skill.name.toLowerCase());
+}
+
+/** Label & gaya ringkasan audit keamanan. */
+export const AUDIT_LABEL: Record<AuditStatus, string> = {
+  pass: "Passed",
+  warn: "Review",
+  fail: "Flagged",
+};
+
+export const AUDIT_BADGE_CLASS: Record<AuditStatus, string> = {
+  pass: "bg-emerald-500/10 text-emerald-700 dark:text-emerald-400",
+  warn: "bg-amber-500/10 text-amber-700 dark:text-amber-400",
+  fail: "bg-destructive/10 text-destructive",
+};

package/src/lib/time.ts

@@ -0,0 +1,22 @@
+/**
+ * Format waktu & durasi untuk label UI (jam footer pesan, durasi thinking).
+ * Logika murni agar mudah diuji tanpa DOM.
+ */
+
+/** Jam lokal `HH:MM:SS` untuk footer pesan. */
+export function formatTime(ts: number): string {
+  return new Date(ts).toLocaleTimeString(undefined, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  });
+}
+
+/** Format durasi ms ke string ringkas: "1s", "12s", "1m 5s". */
+export function formatDuration(ms: number): string {
+  const s = Math.round(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  return rem === 0 ? `${m}m` : `${m}m ${rem}s`;
+}