kcg-code 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,118 @@
+/**
+ * Unit test placeholder composer (src/lib/composer.ts).
+ */
+import { describe, expect, test } from "bun:test";
+import { composerPlaceholder, extractMentionedFiles, splitComposerMentions } from "../composer";
+
+describe("composerPlaceholder", () => {
+  test("ada lampiran: ajakan singkat (tidak wrap di ruang yang menyempit)", () => {
+    for (const compact of [false, true]) {
+      expect(
+        composerPlaceholder({ busy: false, canInput: true, compact, hasAttachments: true }),
+      ).toBe("Add a message…");
+    }
+    // Status sibuk / Session mati tetap lebih penting.
+    expect(
+      composerPlaceholder({ busy: true, canInput: false, compact: false, hasAttachments: true }),
+    ).toBe("Model is responding…");
+  });
+
+  test("wide screen: full hint when input is ready", () => {
+    expect(composerPlaceholder({ busy: false, canInput: true, compact: false })).toBe(
+      "Type a message… type @ for file references, or drop files here",
+    );
+  });
+
+  test("narrow screen: short text to avoid truncation", () => {
+    expect(composerPlaceholder({ busy: false, canInput: true, compact: true })).toBe(
+      "Type a message…",
+    );
+  });
+
+  test("model responding: status outranks the typing hint", () => {
+    expect(composerPlaceholder({ busy: true, canInput: false, compact: false })).toBe(
+      "Model is responding…",
+    );
+    expect(composerPlaceholder({ busy: true, canInput: false, compact: true })).toBe("Responding…");
+  });
+
+  test("session down: same text at both sizes (already short)", () => {
+    expect(composerPlaceholder({ busy: false, canInput: false, compact: false })).toBe(
+      "Session is not active",
+    );
+    expect(composerPlaceholder({ busy: false, canInput: false, compact: true })).toBe(
+      "Session is not active",
+    );
+  });
+
+  test("busy is checked before canInput", () => {
+    // Unusual combination (busy + canInput) still reports the responding status.
+    expect(composerPlaceholder({ busy: true, canInput: true, compact: false })).toBe(
+      "Model is responding…",
+    );
+  });
+});
+
+describe("extractMentionedFiles", () => {
+  test("path yang pernah disarankan autocomplete ikut dikirim", () => {
+    const known = new Set(["src/index.ts"]);
+    expect(extractMentionedFiles("fix @src/index.ts", known)).toEqual(["src/index.ts"]);
+  });
+
+  test("path memuat / ikut dikirim walau tidak pernah disarankan", () => {
+    expect(extractMentionedFiles("lihat @a/b/c.ts dulu", new Set())).toEqual(["a/b/c.ts"]);
+  });
+
+  test("kata biasa dengan @ (mis. @user) TIDAK dikirim tanpa slash & tak dikenal", () => {
+    expect(extractMentionedFiles("halo @user apa kabar", new Set())).toEqual([]);
+    // Kecuali pernah disarankan autocomplete — baru dianggap file sungguhan.
+    expect(extractMentionedFiles("halo @user", new Set(["user"]))).toEqual(["user"]);
+  });
+
+  test("urutan & duplikat kemunculan dipertahankan", () => {
+    const known = new Set(["a.ts"]);
+    expect(extractMentionedFiles("@a.ts lalu @a.ts lagi", known)).toEqual(["a.ts", "a.ts"]);
+  });
+
+  test("tanpa teks atau tanpa @ -> kosong", () => {
+    expect(extractMentionedFiles("", new Set())).toEqual([]);
+    expect(extractMentionedFiles("tidak ada mention", new Set(["x.ts"]))).toEqual([]);
+  });
+});
+
+describe("splitComposerMentions", () => {
+  const known = new Set(["skills-lock.json"]);
+  const join = (segs: { text: string }[]) => segs.map((x) => x.text).join("");
+
+  test("memecah teks + mention yang dikenal", () => {
+    const text = "lalu apa yang ada pada file @skills-lock.json ya";
+    const segs = splitComposerMentions(text, known);
+    expect(segs).toEqual([
+      { kind: "text", text: "lalu apa yang ada pada file " },
+      { kind: "mention", text: "@skills-lock.json", path: "skills-lock.json" },
+      { kind: "text", text: " ya" },
+    ]);
+    expect(join(segs)).toBe(text);
+  });
+
+  test("path dengan / dianggap file walau belum disarankan", () => {
+    const segs = splitComposerMentions("@src/App.tsx dan @src/lib/x.ts", new Set());
+    expect(segs.filter((x) => x.kind === "mention").map((x) => x.text)).toEqual([
+      "@src/App.tsx",
+      "@src/lib/x.ts",
+    ]);
+  });
+
+  test("@kata biasa & email tidak disorot", () => {
+    const text = "halo @budi, email saya a@b.com";
+    const segs = splitComposerMentions(text, known);
+    expect(segs.every((x) => x.kind === "text")).toBe(true);
+    expect(join(segs)).toBe(text);
+  });
+
+  test("gabungan potongan selalu identik dengan input", () => {
+    for (const text of ["", "@", "@skills-lock.json", "\n@src/a.ts\n\nteks", "  @x/y  "]) {
+      expect(join(splitComposerMentions(text, known))).toBe(text);
+    }
+  });
+});

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

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+import { highlightCode, resolveLang } from "../highlight";
+
+describe("resolveLang", () => {
+  test("nama kanonis, alias, prefix language-, huruf besar", () => {
+    expect(resolveLang("typescript")).toBe("typescript");
+    expect(resolveLang("ts")).toBe("typescript");
+    expect(resolveLang("language-tsx")).toBe("tsx");
+    expect(resolveLang("Bash")).toBe("shellscript");
+    expect(resolveLang("yml")).toBe("yaml");
+    expect(resolveLang("Dockerfile")).toBe("docker");
+  });
+
+  test("tak dikenal / kosong -> null (teks polos)", () => {
+    expect(resolveLang("brainfuck")).toBeNull();
+    expect(resolveLang("")).toBeNull();
+    expect(resolveLang(null)).toBeNull();
+  });
+});
+
+describe("highlightCode", () => {
+  test("token menyatu kembali persis jadi kode asli", async () => {
+    for (const code of ["const a = 1;\nlet b = 2", "x\n", "a\n\n  b\t c\n", ""]) {
+      const lines = await highlightCode(code, "typescript");
+      expect(lines).not.toBeNull();
+      const joined = (lines ?? []).map((l) => l.map((t) => t.content).join("")).join("\n");
+      expect(joined).toBe(code);
+    }
+  });
+
+  test("token membawa warna light & dark sebagai CSS variable", async () => {
+    const lines = await highlightCode("const x = 1", "typescript");
+    const kw = lines?.[0]?.find((t) => t.content === "const");
+    expect(kw?.style["--shiki-light"]).toMatch(/^#[0-9a-f]{6,8}$/i);
+    expect(kw?.style["--shiki-dark"]).toMatch(/^#[0-9a-f]{6,8}$/i);
+  });
+
+  test("bahasa lain dimuat lazy (python, bash)", async () => {
+    expect(await highlightCode("def f():\n  return 1", "python")).not.toBeNull();
+    expect(await highlightCode("echo $HOME | wc -l", "shellscript")).not.toBeNull();
+  });
+});

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,83 @@
+/**
+ * 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 {
+  describeMcpEntries,
+  describeMcpSummary,
+  filterSkills,
+  groupSkills,
+  mergeMcpServers,
+} 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("mergeMcpServers", () => {
+  test("gabung per nama, catat agent, urut yang bermasalah dulu", () => {
+    const entries = mergeMcpServers({
+      opencode: [
+        { name: "web", status: "connected", error: null },
+        { name: "db", status: "connected", error: null },
+      ],
+      "claude-code": [
+        { name: "web", status: "unknown", error: null },
+        { name: "db", status: "failed", error: "boom" },
+        { name: "cc-only", status: "disabled", error: null },
+      ],
+    });
+    expect(entries.map((e) => [e.name, e.status, e.agents])).toEqual([
+      ["db", "failed", ["opencode", "claude-code"]],
+      ["web", "connected", ["opencode", "claude-code"]],
+      ["cc-only", "disabled", ["claude-code"]],
+    ]);
+    expect(entries[0]?.byAgent["claude-code"]?.error).toBe("boom");
+    // Tersambung di salah satu agent sudah dihitung "connected".
+    expect(describeMcpEntries(entries)).toBe("2 of 3 connected");
+    expect(describeMcpEntries([])).toBe("None configured");
+  });
+});
+
+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([]);
+  });
+});