kcg-code 0.0.0-stage → 0.2.0

package/src/lib/__tests__/sidebar-groups.test.ts

@@ -0,0 +1,100 @@
+/**
+ * Unit test pengelompokan Session per Project untuk sidebar
+ * (src/lib/sidebar-groups.ts) — logika murni.
+ */
+import { describe, expect, test } from "bun:test";
+import type { Project, Session, SessionStatus } from "@/types";
+import { filterSidebarGroups, groupSessionsByProject } from "../sidebar-groups";
+
+function project(id: string, name: string, createdAt: number): Project {
+  return { id, name, path: `/sandbox/${name}`, createdAt };
+}
+
+function session(
+  id: string,
+  projectId: string,
+  status: SessionStatus,
+  updatedAt: number,
+  title: string | null = null,
+): Session {
+  return {
+    id,
+    projectId,
+    agentType: "opencode",
+    cwd: "/sandbox",
+    status,
+    ocSessionId: null,
+    title,
+    model: null,
+    agent: null,
+    createdAt: updatedAt,
+    updatedAt,
+  };
+}
+
+const titleOf = (s: Session) => s.title ?? "New session";
+
+describe("groupSessionsByProject", () => {
+  test("mengelompokkan Session per Project dan menghitung yang running", () => {
+    const groups = groupSessionsByProject(
+      [project("p1", "alpha", 1), project("p2", "beta", 2)],
+      [
+        session("s1", "p1", "running", 10),
+        session("s2", "p1", "stopped", 20),
+        session("s3", "p2", "running", 5),
+      ],
+    );
+    const alpha = groups.find((g) => g.project.id === "p1");
+    expect(alpha?.sessions.map((s) => s.id)).toEqual(["s1", "s2"]);
+    expect(alpha?.runningCount).toBe(1);
+    expect(groups.find((g) => g.project.id === "p2")?.sessions).toHaveLength(1);
+  });
+
+  test("Project dengan aktivitas terbaru di atas; Project kosong tetap tampil", () => {
+    const groups = groupSessionsByProject(
+      [project("p1", "alpha", 1), project("p2", "beta", 2), project("p3", "gamma", 100)],
+      [session("s1", "p1", "stopped", 50), session("s2", "p2", "stopped", 80)],
+    );
+    expect(groups.map((g) => g.project.id)).toEqual(["p3", "p2", "p1"]);
+    expect(groups[0]?.sessions).toEqual([]);
+  });
+
+  test("Session dengan projectId tak dikenal diabaikan", () => {
+    const groups = groupSessionsByProject(
+      [project("p1", "alpha", 1)],
+      [session("s1", "ghost", "running", 10)],
+    );
+    expect(groups).toHaveLength(1);
+    expect(groups[0]?.sessions).toEqual([]);
+  });
+});
+
+describe("filterSidebarGroups", () => {
+  const groups = groupSessionsByProject(
+    [project("p1", "alpha", 1), project("p2", "beta", 2)],
+    [
+      session("s1", "p1", "running", 10, "Fix login bug"),
+      session("s2", "p1", "stopped", 20, "Add sidebar"),
+      session("s3", "p2", "running", 5, "Refactor login"),
+    ],
+  );
+
+  test("query kosong mengembalikan semua grup", () => {
+    expect(filterSidebarGroups(groups, "  ", titleOf)).toHaveLength(2);
+  });
+
+  test("nama Project cocok -> grup utuh", () => {
+    const out = filterSidebarGroups(groups, "ALPHA", titleOf);
+    expect(out).toHaveLength(1);
+    expect(out[0]?.sessions).toHaveLength(2);
+  });
+
+  test("judul Session cocok -> hanya Session tersebut, grup kosong dibuang", () => {
+    const out = filterSidebarGroups(groups, "login", titleOf);
+    expect(out.map((g) => g.sessions.map((s) => s.id))).toEqual([["s1"], ["s3"]]);
+    expect(filterSidebarGroups(groups, "sidebar", titleOf).map((g) => g.project.id)).toEqual([
+      "p1",
+    ]);
+    expect(filterSidebarGroups(groups, "zzz", titleOf)).toEqual([]);
+  });
+});

package/src/lib/__tests__/skill-installs.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Unit test store instalasi skill (src/lib/skill-installs.ts) — bagian murni.
+ */
+import { describe, expect, test } from "bun:test";
+import type { InstallJob } from "@/server/services/skill-install-jobs";
+import {
+  findRunningInstall,
+  hydrationEntries,
+  type InstallEntry,
+  mergeLog,
+} from "../skill-installs";
+
+function job(over: Partial<InstallJob> = {}): InstallJob {
+  return {
+    id: "j1",
+    projectId: "p1",
+    projectName: "Proj",
+    source: "a/b",
+    skillId: "c",
+    agentTypes: ["opencode"],
+    status: "running",
+    error: null,
+    refreshed: null,
+    installedPath: null,
+    startedAt: 1,
+    finishedAt: null,
+    lastOutputAt: 1,
+    lineCount: 0,
+    ...over,
+  };
+}
+
+function entry(over: Partial<InstallEntry> = {}): InstallEntry {
+  return {
+    job: job(),
+    lines: [],
+    next: 0,
+    truncated: false,
+    dismissed: false,
+    expanded: true,
+    pollError: null,
+    cancelling: false,
+    ...over,
+  };
+}
+
+describe("mergeLog", () => {
+  test("menambah baris baru dan memajukan kursor", () => {
+    const e = mergeLog(entry(), {
+      job: job({ lineCount: 2 }),
+      from: 0,
+      lines: ["a", "b"],
+      truncated: false,
+    });
+    expect(e.lines).toEqual(["a", "b"]);
+    expect(e.next).toBe(2);
+    const e2 = mergeLog(e, { job: job({ lineCount: 3 }), from: 2, lines: ["c"], truncated: false });
+    expect(e2.lines).toEqual(["a", "b", "c"]);
+    expect(e2.next).toBe(3);
+  });
+
+  test("respon tumpang tindih tidak menggandakan baris", () => {
+    const e = entry({ lines: ["a", "b"], next: 2 });
+    const merged = mergeLog(e, { job: job(), from: 1, lines: ["b", "c"], truncated: false });
+    expect(merged.lines).toEqual(["a", "b", "c"]);
+    expect(merged.next).toBe(3);
+  });
+
+  test("status job diperbarui & pollError dibersihkan; truncated diteruskan", () => {
+    const e = entry({ pollError: "x" });
+    const merged = mergeLog(e, {
+      job: job({ status: "succeeded" }),
+      from: 5,
+      lines: ["z"],
+      truncated: true,
+    });
+    expect(merged.job.status).toBe("succeeded");
+    expect(merged.pollError).toBeNull();
+    expect(merged.truncated).toBe(true);
+    expect(merged.next).toBe(6);
+  });
+});
+
+describe("findRunningInstall", () => {
+  test("cocokkan project + source + skill yang masih berjalan", () => {
+    const list = [
+      entry({ job: job({ id: "done", status: "succeeded" }) }),
+      entry({ job: job({ id: "run" }) }),
+    ];
+    expect(findRunningInstall(list, "p1", "a/b", "c")?.job.id).toBe("run");
+    expect(findRunningInstall(list, "p2", "a/b", "c")).toBeUndefined();
+    expect(findRunningInstall(list, "p1", "a/b", "d")).toBeUndefined();
+  });
+});
+
+describe("hydrationEntries (pulih setelah refresh)", () => {
+  const running = job({ id: "run" });
+  const done = job({ id: "done", status: "succeeded", finishedAt: 5 });
+  const failed = job({
+    id: "fail",
+    status: "failed",
+    error: "SKILL_INSTALL_FAILED",
+    finishedAt: 6,
+  });
+
+  test("job berjalan & selesai yang belum ditutup dipulihkan, status tampilan ikut", () => {
+    const out = hydrationEntries(
+      [running, done, failed],
+      { dismissed: [], expanded: ["done"] },
+      new Set(),
+    );
+    expect(out.map((e) => e.job.id)).toEqual(["run", "done", "fail"]);
+    expect(out.find((e) => e.job.id === "done")?.expanded).toBe(true);
+    expect(out.find((e) => e.job.id === "run")?.expanded).toBe(false);
+    expect(out.every((e) => e.lines.length === 0 && e.next === 0)).toBe(true);
+  });
+
+  test("job selesai yang ditutup tidak kembali; job berjalan yang disembunyikan tetap tersembunyi", () => {
+    const out = hydrationEntries(
+      [running, done],
+      { dismissed: ["run", "done"], expanded: [] },
+      new Set(),
+    );
+    expect(out.map((e) => [e.job.id, e.dismissed])).toEqual([["run", true]]);
+  });
+
+  test("entry yang sudah ada di store dilewati", () => {
+    const out = hydrationEntries(
+      [running, done],
+      { dismissed: [], expanded: [] },
+      new Set(["run"]),
+    );
+    expect(out.map((e) => e.job.id)).toEqual(["done"]);
+  });
+});

package/src/lib/__tests__/skills-catalog.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Unit test helper katalog skill (src/lib/skills-catalog.ts).
+ */
+import { describe, expect, test } from "bun:test";
+import type { SkillInfo } from "@/server/services/opencode-client";
+import type { RegistrySkill } from "@/server/services/skills-registry";
+import type { Project } from "@/types";
+import {
+  formatInstalls,
+  githubOwner,
+  installedAgentsFor,
+  mergeInstalledSkills,
+  resolveSkillsProject,
+  visibleInstalledSkills,
+} from "../skills-catalog";
+
+describe("formatInstalls", () => {
+  test("ringkas per ribuan / jutaan", () => {
+    expect(formatInstalls(0)).toBe("0");
+    expect(formatInstalls(950)).toBe("950");
+    expect(formatInstalls(1000)).toBe("1K");
+    expect(formatInstalls(1234)).toBe("1.2K");
+    expect(formatInstalls(752_553)).toBe("753K");
+    expect(formatInstalls(1_300_000)).toBe("1.3M");
+  });
+});
+
+describe("deteksi terpasang", () => {
+  const skills: SkillInfo[] = [
+    {
+      name: "find-skills",
+      description: null,
+      location: "/p/.agents/skills/find-skills/SKILL.md",
+      source: "project",
+    },
+    { name: "Global-One", description: null, location: "/home/u/.config/x", source: "global" },
+    { name: "builtin", description: null, location: null, source: "builtin" },
+  ];
+  const reg = (skillId: string, name = skillId): RegistrySkill => ({
+    id: `a/b/${skillId}`,
+    name,
+    source: "a/b",
+    skillId,
+    installs: 1,
+    url: "",
+  });
+
+  test("mergeInstalledSkills: gabung per source + nama, catat agent", () => {
+    const merged = mergeInstalledSkills({
+      opencode: skills,
+      "claude-code": [
+        {
+          name: "Find-Skills",
+          description: "From CC",
+          location: "/p/.claude/x",
+          source: "project",
+        },
+        { name: "cc-only", description: null, location: "/p/.claude/y", source: "project" },
+      ],
+    });
+    expect(merged.map((s) => [s.name, s.source, s.agents])).toEqual([
+      ["builtin", "builtin", ["opencode"]],
+      ["cc-only", "project", ["claude-code"]],
+      ["find-skills", "project", ["opencode", "claude-code"]],
+      ["Global-One", "global", ["opencode"]],
+    ]);
+    // Deskripsi kosong diisi dari agent lain.
+    expect(merged.find((s) => s.name === "find-skills")?.description).toBe("From CC");
+  });
+
+  test("installedAgentsFor: hanya sumber project, case-insensitive", () => {
+    const merged = mergeInstalledSkills({
+      opencode: skills,
+      "claude-code": [skills[0] as SkillInfo],
+    });
+    expect(installedAgentsFor(reg("FIND-SKILLS"), merged)).toEqual(["opencode", "claude-code"]);
+    expect(installedAgentsFor(reg("other", "find-skills"), merged)).toEqual([
+      "opencode",
+      "claude-code",
+    ]);
+    expect(installedAgentsFor(reg("global-one"), merged)).toEqual([]);
+  });
+});
+
+describe("resolveSkillsProject", () => {
+  const p = (id: string): Project => ({ id, name: id, path: `/${id}`, createdAt: 1 });
+  const projects = [p("a"), p("b")];
+
+  test("URL menang, lalu tersimpan; id tak dikenal dilewati", () => {
+    expect(resolveSkillsProject(projects, "b", "a")?.id).toBe("b");
+    expect(resolveSkillsProject(projects, "gone", "a")?.id).toBe("a");
+    expect(resolveSkillsProject(projects, null, "gone")).toBeNull();
+    expect(resolveSkillsProject(projects, null, null)).toBeNull();
+  });
+
+  test("satu-satunya Project dipilih otomatis", () => {
+    expect(resolveSkillsProject([p("only")], null, null)?.id).toBe("only");
+    expect(resolveSkillsProject([], null, null)).toBeNull();
+  });
+});
+
+describe("githubOwner", () => {
+  test("owner/repo -> owner; domain / bentuk lain -> null", () => {
+    expect(githubOwner("vercel-labs/skills")).toBe("vercel-labs");
+    expect(githubOwner("mintlify.com")).toBeNull();
+    expect(githubOwner("a/b/c")).toBeNull();
+  });
+});
+
+describe("visibleInstalledSkills", () => {
+  const s = (name: string, source: SkillInfo["source"], description: string | null = null) => ({
+    name,
+    description,
+    location: null,
+    source,
+  });
+  const all = [s("g1", "global"), s("builtin", "builtin"), s("p1", "project", "React helper")];
+
+  test("tanpa bawaan, project dulu, filter nama/deskripsi", () => {
+    expect(visibleInstalledSkills(all, "").map((x) => x.name)).toEqual(["p1", "g1"]);
+    expect(visibleInstalledSkills(all, "react").map((x) => x.name)).toEqual(["p1"]);
+    expect(visibleInstalledSkills(all, "G1").map((x) => x.name)).toEqual(["g1"]);
+  });
+});

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

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { BASE_FREQUENCY, scaleFrequency } from "../tone";
+
+describe("scaleFrequency", () => {
+  test("penanda pertama = nada dasar, makin ke bawah makin tinggi", () => {
+    expect(scaleFrequency(0)).toBeCloseTo(BASE_FREQUENCY, 2);
+    const freqs = [0, 1, 2, 3, 4, 5, 6, 7].map((i) => scaleFrequency(i));
+    for (let i = 1; i < freqs.length; i++) {
+      expect(freqs[i]).toBeGreaterThan(freqs[i - 1] as number);
+    }
+  });
+
+  test("nada mayor: langkah ke-3 (fa) = 5 semiton, oktaf penuh = 2x dasar", () => {
+    expect(scaleFrequency(3)).toBeCloseTo(BASE_FREQUENCY * 2 ** (5 / 12), 2);
+    expect(scaleFrequency(7)).toBeCloseTo(BASE_FREQUENCY * 2, 2);
+  });
+
+  test("ditahan di dua oktaf: tidak melengking & tidak turun lagi", () => {
+    // Derajat ke-14 = do dua oktaf di atas dasar; di atas itu nadanya sama.
+    expect(scaleFrequency(14)).toBeCloseTo(BASE_FREQUENCY * 4, 2);
+    expect(scaleFrequency(20)).toBeCloseTo(scaleFrequency(14), 2);
+    expect(scaleFrequency(1000)).toBeCloseTo(scaleFrequency(14), 2);
+    // Tidak pernah menurun (rail panjang tetap terasa menaik).
+    let prev = 0;
+    for (let i = 0; i < 40; i++) {
+      const f = scaleFrequency(i);
+      expect(f).toBeGreaterThanOrEqual(prev);
+      expect(f).toBeLessThanOrEqual(BASE_FREQUENCY * 4 + 0.01);
+      prev = f;
+    }
+  });
+
+  test("index negatif / pecahan tetap aman", () => {
+    expect(scaleFrequency(-5)).toBeCloseTo(BASE_FREQUENCY, 2);
+    expect(scaleFrequency(1.9)).toBeCloseTo(scaleFrequency(1), 2);
+  });
+});

package/src/lib/__tests__/turns-delta.test.ts

@@ -0,0 +1,55 @@
+/**
+ * Unit test penerapan delta streaming di sisi Client (`appendMessagePartDelta`)
+ * — logika murni, meniru urutan event opencode 1.x: part dibuat dengan teks
+ * kosong (`message_part`), lalu teks bertambah lewat `message_part_delta`.
+ */
+import { describe, expect, test } from "bun:test";
+import type { SessionMessage } from "@/types";
+import { appendMessagePartDelta, upsertMessagePart } from "../turns";
+
+function base(): SessionMessage[] {
+  return upsertMessagePart([], "s1", "msg_a1", { type: "text", id: "prt_t1", text: "" });
+}
+
+describe("appendMessagePartDelta", () => {
+  test("menambahkan delta berurutan ke field part", () => {
+    let msgs = base();
+    for (const d of ["Ku", "cing ", "lucu."]) {
+      msgs = appendMessagePartDelta(msgs, "msg_a1", "prt_t1", "text", d);
+    }
+    expect(msgs[0]?.parts[0]?.text).toBe("Kucing lucu.");
+    expect(msgs[0]?.streaming).toBe(true);
+  });
+
+  test("field belum ada diperlakukan sebagai string kosong", () => {
+    const msgs = upsertMessagePart([], "s1", "msg_a1", { type: "reasoning", id: "prt_r1" });
+    const next = appendMessagePartDelta(msgs, "msg_a1", "prt_r1", "text", "pikir");
+    expect(next[0]?.parts[0]?.text).toBe("pikir");
+  });
+
+  test("pesan/part tak dikenal atau delta kosong -> array yang sama", () => {
+    const msgs = base();
+    expect(appendMessagePartDelta(msgs, "msg_x", "prt_t1", "text", "a")).toBe(msgs);
+    expect(appendMessagePartDelta(msgs, "msg_a1", "prt_x", "text", "a")).toBe(msgs);
+    expect(appendMessagePartDelta(msgs, "msg_a1", "prt_t1", "text", "")).toBe(msgs);
+  });
+
+  test("tidak memutasi state sebelumnya", () => {
+    const msgs = base();
+    const before = JSON.stringify(msgs);
+    appendMessagePartDelta(msgs, "msg_a1", "prt_t1", "text", "hai");
+    expect(JSON.stringify(msgs)).toBe(before);
+  });
+
+  test("snapshot final (message_part) menggantikan hasil akumulasi", () => {
+    let msgs = base();
+    msgs = appendMessagePartDelta(msgs, "msg_a1", "prt_t1", "text", "Kuc");
+    msgs = upsertMessagePart(msgs, "s1", "msg_a1", {
+      type: "text",
+      id: "prt_t1",
+      text: "Kucing lucu.",
+    });
+    expect(msgs[0]?.parts).toHaveLength(1);
+    expect(msgs[0]?.parts[0]?.text).toBe("Kucing lucu.");
+  });
+});

package/src/lib/agent-types.ts

@@ -0,0 +1,49 @@
+/**
+ * Tipe CLI_Agent yang bisa dipilih di UI (backend Session).
+ *
+ * - `opencode`    : server headless `opencode serve`.
+ * - `claude-code` : Claude Code lewat Claude Agent SDK (ikut settings user).
+ */
+import type { AgentType } from "@/types";
+
+export const AGENT_TYPES: readonly AgentType[] = ["opencode", "claude-code"];
+
+export const AGENT_TYPE_LABELS: Record<AgentType, string> = {
+  opencode: "OpenCode",
+  "claude-code": "Claude Code",
+};
+
+/**
+ * Agent terakhir yang dipakai untuk membuat Session (composer homepage &
+ * dialog New Session), diingat per perangkat. Kunci lama dipertahankan agar
+ * pilihan yang sudah tersimpan tetap terbaca.
+ */
+const PREFERRED_AGENT_KEY = "kcg-home-agent-type";
+
+/** Agent pilihan terakhir; default `opencode` (juga saat storage tak tersedia). */
+export function readPreferredAgentType(): AgentType {
+  try {
+    const saved =
+      typeof localStorage === "undefined" ? null : localStorage.getItem(PREFERRED_AGENT_KEY);
+    return saved === "claude-code" ? "claude-code" : "opencode";
+  } catch {
+    return "opencode";
+  }
+}
+
+/** Simpan agent pilihan; diam saja bila storage tak tersedia (mode privat). */
+export function storePreferredAgentType(agentType: AgentType): void {
+  try {
+    localStorage.setItem(PREFERRED_AGENT_KEY, agentType);
+  } catch {
+    // Pilihan tetap berlaku untuk kunjungan ini.
+  }
+}
+
+/**
+ * Query string `?agent=` untuk daftar model/agent Project. opencode tanpa
+ * query (default server) agar URL lama tidak berubah.
+ */
+export function agentQuery(agentType: AgentType): string {
+  return agentType === "claude-code" ? "?agent=claude-code" : "";
+}