kcg-code 0.0.0-stage → 0.2.0

package/src/lib/references.ts

@@ -0,0 +1,106 @@
+/**
+ * Daftar "Reference": file project yang DIBACA agent untuk menjawab.
+ *
+ * Diturunkan dari parts pesan yang SUDAH dimiliki timeline (tidak ada request
+ * tambahan): tiap pembacaan file dikumpulkan tanpa duplikat, TERBARU DI ATAS.
+ *
+ * "Terbaru" = pembacaan terakhir, bukan pertama: file yang dibaca lagi naik
+ * kembali ke atas. Jadi bagian atas daftar selalu mencerminkan apa yang
+ * sedang dikerjakan agent saat ini.
+ *
+ * Yang dihitung "dibaca":
+ * - Tool `read` dengan target satu file.
+ * - Referensi `@file` dari pengguna (part `file` TANPA `attachmentId`) — isi
+ *   file itu dibaca untuk menjawab.
+ *
+ * Yang TIDAK dihitung:
+ * - Tool penulis (`write`, `edit`, `patch`, …). Reference menjawab "konteks
+ *   apa yang dipakai agent", bukan "apa yang diubah". File yang dibaca lalu
+ *   diubah tetap muncul — karena ia DIBACA; file yang hanya ditulis tidak.
+ * - `bash`, `grep`, `glob`, `list`, `webfetch`, dll — targetnya pola/perintah,
+ *   bukan satu file.
+ * - Lampiran upload pengguna (part `file` dengan `attachmentId`): sudah tampil
+ *   di bubble pesannya sendiri dan bukan file project.
+ * - Path di luar project, direktori (berakhiran `/`), dan pola glob.
+ */
+import type { MessagePart, SessionMessage } from "@/types";
+import { toolTarget } from "./turns";
+
+/** Tool yang membaca isi satu file. */
+const READ_TOOLS = new Set(["read"]);
+
+export interface FileReference {
+  /** Path relatif terhadap root project. */
+  path: string;
+}
+
+/** Nama file terakhir dari sebuah path (untuk tampilan ringkas). */
+export function baseName(p: string): string {
+  return p.split("/").filter(Boolean).pop() ?? p;
+}
+
+/** Path tampak seperti pola glob / direktori, bukan satu file. */
+function isPatternOrDir(p: string): boolean {
+  return p.endsWith("/") || /[*?{}[\]]/.test(p);
+}
+
+/**
+ * Normalisasi target tool menjadi path relatif project, atau null bila bukan
+ * file project (di luar `cwd`, glob, direktori, kosong).
+ */
+export function toProjectPath(target: string, cwd: string | null): string | null {
+  const raw = target.trim();
+  if (raw === "" || isPatternOrDir(raw)) return null;
+
+  let rel = raw;
+  if (raw.startsWith("/")) {
+    // Absolut: hanya diterima bila berada di dalam worktree project.
+    if (cwd === null || cwd === "") return null;
+    const base = cwd.endsWith("/") ? cwd : `${cwd}/`;
+    if (!raw.startsWith(base)) return null;
+    rel = raw.slice(base.length);
+  }
+  rel = rel.replace(/^\.\//, "");
+  // `..` keluar dari project -> bukan file project.
+  if (rel === "" || rel.startsWith("../")) return null;
+  return rel;
+}
+
+/**
+ * Kumpulkan file yang dibaca di seluruh pesan satu Session, terbaru di atas.
+ * `cwd` dipakai untuk mengubah path absolut menjadi relatif; null -> path
+ * absolut diabaikan.
+ */
+export function collectReferences(
+  messages: readonly SessionMessage[],
+  cwd: string | null = null,
+): FileReference[] {
+  // Map mempertahankan urutan sisip: hapus lalu sisip ulang = pindahkan ke
+  // akhir. Setelah selesai, akhir Map = pembacaan paling baru -> dibalik.
+  const byRecency = new Map<string, FileReference>();
+  for (const message of messages) {
+    for (const part of message.parts) {
+      const path = readPath(part, cwd);
+      if (path === null) continue;
+      byRecency.delete(path);
+      byRecency.set(path, { path });
+    }
+  }
+  return [...byRecency.values()].reverse();
+}
+
+/** Path file project yang DIBACA oleh satu part, atau null. */
+function readPath(part: MessagePart, cwd: string | null): string | null {
+  // Echo `@file` dari pengguna: part `file` tanpa `attachmentId` (lampiran
+  // upload selalu punya `attachmentId` dan bukan file project).
+  if (part.type === "file") {
+    if (typeof part.attachmentId === "string") return null;
+    const name = typeof part.filename === "string" ? part.filename : "";
+    return toProjectPath(name, cwd);
+  }
+  if (part.type !== "tool") return null;
+  const tool = typeof part.tool === "string" ? part.tool.toLowerCase() : "";
+  if (!READ_TOOLS.has(tool)) return null;
+  const target = toolTarget(part);
+  return target === null ? null : toProjectPath(target, cwd);
+}

package/src/lib/routes.ts

@@ -0,0 +1,124 @@
+/**
+ * Route URL KCG Code — logika murni (tanpa DOM / History API).
+ *
+ * Dipisah dari `hooks/useRouter.ts` agar dapat diuji dengan `bun test`
+ * (pola yang sama dengan `useTheme.ts`). Server (`src/server/app.ts`)
+ * menyajikan shell SPA hanya untuk rute halaman yang terdaftar di
+ * `src/index.ts` (lihat `spaPaths`), sehingga React tinggal memetakan
+ * `location.pathname` -> view lewat `parseRoute()`.
+ */
+
+/** Route hasil parsing `location.pathname`. */
+export type AppRoute =
+  | { name: "projects" }
+  | { name: "project"; projectId: string }
+  | { name: "session"; projectId: string; sessionId: string }
+  | { name: "skills" }
+  | {
+      name: "settings";
+      section: SettingsSection;
+      anchor?: string;
+      /**
+       * `/settings` tanpa sub-halaman. Layar lebar: tampil sebagai Profile
+       * (daftar navigasi ada di samping); layar sempit: daftar bagian.
+       */
+      root?: true;
+    }
+  | { name: "not-found" };
+
+/**
+ * Sub-halaman Settings (`/settings/:section`): empat bagian pengaturan +
+ * `about` (tampil terpisah di akhir navigasi, bukan pengaturan).
+ */
+export const SETTINGS_SECTIONS = ["profile", "security", "workspace", "remote", "about"] as const;
+export type SettingsSection = (typeof SETTINGS_SECTIONS)[number];
+
+/**
+ * Alias URL lama -> section + anchor. `devices` kini bagian dari Security
+ * (grup "Signed-in devices"); URL lamanya tetap berfungsi.
+ */
+const SETTINGS_ALIASES: Record<string, { section: SettingsSection; anchor: string }> = {
+  devices: { section: "security", anchor: "devices" },
+};
+
+function isSettingsSection(value: string): value is SettingsSection {
+  return (SETTINGS_SECTIONS as readonly string[]).includes(value);
+}
+
+/** URL daftar Project. */
+export function projectsPath(): string {
+  return "/";
+}
+
+/** URL daftar Session milik sebuah Project. */
+export function projectPath(projectId: string): string {
+  return `/projects/${projectId}`;
+}
+
+/** URL Session view milik sebuah Project. */
+export function sessionPath(projectId: string, sessionId: string): string {
+  return `/projects/${projectId}/sessions/${sessionId}`;
+}
+
+/**
+ * URL halaman Skills. `projectId` (opsional) jadi query `?project=` agar
+ * Project tersebut otomatis terpilih saat halaman dibuka.
+ */
+export function skillsPath(projectId?: string | null): string {
+  return projectId ? `/skills?project=${encodeURIComponent(projectId)}` : "/skills";
+}
+
+/** URL halaman Settings; tanpa `section` = `/settings` (dibuka sebagai Profile). */
+export function settingsPath(section?: SettingsSection): string {
+  return section ? `/settings/${section}` : "/settings";
+}
+
+/** Ambil id Project dari query string halaman Skills (`?project=`). */
+export function parseSkillsProject(search: string): string | null {
+  const id = new URLSearchParams(search).get("project");
+  return id !== null && id.length > 0 ? id : null;
+}
+
+/**
+ * Pemetaan `pathname` -> `AppRoute`. Segment id dianggap opaque — id
+ * Project/Session berupa UUID sehingga aman tanpa decoding. Trailing slash
+ * diabaikan (`/projects/x/` sama dengan `/projects/x`).
+ */
+export function parseRoute(pathname: string): AppRoute {
+  const segments = pathname
+    .replace(/\/+$/, "")
+    .split("/")
+    .filter((segment) => segment.length > 0);
+
+  if (segments.length === 0) return { name: "projects" };
+  if (segments[0] === "skills" && segments.length === 1) return { name: "skills" };
+  if (segments[0] === "settings") {
+    if (segments.length === 1) return { name: "settings", section: "profile", root: true };
+    const section = segments[1];
+    if (segments.length === 2 && section !== undefined && isSettingsSection(section)) {
+      return { name: "settings", section };
+    }
+    // `Object.hasOwn`: hindari kunci prototipe (mis. "/settings/constructor").
+    const alias =
+      segments.length === 2 && section !== undefined && Object.hasOwn(SETTINGS_ALIASES, section)
+        ? SETTINGS_ALIASES[section]
+        : undefined;
+    if (alias) return { name: "settings", section: alias.section, anchor: alias.anchor };
+    return { name: "not-found" };
+  }
+  if (segments[0] !== "projects") return { name: "not-found" };
+
+  const projectId = segments[1];
+  if (projectId === undefined || projectId.length === 0) return { name: "not-found" };
+
+  if (segments.length === 2) return { name: "project", projectId };
+
+  if (segments[2] === "sessions" && segments.length === 4) {
+    const sessionId = segments[3];
+    if (sessionId !== undefined && sessionId.length > 0) {
+      return { name: "session", projectId, sessionId };
+    }
+  }
+
+  return { name: "not-found" };
+}

package/src/lib/session-handoff.ts

@@ -0,0 +1,25 @@
+/**
+ * Serah-terima homepage -> Session view agar perpindahan tanpa jeda:
+ * Session yang baru dibuat (`POST /api/sessions`) dititipkan di memori
+ * sehingga `SessionPage` bisa langsung merender tanpa `GET /api/sessions`
+ * (tidak ada kilatan "Loading…" di tengah animasi).
+ *
+ * Hanya di memori (per tab, per kunjungan): refresh halaman kembali ke jalur
+ * normal (fetch). Dibaca dengan `peek` (aman untuk StrictMode yang memanggil
+ * initializer dua kali) lalu dibersihkan oleh pemakai setelah mount.
+ */
+import type { Session } from "@/types";
+
+const seeded = new Map<string, Session>();
+
+export function seedSession(session: Session): void {
+  seeded.set(session.id, session);
+}
+
+export function peekSeededSession(sessionId: string): Session | null {
+  return seeded.get(sessionId) ?? null;
+}
+
+export function clearSeededSession(sessionId: string): void {
+  seeded.delete(sessionId);
+}

package/src/lib/session-selection.ts

@@ -0,0 +1,40 @@
+/**
+ * Selection mode daftar Session (bulk delete) — logika murni tanpa DOM,
+ * dipisah agar dapat diuji `bun test` (pola `lib/session-summary.ts`).
+ *
+ * Pilihan disimpan sebagai `Set` id; setiap perubahan menghasilkan Set baru
+ * (immutable) agar React me-render ulang.
+ */
+
+/** Tambah / buang satu id dari pilihan. */
+export function toggleSelection(selected: ReadonlySet<string>, id: string): Set<string> {
+  const next = new Set(selected);
+  if (next.has(id)) next.delete(id);
+  else next.add(id);
+  return next;
+}
+
+/**
+ * Buang id yang Session-nya sudah tidak ada (dihapus di tab/perangkat lain).
+ * Mengembalikan Set yang SAMA bila tidak ada yang dibuang, agar pemanggil
+ * bisa menghindari render ulang.
+ */
+export function pruneSelection(
+  selected: ReadonlySet<string>,
+  sessions: readonly { id: string }[],
+): ReadonlySet<string> {
+  const alive = new Set(sessions.map((s) => s.id));
+  const next = new Set([...selected].filter((id) => alive.has(id)));
+  return next.size === selected.size ? selected : next;
+}
+
+/** Deskripsi grup saat selection mode ("3 of 7 selected"). */
+export function describeSelection(count: number, total: number): string {
+  if (count === 0) return "Tap sessions to select them";
+  return `${count} of ${total} selected`;
+}
+
+/** "1 session" / "3 sessions". */
+export function pluralSessions(count: number): string {
+  return `${count} session${count === 1 ? "" : "s"}`;
+}

package/src/lib/session-status.ts

@@ -0,0 +1,45 @@
+/**
+ * Pemetaan status Session & koneksi WS ke label/visual UI (murni, tanpa DOM).
+ *
+ * Dipakai header chat (`SessionHeader`) dan daftar Session (`SessionList`),
+ * agar warna titik & teks status tidak didefinisikan ganda.
+ */
+import type { WsConnectionStatus } from "@/hooks/useWebSocket";
+import type { SessionStatus } from "@/types";
+
+/** Warna titik status Session (sepadan di header chat & baris daftar). */
+export const SESSION_STATUS_DOT: Record<SessionStatus, string> = {
+  running: "bg-emerald-500",
+  stopped: "bg-muted-foreground/50",
+  crashed: "bg-destructive",
+};
+
+/** Label teks status Session (dipakai badge di daftar Session). */
+export const SESSION_STATUS_LABEL: Record<SessionStatus, string> = {
+  running: "Running",
+  stopped: "Stopped",
+  crashed: "Crashed",
+};
+
+/** Variant Badge shadcn untuk sebuah status Session. */
+export function sessionStatusVariant(
+  status: SessionStatus,
+): "default" | "secondary" | "destructive" {
+  if (status === "running") return "default";
+  if (status === "crashed") return "destructive";
+  return "secondary";
+}
+
+/** Label status koneksi WS untuk UI (mis. subtitle header chat). */
+export function wsStatusLabel(status: WsConnectionStatus): string {
+  switch (status) {
+    case "connected":
+      return "connected";
+    case "connecting":
+      return "connecting…";
+    case "reconnecting":
+      return "reconnecting…";
+    default:
+      return "disconnected";
+  }
+}

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;
+}