kcg-code 0.1.0 → 0.2.0

package/src/server/services/claude-code-translate.ts

@@ -0,0 +1,370 @@
+/**
+ * Penerjemah pesan Claude Agent SDK -> event bergaya opencode.
+ *
+ * Session_Manager & TurnStream dibangun di atas event SSE opencode
+ * (`message.updated`, `message.part.updated`, `message.part.delta`,
+ * `session.idle`, `session.error`, `session.status`). Agar backend Claude
+ * Code bisa memakai jalur yang sama tanpa cabang khusus, setiap `SDKMessage`
+ * diterjemahkan ke event tersebut di sini — fungsi/kelas murni tanpa I/O.
+ *
+ * Pemetaan (terverifikasi terhadap stream SDK 0.3.x):
+ * - Satu turn = SATU pesan assistant lokal (`msg_<uuid>`); seluruh pesan API
+ *   Anthropic dalam turn (termasuk sub-agent) menjadi parts pesan itu.
+ * - `stream_event` text/thinking -> part `text`/`reasoning` + delta token.
+ *   Pesan `assistant` membawa blok yang SAMA secara utuh: blok teks dari
+ *   pesan API yang sudah di-stream dilewati agar tidak terduplikasi.
+ * - `tool_use` (dari pesan `assistant`, input lengkap) -> part `tool`
+ *   status running; `tool_result` (pesan `user`) -> status completed/error.
+ * - Nama tool & key input dinormalisasi ke gaya opencode (`Read` -> `read`,
+ *   `file_path` -> `filePath`) agar renderer, Reference, dan label izin
+ *   yang sudah ada langsung bekerja.
+ * - `system/api_retry` -> `session.status` retry (banner retry provider).
+ */
+import { randomUUID } from "node:crypto";
+import type { MessagePart } from "../../types";
+import type { OpenCodeEvent, OpenCodeTodo } from "./opencode-client";
+
+/** Batas panjang output tool yang disimpan (hindari blob raksasa di DB). */
+export const TOOL_OUTPUT_MAX_LENGTH = 50_000;
+
+/** Nama tool Claude Code -> nama tool gaya opencode (dipakai UI). */
+const TOOL_NAMES: Record<string, string> = {
+  Read: "read",
+  Write: "write",
+  Edit: "edit",
+  MultiEdit: "edit",
+  NotebookEdit: "edit",
+  Bash: "bash",
+  BashOutput: "bash",
+  Glob: "glob",
+  Grep: "grep",
+  LS: "list",
+  WebFetch: "webfetch",
+  WebSearch: "websearch",
+  TodoWrite: "todowrite",
+  Task: "task",
+  Agent: "task",
+  Skill: "skill",
+  AskUserQuestion: "question",
+};
+
+/** Nama tool untuk part `tool` (tool MCP `mcp__server__tool` apa adanya). */
+export function toolName(name: string): string {
+  return TOOL_NAMES[name] ?? (name.startsWith("mcp__") ? name : name.toLowerCase());
+}
+
+/**
+ * Nama permission gaya opencode untuk kartu izin — `parsePermissionTitle`
+ * di UI memetakan nama ini ke label & tingkat risiko. Tool penulis file
+ * dikelompokkan ke `edit` seperti di opencode.
+ */
+export function permissionName(name: string): string {
+  const mapped = toolName(name);
+  return mapped === "write" ? "edit" : mapped;
+}
+
+/** Salinan input tool dengan alias key gaya opencode (`filePath`). */
+export function normalizeToolInput(input: unknown): Record<string, unknown> {
+  if (typeof input !== "object" || input === null) return {};
+  const out: Record<string, unknown> = { ...(input as Record<string, unknown>) };
+  const path = out.file_path ?? out.notebook_path;
+  if (typeof path === "string" && out.filePath === undefined) out.filePath = path;
+  return out;
+}
+
+/** Target utama tool call untuk judul kartu izin (path/perintah/url). */
+export function permissionTarget(input: Record<string, unknown>): string | null {
+  for (const key of ["file_path", "notebook_path", "command", "url", "pattern", "path", "query"]) {
+    const v = input[key];
+    if (typeof v === "string" && v.trim() !== "") return v;
+  }
+  return null;
+}
+
+/** Task list dari input `TodoWrite` (`{ todos: [{ content, status }] }`). */
+export function todosFromInput(input: unknown): OpenCodeTodo[] | null {
+  if (typeof input !== "object" || input === null) return null;
+  const raw = (input as { todos?: unknown }).todos;
+  if (!Array.isArray(raw)) return null;
+  const out: OpenCodeTodo[] = [];
+  for (const t of raw) {
+    if (typeof t !== "object" || t === null) continue;
+    const { content, status, priority } = t as Record<string, unknown>;
+    if (typeof content !== "string") continue;
+    out.push({
+      content,
+      status: typeof status === "string" ? status : "pending",
+      // TodoWrite Claude Code tidak punya prioritas — UI tetap butuh nilai.
+      priority: typeof priority === "string" ? priority : "medium",
+    });
+  }
+  return out;
+}
+
+/** Teks dari konten `tool_result` (string atau array blok). */
+export function toolResultText(content: unknown): string {
+  let text: string;
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    text = content
+      .map((b) => {
+        if (typeof b !== "object" || b === null) return "";
+        const block = b as { type?: unknown; text?: unknown };
+        if (block.type === "text" && typeof block.text === "string") return block.text;
+        if (block.type === "image") return "[image]";
+        return "";
+      })
+      .filter((s) => s !== "")
+      .join("\n");
+  } else {
+    text = "";
+  }
+  return text.length > TOOL_OUTPUT_MAX_LENGTH
+    ? `${text.slice(0, TOOL_OUTPUT_MAX_LENGTH)}\n… (truncated)`
+    : text;
+}
+
+/** Hasil sampingan satu pesan SDK yang perlu disimpan klien. */
+export interface TranslateEffects {
+  /** Task list terbaru (TodoWrite). */
+  todos?: OpenCodeTodo[];
+}
+
+/** Blok streaming yang sedang dibangun (text/reasoning). */
+interface StreamBlock {
+  part: MessagePart;
+  /**
+   * Part sudah dikirim. Blok baru dikirim saat token pertama tiba: thinking
+   * yang disembunyikan provider (tanpa delta) tidak menjadi part kosong.
+   */
+  emitted: boolean;
+}
+
+type Msg = Record<string, unknown>;
+
+/**
+ * Penerjemah stateful per Session Claude Code. `emit` menerima event gaya
+ * opencode yang sudah memuat `sessionID`.
+ */
+export class ClaudeTurnTranslator {
+  /** Id pesan assistant lokal turn aktif; null = belum ada turn. */
+  private messageId: string | null = null;
+  /** Id pesan API Anthropic yang teksnya sudah di-stream (lewati di `assistant`). */
+  private readonly streamed = new Set<string>();
+  /** Blok streaming aktif per pesan API: `${apiMsgId}:${index}` -> part. */
+  private readonly blocks = new Map<string, StreamBlock>();
+  /** Pesan API aktif per jalur (induk / sub-agent `parent_tool_use_id`). */
+  private readonly currentApiMsg = new Map<string, string>();
+  /** Part tool per tool_use id (untuk melengkapi hasilnya). */
+  private readonly tools = new Map<string, MessagePart>();
+
+  constructor(
+    private readonly sessionID: string,
+    private readonly emit: (ev: OpenCodeEvent) => void,
+    private readonly now: () => number = Date.now,
+  ) {}
+
+  /** Mulai turn baru: pesan assistant lokal baru + `message.updated`. */
+  beginTurn(): void {
+    this.messageId = `msg_${randomUUID()}`;
+    this.streamed.clear();
+    this.blocks.clear();
+    this.currentApiMsg.clear();
+    this.tools.clear();
+    this.emit({
+      type: "message.updated",
+      sessionID: this.sessionID,
+      info: { id: this.messageId, role: "assistant" },
+    });
+  }
+
+  /** Pastikan ada pesan assistant (event datang tanpa prompt dari bridge). */
+  private ensureTurn(): string {
+    if (this.messageId === null) this.beginTurn();
+    return this.messageId as string;
+  }
+
+  private emitPart(part: MessagePart): void {
+    const messageID = this.ensureTurn();
+    this.emit({
+      type: "message.part.updated",
+      sessionID: this.sessionID,
+      part: { ...part, messageID },
+    });
+  }
+
+  private emitDelta(partID: string, delta: string): void {
+    if (this.messageId === null || delta === "") return;
+    this.emit({
+      type: "message.part.delta",
+      sessionID: this.sessionID,
+      messageID: this.messageId,
+      partID,
+      field: "text",
+      delta,
+    });
+  }
+
+  /** Terjemahkan satu pesan SDK; kembalikan efek samping untuk klien. */
+  handle(msg: Msg): TranslateEffects {
+    switch (msg.type) {
+      case "stream_event":
+        this.handleStreamEvent(msg);
+        return {};
+      case "assistant":
+        return this.handleAssistant(msg);
+      case "user":
+        this.handleUser(msg);
+        return {};
+      case "system":
+        if (msg.subtype === "api_retry") this.handleRetry(msg);
+        return {};
+      default:
+        return {};
+    }
+  }
+
+  private handleStreamEvent(msg: Msg): void {
+    const ev = msg.event as Msg | undefined;
+    if (!ev || typeof ev.type !== "string") return;
+    const lane = typeof msg.parent_tool_use_id === "string" ? msg.parent_tool_use_id : "";
+    if (ev.type === "message_start") {
+      const id = (ev.message as { id?: unknown } | undefined)?.id;
+      if (typeof id === "string") {
+        this.currentApiMsg.set(lane, id);
+        this.streamed.add(id);
+      }
+      return;
+    }
+    const apiMsgId = this.currentApiMsg.get(lane);
+    if (apiMsgId === undefined || typeof ev.index !== "number") return;
+    const key = `${apiMsgId}:${ev.index}`;
+    if (ev.type === "content_block_start") {
+      const block = ev.content_block as { type?: unknown } | undefined;
+      const type =
+        block?.type === "text" ? "text" : block?.type === "thinking" ? "reasoning" : null;
+      if (type === null) return; // tool_use dirakit dari pesan `assistant`
+      const part: MessagePart = {
+        id: `prt_${apiMsgId}_${ev.index}`,
+        type,
+        text: "",
+        time: { start: this.now() },
+      };
+      this.blocks.set(key, { part, emitted: false });
+      return;
+    }
+    const cur = this.blocks.get(key);
+    if (!cur) return;
+    if (ev.type === "content_block_delta") {
+      const delta = ev.delta as { type?: unknown; text?: unknown; thinking?: unknown } | undefined;
+      const piece =
+        delta?.type === "text_delta" && typeof delta.text === "string"
+          ? delta.text
+          : delta?.type === "thinking_delta" && typeof delta.thinking === "string"
+            ? delta.thinking
+            : "";
+      if (piece === "") return;
+      if (!cur.emitted) {
+        cur.emitted = true;
+        this.emitPart(cur.part);
+      }
+      cur.part = { ...cur.part, text: `${cur.part.text ?? ""}${piece}` };
+      this.emitDelta(cur.part.id as string, piece);
+      return;
+    }
+    if (ev.type === "content_block_stop") {
+      this.blocks.delete(key);
+      if (!cur.emitted) return; // tanpa token sama sekali
+      cur.part = { ...cur.part, time: { ...cur.part.time, end: this.now() } };
+      this.emitPart(cur.part);
+    }
+  }
+
+  private handleAssistant(msg: Msg): TranslateEffects {
+    const message = msg.message as { id?: unknown; content?: unknown } | undefined;
+    if (!message || !Array.isArray(message.content)) return {};
+    const apiMsgId = typeof message.id === "string" ? message.id : null;
+    const wasStreamed = apiMsgId !== null && this.streamed.has(apiMsgId);
+    const uuid = typeof msg.uuid === "string" ? msg.uuid : randomUUID();
+    const effects: TranslateEffects = {};
+    message.content.forEach((raw, i) => {
+      if (typeof raw !== "object" || raw === null) return;
+      const block = raw as Msg;
+      if (block.type === "text" || block.type === "thinking") {
+        // Sudah tampil lewat stream_event — jangan diulang.
+        if (wasStreamed) return;
+        const text = block.type === "text" ? block.text : block.thinking;
+        if (typeof text !== "string" || text === "") return;
+        const t = this.now();
+        this.emitPart({
+          id: `prt_${uuid}_${i}`,
+          type: block.type === "text" ? "text" : "reasoning",
+          text,
+          time: { start: t, end: t },
+        });
+        return;
+      }
+      if (block.type === "tool_use" || block.type === "server_tool_use") {
+        if (typeof block.id !== "string" || typeof block.name !== "string") return;
+        const input = normalizeToolInput(block.input);
+        const part: MessagePart = {
+          id: `prt_${block.id}`,
+          type: "tool",
+          tool: toolName(block.name),
+          callID: block.id,
+          state: { status: "running", input, time: { start: this.now() } },
+        };
+        this.tools.set(block.id, part);
+        this.emitPart(part);
+        if (block.name === "TodoWrite") {
+          const todos = todosFromInput(block.input);
+          if (todos) effects.todos = todos;
+        }
+      }
+    });
+    return effects;
+  }
+
+  private handleUser(msg: Msg): void {
+    const message = msg.message as { content?: unknown } | undefined;
+    if (!message || !Array.isArray(message.content)) return;
+    for (const raw of message.content) {
+      if (typeof raw !== "object" || raw === null) continue;
+      const block = raw as Msg;
+      if (block.type !== "tool_result" || typeof block.tool_use_id !== "string") continue;
+      const part = this.tools.get(block.tool_use_id);
+      if (!part) continue;
+      const prev = (part.state ?? {}) as { input?: Record<string, unknown>; time?: unknown };
+      const startedAt =
+        typeof prev.time === "object" && prev.time !== null
+          ? (prev.time as { start?: number }).start
+          : undefined;
+      const done: MessagePart = {
+        ...part,
+        state: {
+          status: block.is_error === true ? "error" : "completed",
+          input: prev.input,
+          output: toolResultText(block.content),
+          time: { start: startedAt, end: this.now() },
+        },
+      };
+      this.tools.set(block.tool_use_id, done);
+      this.emitPart(done);
+    }
+  }
+
+  private handleRetry(msg: Msg): void {
+    const status = typeof msg.error_status === "number" ? ` (HTTP ${msg.error_status})` : "";
+    const reason = typeof msg.error === "string" ? msg.error.replace(/_/g, " ") : "request failed";
+    this.emit({
+      type: "session.status",
+      sessionID: this.sessionID,
+      status: {
+        type: "retry",
+        attempt: typeof msg.attempt === "number" ? msg.attempt : undefined,
+        message: `${reason}${status}`,
+      },
+    });
+  }
+}

package/src/server/services/claude-mcp.ts

@@ -0,0 +1,122 @@
+/**
+ * Daftar MCP server Claude Code — dibaca dari config di disk.
+ *
+ * Status MCP Claude Code hanya diketahui dari proses `claude` yang sedang
+ * berjalan (`mcpServerStatus()` / pesan `system/init`). Tanpa proses itu
+ * daftarnya kosong, padahal server sudah dikonfigurasi. Modul ini membaca
+ * NAMA server dari lokasi yang sama dengan CLI `claude` (isi config — env,
+ * header, token — tidak pernah dibaca keluar):
+ * - project : `<project>/.mcp.json` -> `mcpServers`
+ * - local   : `<config>/.claude.json` -> `projects[<path>].mcpServers`
+ * - user    : `<config>/.claude.json` -> `mcpServers`
+ * `<config>` = `CLAUDE_CONFIG_DIR` bila diset, selain itu `HOME` dari env
+ * proses `claude` (fallback home user OS).
+ *
+ * Server `.mcp.json` yang ditolak user (`disabledMcpjsonServers`) bertanda
+ * `disabled`; lainnya `unknown` sampai status live tersedia
+ * (`mergeClaudeMcp`).
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { McpServerInfo } from "./opencode-client";
+
+export type ClaudeMcpScope = "project" | "local" | "user";
+
+export interface ClaudeMcpConfigEntry {
+  name: string;
+  scope: ClaudeMcpScope;
+  /** Server `.mcp.json` yang ditolak user di Claude Code. */
+  disabled: boolean;
+}
+
+/** Path `.claude.json` untuk `env` tertentu. */
+export function claudeJsonPath(env: Record<string, string | undefined>): string {
+  const configDir = env.CLAUDE_CONFIG_DIR?.trim();
+  if (configDir) return join(configDir, ".claude.json");
+  return join(env.HOME?.trim() || homedir(), ".claude.json");
+}
+
+function serverNames(value: unknown): string[] {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return [];
+  return Object.keys(value).filter((k) => k !== "");
+}
+
+function stringList(value: unknown): Set<string> {
+  return new Set(Array.isArray(value) ? value.filter((v) => typeof v === "string") : []);
+}
+
+/**
+ * Gabungkan isi `.mcp.json` dan `.claude.json` (sudah di-parse) menjadi
+ * daftar unik per nama. Prioritas sama dengan Claude Code: local > project >
+ * user. Murni — diuji.
+ */
+export function parseClaudeMcpConfig(
+  projectPath: string,
+  mcpJson: unknown,
+  claudeJson: unknown,
+): ClaudeMcpConfigEntry[] {
+  const root = (typeof claudeJson === "object" && claudeJson !== null ? claudeJson : {}) as {
+    mcpServers?: unknown;
+    projects?: Record<string, unknown>;
+  };
+  const projectState = (root.projects?.[projectPath.replace(/\/+$/, "")] ?? {}) as {
+    mcpServers?: unknown;
+    disabledMcpjsonServers?: unknown;
+  };
+  const rejected = stringList(projectState.disabledMcpjsonServers);
+
+  const byName = new Map<string, ClaudeMcpConfigEntry>();
+  const add = (names: string[], scope: ClaudeMcpScope) => {
+    for (const name of names) {
+      if (!byName.has(name)) {
+        byName.set(name, { name, scope, disabled: scope === "project" && rejected.has(name) });
+      }
+    }
+  };
+  add(serverNames(projectState.mcpServers), "local");
+  add(serverNames((mcpJson as { mcpServers?: unknown } | null)?.mcpServers), "project");
+  add(serverNames(root.mcpServers), "user");
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function readJson(path: string): Promise<unknown> {
+  try {
+    const file = Bun.file(path);
+    if (!(await file.exists())) return null;
+    return await file.json();
+  } catch {
+    // File rusak / tak terbaca — anggap tidak ada server dari sumber ini.
+    return null;
+  }
+}
+
+/** Baca config MCP Claude Code untuk sebuah Project dari disk. */
+export async function readClaudeMcpConfig(
+  projectPath: string,
+  env: Record<string, string | undefined>,
+): Promise<ClaudeMcpConfigEntry[]> {
+  const [mcpJson, claudeJson] = await Promise.all([
+    readJson(join(projectPath, ".mcp.json")),
+    readJson(claudeJsonPath(env)),
+  ]);
+  return parseClaudeMcpConfig(projectPath, mcpJson, claudeJson);
+}
+
+/**
+ * Daftar akhir: server dari config + status live bila ada. Server live yang
+ * tidak ada di config (plugin, konektor claude.ai) tetap ikut. Murni — diuji.
+ */
+export function mergeClaudeMcp(
+  configured: readonly ClaudeMcpConfigEntry[],
+  live: readonly McpServerInfo[],
+): McpServerInfo[] {
+  const liveByName = new Map(live.map((s) => [s.name, s]));
+  const out: McpServerInfo[] = configured.map((c) => {
+    const hit = liveByName.get(c.name);
+    if (hit) return hit;
+    return { name: c.name, status: c.disabled ? "disabled" : "unknown", error: null };
+  });
+  const known = new Set(configured.map((c) => c.name));
+  for (const s of live) if (!known.has(s.name)) out.push(s);
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}

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

@@ -0,0 +1,102 @@
+/**
+ * Daftar skill Claude Code — dibaca langsung dari disk.
+ *
+ * Claude Code tidak punya server headless untuk ditanya (beda dengan
+ * `GET /skill` opencode), jadi skill dipindai dari lokasi yang sama dengan
+ * yang dibaca CLI `claude`:
+ * - Project : `<project>/.claude/skills/<nama>/SKILL.md`
+ * - Global  : `<CLAUDE_CONFIG_DIR | ~/.claude>/skills/<nama>/SKILL.md`
+ *
+ * CLI `skills` (`--agent claude-code`) memasang ke `.claude/skills/` berupa
+ * symlink ke `.agents/skills/`, jadi symlink diikuti. Skill dari plugin
+ * Claude Code tidak ikut (tidak dipasang lewat halaman Skills).
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { SkillInfo, SkillSource } from "./opencode-client";
+
+/** Direktori skill global Claude Code untuk `env` tertentu. */
+export function claudeGlobalSkillsDir(env: Record<string, string | undefined>): string {
+  // `HOME` dari env proses `claude` (sama dengan yang dipakai CLI-nya).
+  const configDir = env.CLAUDE_CONFIG_DIR?.trim() || join(env.HOME?.trim() || homedir(), ".claude");
+  return join(configDir, "skills");
+}
+
+function unquote(v: string): string {
+  const t = v.trim();
+  if (t.length >= 2 && (t[0] === '"' || t[0] === "'") && t.at(-1) === t[0]) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+
+/**
+ * Ambil `name` & `description` dari frontmatter YAML SKILL.md. Cukup untuk
+ * bentuk yang umum: nilai satu baris (boleh berkutip) atau blok `>` / `|`
+ * yang baris lanjutannya menjorok. Murni — diuji.
+ */
+export function parseSkillFrontmatter(text: string): {
+  name: string | null;
+  description: string | null;
+} {
+  const lines = text.replace(/^/, "").split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return { name: null, description: null };
+  const fields: Record<string, string> = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "---") break;
+    const m = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(line);
+    if (!m?.[1]) continue;
+    const key = m[1];
+    let value = m[2] ?? "";
+    if (value === "" || /^[>|][+-]?$/.test(value.trim())) {
+      // Blok berlapis: kumpulkan baris menjorok berikutnya.
+      const parts: string[] = [];
+      while (i + 1 < lines.length && /^\s+\S/.test(lines[i + 1] ?? "")) {
+        i++;
+        parts.push((lines[i] ?? "").trim());
+      }
+      value = parts.join(" ");
+    }
+    fields[key] = unquote(value);
+  }
+  const str = (v: string | undefined) => (v && v !== "" ? v : null);
+  return { name: str(fields.name), description: str(fields.description) };
+}
+
+async function scanDir(root: string, source: SkillSource): Promise<SkillInfo[]> {
+  const out: SkillInfo[] = [];
+  const glob = new Bun.Glob("*/SKILL.md");
+  try {
+    for await (const rel of glob.scan({ cwd: root, followSymlinks: true, onlyFiles: true })) {
+      const location = join(root, rel);
+      const dirName = rel.split("/")[0] ?? rel;
+      let meta: ReturnType<typeof parseSkillFrontmatter> = { name: null, description: null };
+      try {
+        meta = parseSkillFrontmatter(await Bun.file(location).text());
+      } catch {
+        // SKILL.md tak terbaca (symlink rusak, izin) — tetap tampil pakai nama folder.
+      }
+      out.push({ name: meta.name ?? dirName, description: meta.description, location, source });
+    }
+  } catch {
+    // Direktori belum ada — tidak ada skill.
+  }
+  return out;
+}
+
+/**
+ * Skill Claude Code untuk sebuah Project (Project + global), terurut nama.
+ * Nama yang sama di dua lokasi tetap tampil keduanya (dibedakan `source`),
+ * sama seperti daftar opencode.
+ */
+export async function listClaudeSkills(
+  projectPath: string,
+  globalDir: string,
+): Promise<SkillInfo[]> {
+  const [project, global] = await Promise.all([
+    scanDir(join(projectPath, ".claude", "skills"), "project"),
+    scanDir(globalDir, "global"),
+  ]);
+  return [...project, ...global].sort((a, b) => a.name.localeCompare(b.name));
+}