kcg-code 0.0.0-stage → 0.1.0

package/src/lib/__tests__/home-chat.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Unit test headline acak homepage (lib/headlines.ts) dan prompt tertunda
+ * (lib/pending-prompt.ts) — logika murni.
+ */
+import { describe, expect, test } from "bun:test";
+import { HOME_HEADLINES, pickHeadline } from "../headlines";
+import {
+  type PendingStore,
+  peekPendingPrompt,
+  setPendingPrompt,
+  takePendingPrompt,
+} from "../pending-prompt";
+
+describe("pickHeadline", () => {
+  test("memilih sesuai nilai random (batas bawah & atas)", () => {
+    const list = ["a", "b", "c"];
+    expect(pickHeadline(list, () => 0)).toBe("a");
+    expect(pickHeadline(list, () => 0.5)).toBe("b");
+    expect(pickHeadline(list, () => 0.9999)).toBe("c");
+    // random() === 1 tidak boleh keluar dari indeks.
+    expect(pickHeadline(list, () => 1)).toBe("c");
+  });
+
+  test("default memakai HOME_HEADLINES; list kosong -> string kosong", () => {
+    expect(HOME_HEADLINES).toContain(pickHeadline());
+    expect(pickHeadline([])).toBe("");
+  });
+});
+
+function memoryStore(): PendingStore {
+  const map = new Map<string, string>();
+  return {
+    getItem: (k) => map.get(k) ?? null,
+    setItem: (k, v) => void map.set(k, v),
+    removeItem: (k) => void map.delete(k),
+  };
+}
+
+describe("pending prompt", () => {
+  test("disimpan per Session dan hanya bisa diambil sekali", () => {
+    const store = memoryStore();
+    setPendingPrompt("s1", "  hello  ", store);
+    expect(takePendingPrompt("s2", store)).toBeNull();
+    expect(takePendingPrompt("s1", store)).toBe("hello");
+    expect(takePendingPrompt("s1", store)).toBeNull();
+  });
+
+  test("peek membaca tanpa menghapus", () => {
+    const store = memoryStore();
+    setPendingPrompt("s1", "hi", store);
+    expect(peekPendingPrompt("s1", store)).toBe("hi");
+    expect(peekPendingPrompt("s1", store)).toBe("hi");
+    expect(takePendingPrompt("s1", store)).toBe("hi");
+    expect(peekPendingPrompt("s1", store)).toBeNull();
+    expect(peekPendingPrompt("s1", null)).toBeNull();
+  });
+
+  test("teks kosong tidak disimpan; tanpa storage aman", () => {
+    const store = memoryStore();
+    setPendingPrompt("s1", "   ", store);
+    expect(takePendingPrompt("s1", store)).toBeNull();
+    expect(takePendingPrompt("s1", null)).toBeNull();
+  });
+});

package/src/lib/__tests__/lock-screen.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Unit test logika keyboard lock screen (src/lib/lock-screen.ts).
+ */
+import { describe, expect, test } from "bun:test";
+import { applyPinAction, digitsFromPaste, PIN_MAX, pinKeyAction } from "../lock-screen";
+
+describe("pinKeyAction", () => {
+  test("angka baris atas & numpad -> digit", () => {
+    for (const k of ["0", "5", "9"]) {
+      expect(pinKeyAction({ key: k })).toEqual({ type: "digit", digit: k });
+    }
+  });
+
+  test("numpad dibaca dari code, termasuk saat NumLock mati", () => {
+    expect(pinKeyAction({ key: "4", code: "Numpad4" })).toEqual({ type: "digit", digit: "4" });
+    expect(pinKeyAction({ key: "ArrowLeft", code: "Numpad4" })).toEqual({
+      type: "digit",
+      digit: "4",
+    });
+    expect(pinKeyAction({ key: "Insert", code: "Numpad0" })).toEqual({ type: "digit", digit: "0" });
+    expect(pinKeyAction({ key: "Enter", code: "NumpadEnter" })).toEqual({ type: "submit" });
+    // Panah biasa (bukan numpad) tetap diabaikan.
+    expect(pinKeyAction({ key: "ArrowLeft", code: "ArrowLeft" })).toBeNull();
+  });
+
+  test("Backspace/Delete, Enter, Escape", () => {
+    expect(pinKeyAction({ key: "Backspace" })).toEqual({ type: "backspace" });
+    expect(pinKeyAction({ key: "Delete" })).toEqual({ type: "backspace" });
+    expect(pinKeyAction({ key: "Enter" })).toEqual({ type: "submit" });
+    expect(pinKeyAction({ key: "Escape" })).toEqual({ type: "clear" });
+  });
+
+  test("huruf & pintasan browser diabaikan", () => {
+    expect(pinKeyAction({ key: "a" })).toBeNull();
+    expect(pinKeyAction({ key: "Tab" })).toBeNull();
+    expect(pinKeyAction({ key: "5", ctrlKey: true })).toBeNull();
+    expect(pinKeyAction({ key: "r", metaKey: true })).toBeNull();
+    expect(pinKeyAction({ key: "1", altKey: true })).toBeNull();
+  });
+});
+
+describe("applyPinAction", () => {
+  test("tambah, hapus, kosongkan; submit tidak mengubah", () => {
+    expect(applyPinAction("12", { type: "digit", digit: "3" })).toBe("123");
+    expect(applyPinAction("123", { type: "backspace" })).toBe("12");
+    expect(applyPinAction("", { type: "backspace" })).toBe("");
+    expect(applyPinAction("123", { type: "clear" })).toBe("");
+    expect(applyPinAction("123", { type: "submit" })).toBe("123");
+  });
+
+  test("tidak melebihi PIN_MAX", () => {
+    const full = "4".repeat(PIN_MAX);
+    expect(applyPinAction(full, { type: "digit", digit: "1" })).toBe(full);
+  });
+});
+
+describe("digitsFromPaste", () => {
+  test("ambil angka saja, digabung, dipotong PIN_MAX", () => {
+    expect(digitsFromPaste("48 29-15", "")).toBe("482915");
+    expect(digitsFromPaste("15", "4829")).toBe("482915");
+    expect(digitsFromPaste("1".repeat(20), "")).toBe("1".repeat(PIN_MAX));
+    expect(digitsFromPaste("abc", "12")).toBe("12");
+  });
+});

package/src/lib/__tests__/model-picker.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Unit test helper pemilihan model (src/lib/model-picker.ts) — logika murni,
+ * pola sama dengan `session-summary.test.ts`.
+ */
+import { describe, expect, test } from "bun:test";
+import type { ModelOption } from "@/server/services/opencode-client";
+import {
+  activeModelLabel,
+  DEFAULT_MODEL_KEY,
+  describeModelCount,
+  filterModels,
+  groupModels,
+  keyOfSessionModel,
+  MODEL_NAME_MAX_LENGTH,
+  modelKey,
+  optionKey,
+  parseModelKey,
+  shortModelName,
+} from "../model-picker";
+
+function option(
+  providerID: string,
+  providerName: string,
+  modelID: string,
+  name: string,
+): ModelOption {
+  return { providerID, providerName, modelID, name };
+}
+
+const OPUS = option("kcgcode", "KCG Code", "kiro/claude-opus-5", "Claude Opus 5");
+const SONNET = option("kcgcode", "KCG Code", "kiro/claude-sonnet-4", "Claude Sonnet 4");
+const GPT = option("openai", "OpenAI", "gpt-5", "GPT-5");
+
+describe("kunci model", () => {
+  test("modelKey memakai pemisah non-slash (modelID boleh memuat '/')", () => {
+    const key = modelKey("kcgcode", "kiro/claude-opus-5");
+    expect(key).toContain("kiro/claude-opus-5");
+    expect(parseModelKey(key)).toEqual({
+      providerID: "kcgcode",
+      modelID: "kiro/claude-opus-5",
+    });
+  });
+
+  test("optionKey konsisten dengan modelKey", () => {
+    expect(optionKey(OPUS)).toBe(modelKey(OPUS.providerID, OPUS.modelID));
+  });
+
+  test("keyOfSessionModel: null -> kunci default", () => {
+    expect(keyOfSessionModel(null)).toBe(DEFAULT_MODEL_KEY);
+    expect(keyOfSessionModel({ providerID: "openai", modelID: "gpt-5" })).toBe(
+      modelKey("openai", "gpt-5"),
+    );
+  });
+
+  test("parseModelKey: kunci default & kunci tak lengkap -> null", () => {
+    expect(parseModelKey(DEFAULT_MODEL_KEY)).toBeNull();
+    expect(parseModelKey("")).toBeNull();
+    expect(parseModelKey("hanya-provider")).toBeNull();
+  });
+
+  test("round-trip kunci untuk sembarang provider/model", () => {
+    for (const m of [OPUS, SONNET, GPT]) {
+      expect(parseModelKey(optionKey(m))).toEqual({
+        providerID: m.providerID,
+        modelID: m.modelID,
+      });
+    }
+  });
+});
+
+describe("groupModels", () => {
+  test("mengelompokkan per provider, urutan kemunculan dipertahankan", () => {
+    const groups = groupModels([OPUS, GPT, SONNET]);
+    expect(groups.map((g) => g.providerID)).toEqual(["kcgcode", "openai"]);
+    expect(groups[0]?.models.map((m) => m.modelID)).toEqual([
+      "kiro/claude-opus-5",
+      "kiro/claude-sonnet-4",
+    ]);
+    expect(groups[0]?.providerName).toBe("KCG Code");
+  });
+
+  test("daftar kosong -> kosong", () => {
+    expect(groupModels([])).toEqual([]);
+  });
+});
+
+describe("filterModels", () => {
+  const all = [OPUS, SONNET, GPT];
+
+  test("query kosong / whitespace -> semua model", () => {
+    expect(filterModels(all, "")).toHaveLength(3);
+    expect(filterModels(all, "   ")).toHaveLength(3);
+  });
+
+  test("cocok pada nama tanpa membedakan huruf besar/kecil", () => {
+    expect(filterModels(all, "OPUS").map((m) => m.modelID)).toEqual(["kiro/claude-opus-5"]);
+  });
+
+  test("cocok pada modelID", () => {
+    expect(filterModels(all, "gpt-5").map((m) => m.name)).toEqual(["GPT-5"]);
+  });
+
+  test("cocok pada nama provider", () => {
+    expect(filterModels(all, "openai").map((m) => m.name)).toEqual(["GPT-5"]);
+  });
+
+  test("beberapa kata: semua harus cocok, urutan bebas", () => {
+    expect(filterModels(all, "opus 5").map((m) => m.modelID)).toEqual(["kiro/claude-opus-5"]);
+    expect(filterModels(all, "5 opus").map((m) => m.modelID)).toEqual(["kiro/claude-opus-5"]);
+    expect(filterModels(all, "claude code").map((m) => m.modelID)).toEqual([
+      "kiro/claude-opus-5",
+      "kiro/claude-sonnet-4",
+    ]);
+    expect(filterModels(all, "code claude").map((m) => m.modelID)).toEqual([
+      "kiro/claude-opus-5",
+      "kiro/claude-sonnet-4",
+    ]);
+  });
+
+  test("tidak ada yang cocok -> kosong", () => {
+    expect(filterModels(all, "gemini")).toEqual([]);
+  });
+
+  test("input tidak dimutasi", () => {
+    const input = [OPUS, GPT];
+    filterModels(input, "opus");
+    expect(input).toHaveLength(2);
+  });
+});
+
+describe("activeModelLabel", () => {
+  test("model null -> label default", () => {
+    expect(activeModelLabel(null, [OPUS])).toBe("Default model");
+  });
+
+  test("model dikenal -> nama ramah dari daftar", () => {
+    expect(activeModelLabel({ providerID: "kcgcode", modelID: "kiro/claude-opus-5" }, [OPUS])).toBe(
+      "Claude Opus 5",
+    );
+  });
+
+  test("daftar belum termuat -> jatuh ke modelID (trigger tidak kosong)", () => {
+    expect(activeModelLabel({ providerID: "kcgcode", modelID: "kiro/claude-opus-5" }, [])).toBe(
+      "kiro/claude-opus-5",
+    );
+  });
+});
+
+describe("describeModelCount", () => {
+  test("nol, satu, dan banyak", () => {
+    expect(describeModelCount(0)).toBe("No matching models");
+    expect(describeModelCount(1)).toBe("1 model");
+    expect(describeModelCount(7)).toBe("7 models");
+  });
+});
+
+describe("shortModelName", () => {
+  test("prefiks vendor dibuang, segmen terakhir dipakai", () => {
+    expect(shortModelName("kiro/claude-opus-5")).toBe("claude-opus-5");
+    expect(shortModelName("anthropic/claude-sonnet-4")).toBe("claude-sonnet-4");
+  });
+
+  test("prefiks berlapis: tetap segmen terakhir", () => {
+    expect(shortModelName("vendor/family/gpt-5")).toBe("gpt-5");
+  });
+
+  test("tanpa slash dibiarkan apa adanya", () => {
+    expect(shortModelName("Claude Opus 5")).toBe("Claude Opus 5");
+  });
+
+  test("trailing slash diabaikan", () => {
+    expect(shortModelName("kiro/claude-opus-5/")).toBe("claude-opus-5");
+  });
+
+  test("nama panjang dipotong dengan elipsis, total tepat maxLength", () => {
+    const long = "a".repeat(40);
+    const out = shortModelName(long, 10);
+    expect(out).toHaveLength(10);
+    expect(out.endsWith("…")).toBe(true);
+  });
+
+  test("nama tepat sepanjang batas tidak dipotong", () => {
+    const exact = "b".repeat(MODEL_NAME_MAX_LENGTH);
+    expect(shortModelName(exact)).toBe(exact);
+  });
+
+  test("spasi sebelum elipsis dirapikan", () => {
+    expect(shortModelName("Claude Opus Model Panjang", 12)).toBe("Claude Opus…");
+  });
+
+  test("string kosong / hanya slash aman", () => {
+    expect(shortModelName("")).toBe("");
+    expect(shortModelName("/")).toBe("");
+    expect(shortModelName("///")).toBe("");
+  });
+
+  test("maxLength nol atau negatif -> string kosong (tanpa crash)", () => {
+    expect(shortModelName("apa pun", 0)).toBe("");
+    expect(shortModelName("apa pun", -5)).toBe("");
+  });
+
+  test("label default tetap terbaca", () => {
+    expect(shortModelName("Model default")).toBe("Model default");
+  });
+});

package/src/lib/__tests__/onboarding.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import {
+  greeting,
+  nextStep,
+  ONBOARDING_STEPS,
+  PROGRESS_STEPS,
+  prevStep,
+  stepDirection,
+} from "../onboarding";
+
+describe("alur onboarding", () => {
+  test("urutan langkah welcome -> profile -> lock -> done", () => {
+    expect([...ONBOARDING_STEPS]).toEqual(["welcome", "profile", "lock", "done"]);
+    expect(nextStep("welcome")).toBe("profile");
+    expect(nextStep("profile")).toBe("lock");
+    expect(nextStep("lock")).toBe("done");
+    expect(nextStep("done")).toBe("done");
+  });
+
+  test("mundur berhenti di welcome", () => {
+    expect(prevStep("lock")).toBe("profile");
+    expect(prevStep("profile")).toBe("welcome");
+    expect(prevStep("welcome")).toBe("welcome");
+  });
+
+  test("arah animasi mengikuti navigasi", () => {
+    expect(stepDirection("welcome", "profile")).toBe(1);
+    expect(stepDirection("lock", "profile")).toBe(-1);
+  });
+
+  test("titik progres hanya untuk langkah pengaturan", () => {
+    expect([...PROGRESS_STEPS]).toEqual(["profile", "lock"]);
+  });
+
+  test("sapaan sesuai jam", () => {
+    expect(greeting(8)).toBe("Good morning");
+    expect(greeting(14)).toBe("Good afternoon");
+    expect(greeting(20)).toBe("Good evening");
+    expect(greeting(2)).toBe("Good evening");
+  });
+});

package/src/lib/__tests__/permission-info.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import { parsePermissionTitle } from "../permission-info";
+
+describe("parsePermissionTitle", () => {
+  test("judul server: permission + pola ber-backtick", () => {
+    const info = parsePermissionTitle(
+      "external_directory — `/home/irsyadulibad/.config/opencode/*`",
+    );
+    expect(info.permission).toBe("external_directory");
+    expect(info.label).toBe("Access a folder outside the project");
+    expect(info.targets).toEqual(["/home/irsyadulibad/.config/opencode/*"]);
+    expect(info.risk).toBe("high");
+  });
+
+  test("beberapa pola dipisah", () => {
+    const info = parsePermissionTitle("edit — `src/a.ts` — `src/b.ts`");
+    expect(info.label).toBe("Edit files");
+    expect(info.targets).toEqual(["src/a.ts", "src/b.ts"]);
+    expect(info.risk).toBe("medium");
+  });
+
+  test("perintah bash yang memuat ' — ' di dalam backtick tidak dipecah sebagai pola baru", () => {
+    // Server membungkus tiap pola dengan backtick; pemisah ' — ' hanya di
+    // antara pola. Perintah tanpa ' — ' di dalamnya tetap utuh.
+    const info = parsePermissionTitle("bash — `mkdir -p /tmp/perm-test`");
+    expect(info.label).toBe("Run a shell command");
+    expect(info.targets).toEqual(["mkdir -p /tmp/perm-test"]);
+    expect(info.risk).toBe("high");
+  });
+
+  test("permission tanpa pola", () => {
+    const info = parsePermissionTitle("webfetch");
+    expect(info.label).toBe("Fetch a web page");
+    expect(info.targets).toEqual([]);
+  });
+
+  test("baca-saja = risiko rendah", () => {
+    expect(parsePermissionTitle("read — `README.md`").risk).toBe("low");
+    expect(parsePermissionTitle("grep — `TODO`").risk).toBe("low");
+  });
+
+  test("permission tak dikenal: nama ditampilkan (bukan disembunyikan), risiko sedang", () => {
+    const info = parsePermissionTitle("future_tool — `x`");
+    expect(info.permission).toBe("future_tool");
+    expect(info.label).toBe("Future tool");
+    expect(info.risk).toBe("medium");
+  });
+
+  test("judul kosong / fallback server -> label umum", () => {
+    for (const t of [null, "", "  ", "Izin tool"]) {
+      const info = parsePermissionTitle(t);
+      expect(info.permission).toBeNull();
+      expect(info.label).toBe("Use a tool");
+      expect(info.targets).toEqual([]);
+    }
+  });
+
+  test("nama permission tidak peka huruf besar", () => {
+    expect(parsePermissionTitle("BASH — `ls`").label).toBe("Run a shell command");
+  });
+});

package/src/lib/__tests__/project-extensions.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Unit test helper panel samping Project (src/lib/project-extensions.ts).
+ */
+import { describe, expect, test } from "bun:test";
+import type { SkillInfo } from "@/server/services/opencode-client";
+import { describeMcpSummary, filterSkills, groupSkills } from "../project-extensions";
+
+function skill(name: string, source: SkillInfo["source"], description: string | null = null) {
+  return { name, description, location: null, source } satisfies SkillInfo;
+}
+
+describe("describeMcpSummary", () => {
+  test("kosong -> None configured", () => {
+    expect(describeMcpSummary([])).toBe("None configured");
+  });
+
+  test("hitung yang connected", () => {
+    expect(
+      describeMcpSummary([
+        { name: "a", status: "connected", error: null },
+        { name: "b", status: "failed", error: "x" },
+        { name: "c", status: "connected", error: null },
+      ]),
+    ).toBe("2 of 3 connected");
+  });
+});
+
+describe("groupSkills", () => {
+  test("urutan project -> global -> builtin, kelompok kosong dibuang", () => {
+    const groups = groupSkills([
+      skill("b1", "builtin"),
+      skill("p1", "project"),
+      skill("p2", "project"),
+    ]);
+    expect(groups.map((g) => g.source)).toEqual(["project", "builtin"]);
+    expect(groups[0]?.skills.map((s) => s.name)).toEqual(["p1", "p2"]);
+  });
+});
+
+describe("filterSkills", () => {
+  const all = [skill("shadcn", "project", "UI components"), skill("firecrawl", "global", "Web")];
+
+  test("query kosong -> semua", () => {
+    expect(filterSkills(all, "  ")).toHaveLength(2);
+  });
+
+  test("cocok nama atau deskripsi, case-insensitive", () => {
+    expect(filterSkills(all, "SHAD").map((s) => s.name)).toEqual(["shadcn"]);
+    expect(filterSkills(all, "web").map((s) => s.name)).toEqual(["firecrawl"]);
+    expect(filterSkills(all, "zzz")).toEqual([]);
+  });
+});

package/src/lib/__tests__/project-overview.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Unit test ringkasan Project homepage (src/lib/project-overview.ts).
+ *
+ * Yang diuji: penggabungan Project + Session, urutan aktivitas terbaru,
+ * filter pencarian, dan label waktu relatif — semuanya logika murni
+ * (pola yang sama dengan `routes.test.ts`).
+ */
+import { describe, expect, test } from "bun:test";
+import type { Project, Session, SessionStatus } from "@/types";
+import {
+  buildProjectOverviews,
+  filterProjectOverviews,
+  formatRelativeTime,
+  totalRunningSessions,
+} from "../project-overview";
+
+function project(id: string, name: string, createdAt: number, path = `/sandbox/${name}`): Project {
+  return { id, name, path, createdAt };
+}
+
+function session(id: string, projectId: string, status: SessionStatus, updatedAt: number): Session {
+  return {
+    id,
+    projectId,
+    agentType: "opencode",
+    cwd: "/sandbox",
+    status,
+    ocSessionId: null,
+    title: null,
+    model: null,
+    agent: null,
+    createdAt: updatedAt,
+    updatedAt,
+  };
+}
+
+describe("buildProjectOverviews", () => {
+  test("menghitung jumlah Session dan Session berjalan per Project", () => {
+    const projects = [project("p1", "alpha", 1_000), project("p2", "beta", 2_000)];
+    const sessions = [
+      session("s1", "p1", "running", 5_000),
+      session("s2", "p1", "stopped", 4_000),
+      session("s3", "p2", "crashed", 3_000),
+    ];
+
+    const [first, second] = buildProjectOverviews(projects, sessions);
+
+    expect(first?.project.id).toBe("p1");
+    expect(first?.sessionCount).toBe(2);
+    expect(first?.runningCount).toBe(1);
+    expect(first?.lastSession?.id).toBe("s1");
+    expect(first?.lastActivityAt).toBe(5_000);
+
+    expect(second?.project.id).toBe("p2");
+    expect(second?.runningCount).toBe(0);
+    expect(second?.lastSession?.id).toBe("s3");
+  });
+
+  test("Project tanpa Session memakai createdAt sebagai aktivitas terakhir", () => {
+    const [only] = buildProjectOverviews([project("p1", "alpha", 7_000)], []);
+    expect(only?.sessionCount).toBe(0);
+    expect(only?.lastSession).toBeNull();
+    expect(only?.lastActivityAt).toBe(7_000);
+  });
+
+  test("urutan: aktivitas terbaru di atas", () => {
+    const projects = [
+      project("p1", "alpha", 1_000),
+      project("p2", "beta", 2_000),
+      project("p3", "gamma", 3_000),
+    ];
+    const sessions = [session("s1", "p1", "stopped", 9_000)];
+
+    const ids = buildProjectOverviews(projects, sessions).map((o) => o.project.id);
+    expect(ids).toEqual(["p1", "p3", "p2"]);
+  });
+
+  test("aktivitas sama diurut berdasarkan nama (case-insensitive)", () => {
+    const projects = [project("p1", "Zeta", 1_000), project("p2", "alpha", 1_000)];
+    const ids = buildProjectOverviews(projects, []).map((o) => o.project.id);
+    expect(ids).toEqual(["p2", "p1"]);
+  });
+
+  test("Session dengan projectId tak dikenal diabaikan", () => {
+    const overviews = buildProjectOverviews(
+      [project("p1", "alpha", 1_000)],
+      [session("s1", "ghost", "running", 9_000)],
+    );
+    expect(overviews).toHaveLength(1);
+    expect(overviews[0]?.sessionCount).toBe(0);
+  });
+
+  test("daftar Project kosong -> hasil kosong", () => {
+    expect(buildProjectOverviews([], [session("s1", "p1", "running", 1)])).toEqual([]);
+  });
+});
+
+describe("filterProjectOverviews", () => {
+  const overviews = buildProjectOverviews(
+    [
+      project("p1", "web-app", 1_000, "/sandbox/web-app"),
+      project("p2", "api-service", 2_000, "/sandbox/backend/api"),
+    ],
+    [],
+  );
+
+  test("query kosong mengembalikan semua", () => {
+    expect(filterProjectOverviews(overviews, "")).toHaveLength(2);
+    expect(filterProjectOverviews(overviews, "   ")).toHaveLength(2);
+  });
+
+  test("cocok pada nama tanpa membedakan huruf besar/kecil", () => {
+    const found = filterProjectOverviews(overviews, "WEB");
+    expect(found.map((o) => o.project.id)).toEqual(["p1"]);
+  });
+
+  test("cocok pada path", () => {
+    const found = filterProjectOverviews(overviews, "backend");
+    expect(found.map((o) => o.project.id)).toEqual(["p2"]);
+  });
+
+  test("tidak ada yang cocok -> kosong", () => {
+    expect(filterProjectOverviews(overviews, "zzz")).toEqual([]);
+  });
+});
+
+describe("totalRunningSessions", () => {
+  test("menjumlahkan Session berjalan seluruh Project", () => {
+    const overviews = buildProjectOverviews(
+      [project("p1", "alpha", 1), project("p2", "beta", 2)],
+      [
+        session("s1", "p1", "running", 10),
+        session("s2", "p1", "running", 11),
+        session("s3", "p2", "stopped", 12),
+      ],
+    );
+    expect(totalRunningSessions(overviews)).toBe(2);
+  });
+
+  test("tanpa Session -> 0", () => {
+    expect(totalRunningSessions([])).toBe(0);
+  });
+});
+
+describe("formatRelativeTime", () => {
+  const now = Date.UTC(2026, 0, 15, 12, 0, 0);
+  const minute = 60_000;
+
+  test("kurang dari satu menit -> just now", () => {
+    expect(formatRelativeTime(now - 30_000, now)).toBe("just now");
+  });
+
+  test("timestamp di masa depan tetap just now", () => {
+    expect(formatRelativeTime(now + minute, now)).toBe("just now");
+  });
+
+  test("skala menit, jam, dan hari", () => {
+    expect(formatRelativeTime(now - 5 * minute, now)).toBe("5 minutes ago");
+    expect(formatRelativeTime(now - 3 * 60 * minute, now)).toBe("3 hours ago");
+    expect(formatRelativeTime(now - 2 * 24 * 60 * minute, now)).toBe("2 days ago");
+  });
+
+  test("lebih dari sepekan -> tanggal absolut", () => {
+    const old = now - 30 * 24 * 60 * minute;
+    expect(formatRelativeTime(old, now)).toBe(
+      new Date(old).toLocaleDateString(undefined, {
+        day: "2-digit",
+        month: "short",
+        year: "numeric",
+      }),
+    );
+  });
+});