kcg-code 0.1.0 → 0.2.0

package/src/server/services/__tests__/claude-skills.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Unit test pemindai skill Claude Code (src/server/services/claude-skills.ts)
+ * — frontmatter SKILL.md dan pemindaian `.claude/skills` di direktori temp.
+ */
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { claudeGlobalSkillsDir, listClaudeSkills, parseSkillFrontmatter } from "../claude-skills";
+
+function writeSkill(dir: string, body: string): void {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "SKILL.md"), body);
+}
+
+describe("parseSkillFrontmatter", () => {
+  test("nilai satu baris, berkutip maupun tidak", () => {
+    expect(
+      parseSkillFrontmatter('---\nname: pdf\ndescription: "Read PDFs: fast"\n---\n# PDF'),
+    ).toEqual({ name: "pdf", description: "Read PDFs: fast" });
+  });
+
+  test("blok `>` digabung menjadi satu baris", () => {
+    expect(
+      parseSkillFrontmatter("---\nname: x\ndescription: >\n  first line\n  second line\n---\n"),
+    ).toEqual({ name: "x", description: "first line second line" });
+  });
+
+  test("tanpa frontmatter -> null", () => {
+    expect(parseSkillFrontmatter("# Just markdown")).toEqual({ name: null, description: null });
+  });
+});
+
+describe("listClaudeSkills", () => {
+  test("Project + global, ikuti symlink, fallback nama folder", async () => {
+    const root = mkdtempSync(join(tmpdir(), "kcg-cc-skills-"));
+    const project = join(root, "proj");
+    const global = join(root, "home-skills");
+    // Pola CLI `skills --agent claude-code`: isi di .agents/skills, symlink di .claude/skills.
+    writeSkill(join(project, ".agents/skills/linked"), "---\nname: linked\ndescription: L\n---\n");
+    mkdirSync(join(project, ".claude/skills"), { recursive: true });
+    symlinkSync(join(project, ".agents/skills/linked"), join(project, ".claude/skills/linked"));
+    writeSkill(join(project, ".claude/skills/plain"), "no frontmatter");
+    writeSkill(join(global, "global-one"), "---\nname: global-one\n---\n");
+
+    const skills = await listClaudeSkills(project, global);
+    expect(skills.map((s) => [s.name, s.source, s.description])).toEqual([
+      ["global-one", "global", null],
+      ["linked", "project", "L"],
+      ["plain", "project", null],
+    ]);
+    expect(skills[1]?.location).toBe(join(project, ".claude/skills/linked/SKILL.md"));
+  });
+
+  test("direktori tidak ada -> daftar kosong", async () => {
+    expect(await listClaudeSkills("/nonexistent-kcg", "/nonexistent-kcg-global")).toEqual([]);
+  });
+
+  test("claudeGlobalSkillsDir menghormati CLAUDE_CONFIG_DIR", () => {
+    expect(claudeGlobalSkillsDir({ CLAUDE_CONFIG_DIR: "/cfg" })).toBe("/cfg/skills");
+    expect(claudeGlobalSkillsDir({})).toEndWith("/.claude/skills");
+  });
+});

package/src/server/services/__tests__/session-manager.test.ts

@@ -3467,3 +3467,43 @@ test("deleteSession membersihkan lampiran gambar Session", async () => {
     h.close();
   }
 });
+
+test("Session claude-code memakai backend Claude Code; opencode tidak tersentuh", async () => {
+  const claude = makeFakeServers();
+  const h = freshHarnessWithHooks({}, {}, { claudeServers: claude.manager });
+  try {
+    const sid = await createSession(h, "claude-code");
+    expect(claude.ensureCalls).toHaveLength(1);
+    expect(h.fake.ensureCalls).toHaveLength(0);
+    const cc = claude.clients.get("p1");
+    if (!cc) throw new Error("claude client tidak ada");
+
+    expect((await h.sm.sendFreeTextInput(sid, "halo")).ok).toBe(true);
+    await flush();
+    expect(cc.calls).toContain("promptAsync:halo");
+
+    // Event dari backend Claude Code memetakan ke Session lokal yang sama.
+    cc.emit({
+      type: "permission.asked",
+      sessionID: "ses_remote1",
+      requestID: "per_cc",
+      permission: "bash",
+      patterns: ["ls"],
+    });
+    expect(h.prompts.map((p) => p.id)).toEqual(["per_cc"]);
+    expect((await h.sm.resolvePrompt(sid, "per_cc", "approve")).ok).toBe(true);
+    expect(cc.calls).toContain("replyPermission:per_cc:once");
+
+    // Daftar model per backend + task list dibaca dari session remote.
+    expect((await h.sm.listModels("p1", "claude-code")).ok).toBe(true);
+    expect(cc.calls).toContain("listModels");
+    expect((await h.sm.sessionContext(sid)).ok).toBe(true);
+    expect(cc.calls).toContain("listTodos:ses_remote1");
+    expect(h.fake.ensureCalls).toHaveLength(0);
+
+    expect((await h.sm.releaseProject("p1")).ok).toBe(true);
+    expect(claude.stopped).toContain("p1");
+  } finally {
+    h.close();
+  }
+});

package/src/server/services/__tests__/skill-install-jobs.test.ts

@@ -12,6 +12,8 @@ interface Harness {
   release: (res: Result<InstallResult>) => void;
   emit: (line: string) => void;
   refreshCalls: string[];
+  /** Agent yang diteruskan ke `registry.install` per panggilan. */
+  installAgents: (readonly string[] | undefined)[];
 }
 
 /**
@@ -23,11 +25,13 @@ function harness(refreshed = true): Harness {
   let emitFn: (line: string) => void = () => {};
   let releaseFn: (res: Result<InstallResult>) => void = () => {};
   const refreshCalls: string[] = [];
+  const installAgents: (readonly string[] | undefined)[] = [];
   const registry: SkillsRegistry = {
     search: async () => ({ ok: true, data: [] }),
     audit: async () => ({ ok: true, data: { audits: null, overall: null } }),
-    install: (_path, _source, _skill, onLine, signal) =>
+    install: (_path, _source, _skill, onLine, signal, agentTypes) =>
       new Promise((resolve) => {
+        installAgents.push(agentTypes);
         emitFn = (l) => onLine?.(l);
         releaseFn = resolve;
         signal?.addEventListener("abort", () =>
@@ -37,8 +41,8 @@ function harness(refreshed = true): Harness {
   };
   const jobs = createSkillInstallJobs({
     registry,
-    refreshSkills: async (projectId) => {
-      refreshCalls.push(projectId);
+    refreshSkills: async (projectId, agentType) => {
+      refreshCalls.push(agentType === "opencode" ? projectId : `${projectId}:${agentType}`);
       return { ok: true, data: { refreshed } };
     },
     validate: (source, skill) => source === "a/b" && !skill.startsWith("-"),
@@ -52,6 +56,7 @@ function harness(refreshed = true): Harness {
     release: (r) => releaseFn(r),
     emit: (l) => emitFn(l),
     refreshCalls,
+    installAgents,
   };
 }
 
@@ -64,6 +69,20 @@ const input = {
 };
 
 describe("createSkillInstallJobs", () => {
+  test("agentTypes diteruskan ke instalasi & refresh tiap agent (default opencode)", async () => {
+    const h = harness();
+    const a = h.jobs.start({ ...input, agentTypes: ["opencode", "claude-code"] });
+    expect(a.ok && a.data.agentTypes).toEqual(["opencode", "claude-code"]);
+    h.release({ ok: true, data: { name: "c", path: null } });
+    if (a.ok) await h.jobs.settled(a.data.id);
+    const b = h.jobs.start(input);
+    expect(b.ok && b.data.agentTypes).toEqual(["opencode"]);
+    h.release({ ok: true, data: { name: "c", path: null } });
+    if (b.ok) await h.jobs.settled(b.data.id);
+    expect(h.installAgents).toEqual([["opencode", "claude-code"], ["opencode"]]);
+    expect(h.refreshCalls).toEqual(["p1", "p1:claude-code", "p1"]);
+  });
+
   test("job berjalan, log bertahap via from, sukses + refresh", async () => {
     const h = harness();
     const started = h.jobs.start(input);

package/src/server/services/__tests__/skills-registry.test.ts

@@ -146,6 +146,12 @@ describe("parsing", () => {
     ]);
   });
 
+  test("buildInstallArgs: beberapa agent setelah satu --agent", () => {
+    const args = buildInstallArgs("a/b", "c", ["opencode", "claude-code"]);
+    const i = args.indexOf("--agent");
+    expect(args.slice(i, i + 4)).toEqual(["--agent", "opencode", "claude-code", "-y"]);
+  });
+
   test("parseInstallOutput: JSON setelah teks lain; status harus installed/updated", () => {
     const ok = parseInstallOutput(
       'log line\n[{"name":"c","status":"installed","path":"/p/.agents/skills/c"}]',