@aliyunrds/ctxdb 0.0.10 → 1.0.0-beta.1

package/dist/opencode/index.js

@@ -0,0 +1,630 @@
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_BASE_URL = "https://context-database.aliyuncs.com";
+var DEFAULT_USER_ID = "default";
+var DEFAULT_TOP_K = 5;
+var DEFAULT_THRESHOLD = 0.4;
+var DEFAULT_KNOWLEDGE_TOP_K = 6;
+var DEFAULT_KB_CATALOG_INJECTION = "session_start";
+function defaultPath(env) {
+  if (env.CTXDB_CONFIG_PATH) return env.CTXDB_CONFIG_PATH;
+  return join(homedir(), ".ctxdb", "ctxdb.json");
+}
+function coerceInt(v, fallback) {
+  if (v === null || v === void 0 || v === "") return fallback;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? Math.trunc(n) : fallback;
+}
+function coerceFloat(v, fallback) {
+  if (v === null || v === void 0 || v === "") return fallback;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+function coerceBool(v, fallback) {
+  if (typeof v === "boolean") return v;
+  if (v === void 0 || v === null) return fallback;
+  return Boolean(v);
+}
+function coerceKbCatalogInjection(v) {
+  if (v === "session_start" || v === "user_prompt_submit" || v === "off") return v;
+  return DEFAULT_KB_CATALOG_INJECTION;
+}
+function readRaw(path) {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function agentRaw(raw) {
+  if (!(raw.version === 2)) return {};
+  const agents = raw.agents;
+  if (!agents || typeof agents !== "object" || Array.isArray(agents)) return {};
+  const section = agents.opencode;
+  if (!section || typeof section !== "object" || Array.isArray(section)) return {};
+  return section;
+}
+function applyEnv(cfg, env) {
+  if (env.CTXDB_API_KEY) cfg.apiKey = env.CTXDB_API_KEY;
+  if (env.CTXDB_BASE_URL) cfg.baseUrl = env.CTXDB_BASE_URL.replace(/\/+$/, "");
+  if (env.CTXDB_USER_ID) cfg.userId = env.CTXDB_USER_ID;
+  return cfg;
+}
+function loadOpencodeConfig(options = {}) {
+  const env = options.env ?? process.env;
+  const path = options.path ?? defaultPath(env);
+  const raw = readRaw(path);
+  const section = agentRaw(raw);
+  const cfg = {
+    apiKey: typeof section.api_key === "string" && section.api_key ? section.api_key : null,
+    baseUrl: typeof section.base_url === "string" && section.base_url ? String(section.base_url).replace(/\/+$/, "") : DEFAULT_BASE_URL,
+    userId: typeof section.user_id === "string" && section.user_id ? section.user_id : DEFAULT_USER_ID,
+    autoCapture: coerceBool(section.auto_capture, true),
+    autoRecall: coerceBool(section.auto_recall, true),
+    warmupRecall: coerceBool(section.warmup_recall, false),
+    recallKnowledge: coerceBool(section.recall_knowledge, false),
+    topK: coerceInt(section.top_k, DEFAULT_TOP_K),
+    threshold: coerceFloat(section.threshold, DEFAULT_THRESHOLD),
+    knowledgeTopK: coerceInt(section.knowledge_top_k, DEFAULT_KNOWLEDGE_TOP_K),
+    debug: coerceBool(section.debug, false),
+    kbCatalogInjection: coerceKbCatalogInjection(section.kb_catalog_injection)
+  };
+  return applyEnv(cfg, env);
+}
+function isConfigured(cfg) {
+  return Boolean(cfg.apiKey && cfg.baseUrl);
+}
+
+// src/http-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var CtxdbHttpError = class extends Error {
+  status;
+  path;
+  constructor(path, status, message) {
+    super(message);
+    this.name = "CtxdbHttpError";
+    this.path = path;
+    this.status = status;
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  userAgent;
+  fetchImpl;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.userAgent = opts.userAgent ?? "ctxdb-opencode-plugin/0.0.0";
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  }
+  headers(contentType) {
+    const h = {
+      "User-Agent": this.userAgent,
+      Connection: "close"
+    };
+    if (this.apiKey) h.Authorization = `Token ${this.apiKey}`;
+    if (contentType) h["Content-Type"] = contentType;
+    return h;
+  }
+  async get(path, params, options = {}) {
+    let url = `${this.baseUrl}${path}`;
+    if (params) {
+      const qs = new URLSearchParams();
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== void 0 && v !== null) qs.append(k, String(v));
+      }
+      const s = qs.toString();
+      if (s) url = `${url}?${s}`;
+    }
+    return this.request("GET", url, path, void 0, void 0, options.timeoutMs);
+  }
+  async postJson(path, body, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    return this.request("POST", url, path, JSON.stringify(body), "application/json", options.timeoutMs);
+  }
+  async request(method, url, path, body, contentType, timeoutMs) {
+    const effectiveTimeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), effectiveTimeout);
+    try {
+      let resp;
+      try {
+        resp = await this.fetchImpl(url, {
+          method,
+          headers: this.headers(contentType),
+          body,
+          signal: controller.signal
+        });
+      } catch (err) {
+        if (err?.name === "AbortError") {
+          throw new CtxdbHttpError(path, null, `timeout after ${effectiveTimeout}ms`);
+        }
+        throw new CtxdbHttpError(path, null, `network error: ${err?.message ?? err}`);
+      }
+      if (resp.status === 204) return {};
+      let text;
+      try {
+        text = await resp.text();
+      } catch (err) {
+        throw new CtxdbHttpError(path, resp.status, `body read failed: ${err?.message ?? err}`);
+      }
+      if (!resp.ok) {
+        throw new CtxdbHttpError(path, resp.status, extractDetail(text) || `HTTP ${resp.status}`);
+      }
+      if (!text) return {};
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function extractDetail(text) {
+  if (!text) return "";
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      for (const k of ["detail", "message", "error"]) {
+        const v = parsed[k];
+        if (typeof v === "string" && v) return v;
+      }
+      return JSON.stringify(parsed);
+    }
+    return String(parsed);
+  } catch {
+    return text;
+  }
+}
+
+// src/recall.ts
+import {
+  formatRecalledMemoriesBlock,
+  buildExternalKnowledgeBlock
+} from "@aliyunrds/ctxdb-shared";
+var EMPTY = { block: "", memoryCount: 0, knowledgeChunkCount: 0, reason: "" };
+function stripSystemReminders(raw) {
+  const cleaned = raw.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+  return cleaned || raw;
+}
+async function searchAndFormatRecall(prompt, cfg, client, timeoutMs) {
+  if (!prompt.trim()) return { ...EMPTY, reason: "empty_prompt" };
+  if (!cfg.baseUrl) return { ...EMPTY, reason: "config_incomplete" };
+  const body = {
+    query: stripSystemReminders(prompt),
+    user_id: cfg.userId,
+    top_k: cfg.topK,
+    threshold: cfg.threshold
+  };
+  if (cfg.recallKnowledge) {
+    body.knowledge = { enable: true, top_k: cfg.knowledgeTopK };
+  }
+  let resp;
+  try {
+    resp = await client.postJson("/v3/memories/search/", body, { timeoutMs });
+  } catch (err) {
+    return { ...EMPTY, reason: `http_error: ${err.message}` };
+  }
+  if (!resp || typeof resp !== "object") {
+    return { ...EMPTY, reason: "bad_response_shape" };
+  }
+  const r = resp;
+  const memories = Array.isArray(r.results) ? r.results : Array.isArray(r.memories) ? r.memories : [];
+  const knowledge = r.knowledge && typeof r.knowledge === "object" ? r.knowledge : null;
+  const chunks = Array.isArray(knowledge?.chunks) ? knowledge.chunks : [];
+  const blocks = [];
+  if (memories.length > 0) blocks.push(formatRecalledMemoriesBlock(memories, cfg.userId));
+  if (chunks.length > 0) blocks.push(buildExternalKnowledgeBlock(chunks, cfg.userId));
+  if (blocks.length === 0) return { ...EMPTY, reason: "nothing_to_inject" };
+  return {
+    block: blocks.join("\n\n"),
+    memoryCount: memories.length,
+    knowledgeChunkCount: chunks.length,
+    reason: "ok"
+  };
+}
+
+// src/kb-catalog.ts
+var KB_LIST_PATH = "/v1/knowledge/knowledge_bases";
+function sanitizeKeyEntities(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const e of raw) {
+    if (typeof e !== "string") continue;
+    const cleaned = e.replace(/\s+/g, " ").trim();
+    if (cleaned) out.push(cleaned);
+  }
+  return out;
+}
+async function fetchKbCatalogBlock(client, timeoutMs, agent = "opencode") {
+  let resp;
+  try {
+    resp = await client.get(KB_LIST_PATH, void 0, { timeoutMs });
+  } catch {
+    return "";
+  }
+  let kbs = [];
+  if (Array.isArray(resp)) {
+    kbs = resp;
+  } else if (resp && typeof resp === "object") {
+    const o = resp;
+    const list = o.knowledge_bases ?? o.results;
+    if (Array.isArray(list)) kbs = list;
+  }
+  const active = kbs.filter((kb) => kb.status === "active" && typeof kb.name === "string" && kb.name);
+  if (active.length === 0) return "";
+  const lines = active.map((kb) => {
+    const ents = sanitizeKeyEntities(kb.key_entities);
+    return ents.length > 0 ? `\xB7 ${kb.name}: ${ents.join(", ")}` : `\xB7 ${kb.name}`;
+  });
+  return [
+    "<available-knowledge-bases>",
+    `When you identify that relevant information may exist in the knowledge bases below, you MUST run \`ctxdb kb search "<query>" --kb=<name> --agent=${agent}\` with targeted keywords after initial analysis to supplement and correct your approach. For keyword-based KB search, keep each single query focused: use at most 5 keywords or short phrases; run multiple targeted searches if more are needed. Knowledge bases:`,
+    ...lines,
+    "</available-knowledge-bases>"
+  ].join("\n");
+}
+
+// src/warmup.ts
+import { execSync } from "child_process";
+import { basename } from "path";
+function collectGitSignals(cwd) {
+  const result = { branch: "", recentCommits: [] };
+  try {
+    result.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      timeout: 500,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+  }
+  try {
+    const log = execSync("git log --oneline -3 --no-decorate", {
+      cwd,
+      timeout: 500,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (log) {
+      result.recentCommits = log.split("\n").map((l) => {
+        const idx = l.indexOf(" ");
+        return idx > 0 ? l.slice(idx + 1) : l;
+      });
+    }
+  } catch {
+  }
+  return result;
+}
+function buildWarmupQuery(cwd, git) {
+  const project = basename(cwd) || "unknown";
+  const parts = [`project: ${project}`];
+  if (git.branch) parts.push(`branch: ${git.branch}`);
+  if (git.recentCommits.length > 0) parts.push(`recent work: ${git.recentCommits.join("; ")}`);
+  return parts.join(", ");
+}
+
+// src/capture.ts
+import { createHash } from "crypto";
+import {
+  filterMessagesForExtraction,
+  selectTurnMessages
+} from "@aliyunrds/ctxdb-shared";
+var EMPTY2 = {
+  captured: false,
+  reason: "",
+  messageCount: 0,
+  fingerprint: null
+};
+function toParsedMessages(messages) {
+  const parsed = [];
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    const converted = toParsedMessage(m, i);
+    if (converted) parsed.push(converted);
+  }
+  return parsed;
+}
+function unwrapSessionMessagesResponse(resp) {
+  if (Array.isArray(resp)) return resp;
+  if (!resp || typeof resp !== "object") return [];
+  const root = resp;
+  if (Array.isArray(root.data)) return root.data;
+  if (root.data && typeof root.data === "object") {
+    const nested = root.data;
+    if (Array.isArray(nested.data)) return nested.data;
+  }
+  if (Array.isArray(root.messages)) return root.messages;
+  return [];
+}
+function toParsedMessage(m, index) {
+  if (!m || typeof m !== "object") return null;
+  const obj = m;
+  if (obj.info && typeof obj.info === "object" && Array.isArray(obj.parts)) {
+    const info = obj.info;
+    const role = info.role;
+    if (role !== "user" && role !== "assistant") return null;
+    const textChunks = [];
+    for (const rawPart of obj.parts) {
+      if (!rawPart || typeof rawPart !== "object") continue;
+      const p = rawPart;
+      if (p.type !== "text") continue;
+      if (p.synthetic === true || p.ignored === true) continue;
+      if (typeof p.text === "string" && p.text) textChunks.push(p.text);
+    }
+    const content = textChunks.join("\n").trim();
+    if (!content) return null;
+    const isSummary = role === "assistant" && info.summary === true;
+    return { role, content, index, isSummary };
+  }
+  if (obj.type === "user") {
+    const content = typeof obj.text === "string" ? obj.text.trim() : "";
+    return content ? { role: "user", content, index, isSummary: false } : null;
+  }
+  if (obj.type === "assistant" && Array.isArray(obj.content)) {
+    const textChunks = [];
+    for (const rawPart of obj.content) {
+      if (!rawPart || typeof rawPart !== "object") continue;
+      const p = rawPart;
+      if (p.type === "text" && typeof p.text === "string" && p.text) {
+        textChunks.push(p.text);
+      }
+    }
+    const content = textChunks.join("\n").trim();
+    return content ? { role: "assistant", content, index, isSummary: false } : null;
+  }
+  return null;
+}
+function fingerprintMessages(messages) {
+  const h = createHash("sha256");
+  for (const m of messages) {
+    h.update(m.role);
+    h.update("\0");
+    h.update(m.content);
+    h.update("
");
+  }
+  return h.digest("hex");
+}
+async function runCapture(messages, cfg, client, timeoutMs, lastFingerprint) {
+  if (!cfg.autoCapture) return { ...EMPTY2, reason: "auto_capture_disabled" };
+  if (!cfg.baseUrl) return { ...EMPTY2, reason: "config_incomplete" };
+  if (messages.length === 0) return { ...EMPTY2, reason: "empty_transcript" };
+  const parsed = toParsedMessages(messages);
+  if (parsed.length === 0) return { ...EMPTY2, reason: "transcript_no_text_parts" };
+  const turn = selectTurnMessages(parsed);
+  if (turn.length === 0) return { ...EMPTY2, reason: "empty_turn_slice" };
+  if (!turn.some((m) => m.role === "user")) return { ...EMPTY2, reason: "no_user_in_turn" };
+  if (!turn.some((m) => m.role === "assistant")) {
+    return { ...EMPTY2, reason: "no_assistant_in_turn" };
+  }
+  const raw = turn.map((m) => ({ role: m.role, content: m.content }));
+  const filtered = filterMessagesForExtraction(raw);
+  if (filtered.length === 0) return { ...EMPTY2, reason: "all_filtered" };
+  const fingerprint = fingerprintMessages(filtered);
+  if (fingerprint === lastFingerprint) {
+    return { ...EMPTY2, reason: "duplicate_fingerprint", fingerprint };
+  }
+  const payload = {
+    messages: filtered,
+    user_id: cfg.userId,
+    async_mode: true
+  };
+  let resp;
+  try {
+    resp = await client.postJson("/v3/memories/add/", payload, { timeoutMs });
+  } catch (err) {
+    return {
+      ...EMPTY2,
+      reason: `http_error: ${err.message}`,
+      messageCount: filtered.length,
+      fingerprint
+    };
+  }
+  return {
+    captured: true,
+    reason: "ok",
+    messageCount: filtered.length,
+    fingerprint,
+    serverResponse: resp
+  };
+}
+
+// src/hooks.ts
+var SESSION_TTL_MS = 15 * 60 * 1e3;
+var SESSION_MAX = 100;
+var RECALL_TIMEOUT_MS = 5e3;
+var CAPTURE_TIMEOUT_MS = 8e3;
+function buildRuntime(config, cwd) {
+  return {
+    config,
+    http: new HttpClient({ baseUrl: config.baseUrl, apiKey: config.apiKey }),
+    sessionState: /* @__PURE__ */ new Map(),
+    cwd
+  };
+}
+function touchSession(rt, sessionID) {
+  pruneSessions(rt.sessionState);
+  let s = rt.sessionState.get(sessionID);
+  if (!s) {
+    s = { lastPrompt: "", initialized: false, lastFingerprint: null, touched: Date.now() };
+    rt.sessionState.set(sessionID, s);
+  } else {
+    s.touched = Date.now();
+  }
+  return s;
+}
+function pruneSessions(state) {
+  const now = Date.now();
+  for (const [id, s] of state) {
+    if (now - s.touched > SESSION_TTL_MS) state.delete(id);
+  }
+  if (state.size > SESSION_MAX) {
+    const overflow = state.size - SESSION_MAX;
+    const sorted = [...state.entries()].sort((a, b) => a[1].touched - b[1].touched);
+    for (let i = 0; i < overflow; i++) state.delete(sorted[i][0]);
+  }
+}
+function extractTextPrompt(parts) {
+  const chunks = [];
+  for (const p of parts) {
+    if (p.type !== "text") continue;
+    if (p.synthetic === true || p.ignored === true) continue;
+    if (typeof p.text === "string" && p.text) chunks.push(p.text);
+  }
+  return chunks.join("\n").trim();
+}
+async function buildHooks(input) {
+  const config = loadOpencodeConfig();
+  if (!isConfigured(config)) {
+    logDebug(
+      config,
+      "config",
+      "opencode integration disabled: missing agents.opencode.api_key in ~/.ctxdb/ctxdb.json or CTXDB_API_KEY"
+    );
+    return {};
+  }
+  const cwd = input.directory || input.worktree || process.cwd();
+  const rt = buildRuntime(config, cwd);
+  const hooks = {
+    "chat.message": async (input2, output) => {
+      try {
+        const text = extractTextPrompt(output.parts);
+        if (!text) return;
+        const s = touchSession(rt, input2.sessionID);
+        s.lastPrompt = text;
+      } catch (err) {
+        logError(rt.config, "chat.message", err);
+      }
+    },
+    "experimental.chat.system.transform": async (input2, output) => {
+      try {
+        const sessionID = input2.sessionID;
+        const state = sessionID ? touchSession(rt, sessionID) : null;
+        const isFirstMessage = state ? !state.initialized : false;
+        const prompt = state?.lastPrompt ?? "";
+        const tasks = [];
+        if (rt.config.autoRecall && prompt) {
+          tasks.push(
+            searchAndLogRecall("system.transform.recall", prompt, rt)
+          );
+        }
+        if (rt.config.warmupRecall && isFirstMessage) {
+          const git = collectGitSignals(rt.cwd);
+          const query = buildWarmupQuery(rt.cwd, git);
+          tasks.push(
+            searchAndLogRecall("system.transform.warmupRecall", query, rt)
+          );
+        }
+        const kbMode = rt.config.kbCatalogInjection;
+        const kbThisTurn = kbMode === "user_prompt_submit" || kbMode === "session_start" && isFirstMessage;
+        if (kbThisTurn) {
+          tasks.push(fetchKbCatalogBlock(rt.http, RECALL_TIMEOUT_MS));
+        }
+        const blocks = (await Promise.all(tasks)).filter((b) => b && b.length > 0);
+        for (const b of blocks) output.system.push(b);
+        if (state) state.initialized = true;
+      } catch (err) {
+        logError(rt.config, "system.transform", err);
+      }
+    },
+    "event": async (evtInput) => {
+      try {
+        const ev = evtInput.event;
+        if (!ev || ev.type !== "session.idle") return;
+        const sessionID = ev.properties?.sessionID;
+        if (!sessionID) return;
+        if (!rt.config.autoCapture) return;
+        const state = touchSession(rt, sessionID);
+        let messages;
+        try {
+          const data = await withTimeout(
+            input.client.session.messages({
+              path: { id: sessionID },
+              query: { limit: 24 },
+              throwOnError: true
+            }),
+            CAPTURE_TIMEOUT_MS,
+            "session.messages"
+          );
+          messages = unwrapSessionMessagesResponse(data);
+        } catch (err) {
+          logError(rt.config, "event.fetchMessages", err);
+          return;
+        }
+        if (messages.length === 0) return;
+        const outcome = await runCapture(
+          messages,
+          rt.config,
+          rt.http,
+          CAPTURE_TIMEOUT_MS,
+          state.lastFingerprint
+        );
+        if (outcome.captured && outcome.fingerprint) {
+          state.lastFingerprint = outcome.fingerprint;
+        }
+        if (!outcome.captured && outcome.reason.startsWith("http_error:")) {
+          logError(rt.config, "event.capture", new Error(outcome.reason));
+        }
+        logDebug(
+          rt.config,
+          "event.capture",
+          `sessionID=${sessionID} captured=${outcome.captured} reason=${outcome.reason} count=${outcome.messageCount}`
+        );
+      } catch (err) {
+        logError(rt.config, "event", err);
+      }
+    }
+  };
+  return hooks;
+}
+async function searchAndLogRecall(scope, query, rt) {
+  const result = await searchAndFormatRecall(query, rt.config, rt.http, RECALL_TIMEOUT_MS);
+  if (result.reason.startsWith("http_error:")) {
+    logError(rt.config, scope, new Error(result.reason));
+  }
+  return result.block;
+}
+async function withTimeout(promise, timeoutMs, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`${label} timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function logDebug(config, scope, message) {
+  if (!config.debug) return;
+  try {
+    process.stderr.write(`[ctxdb-opencode] ${scope}: ${message}
+`);
+  } catch {
+  }
+}
+function logError(config, scope, err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  logDebug(config, scope, msg);
+}
+
+// src/index.ts
+var plugin = async (input) => buildHooks(input);
+var index_default = {
+  id: "ctxdb",
+  server: plugin
+};
+export {
+  index_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliyunrds/ctxdb",
-  "version": "0.0.10",
+  "version": "1.0.0-beta.1",
   "type": "module",
   "description": "Unified access layer for RDS ContextDatabase: `ctxdb` CLI (memory + KB ops), one-shot `setup --agent <qoder|qoderwork|codex|claude|opencode>` installer, per-agent config, hooks/plugins, and SKILL.md.",
   "license": "Apache-2.0",
@@ -39,7 +39,7 @@
     "vitest": "^4.0.18"
   },
   "scripts": {
-    "build": "tsup && mkdir -p dist/setup dist/opencode && cp -r src/setup/skills dist/setup/ && cp -r ../opencode/src dist/opencode/ && chmod +x dist/hooks/*.js dist/cli/main.js",
+    "build": "tsup && pnpm --dir ../opencode build && mkdir -p dist/setup dist/opencode && cp ../opencode/dist/index.js dist/opencode/index.js && cp -r src/setup/skills dist/setup/ && chmod +x dist/hooks/*.js dist/cli/main.js",
     "test": "vitest run"
   }
 }