clikit-plugin 0.3.4 → 0.3.5

package/dist/index.js

@@ -3386,7 +3386,7 @@ var require_parse = __commonJS((exports, module) => {
 
 // node_modules/gray-matter/index.js
 var require_gray_matter = __commonJS((exports, module) => {
-  var fs = __require("fs");
+  var fs2 = __require("fs");
   var sections = require_section_matter();
   var defaults = require_defaults();
   var stringify = require_stringify();
@@ -3473,7 +3473,7 @@ var require_gray_matter = __commonJS((exports, module) => {
     return stringify(file2, data, options2);
   };
   matter.read = function(filepath, options2) {
-    const str2 = fs.readFileSync(filepath, "utf8");
+    const str2 = fs2.readFileSync(filepath, "utf8");
     const file2 = matter(str2, options2);
     file2.path = filepath;
     return file2;
@@ -3500,6 +3500,372 @@ var require_gray_matter = __commonJS((exports, module) => {
   module.exports = matter;
 });
 
+// src/cli.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { fileURLToPath } from "url";
+var PLUGIN_NAME = "clikit-plugin";
+var DCP_PLUGIN_ENTRY = "@tarquinen/opencode-dcp@beta";
+var VERSION = "0.0.0";
+function getPackageRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = path.dirname(currentFile);
+  if (path.basename(currentDir) === "dist") {
+    return path.dirname(currentDir);
+  }
+  return path.dirname(currentDir);
+}
+function getPackageVersion() {
+  const packageJsonPath = path.join(getPackageRoot(), "package.json");
+  try {
+    const raw = fs.readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.version || VERSION;
+  } catch {
+    return VERSION;
+  }
+}
+function getPluginEntry() {
+  return `${PLUGIN_NAME}@latest`;
+}
+function resolveProjectDir(env = process.env, cwd = process.cwd()) {
+  const candidates = [env.INIT_CWD, env.PWD, cwd].filter((value) => typeof value === "string" && value.trim().length > 0);
+  for (const candidate of candidates) {
+    const resolved = path.resolve(candidate);
+    try {
+      if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+        return resolved;
+      }
+    } catch {}
+  }
+  return cwd;
+}
+function upsertPluginEntry(existingPlugins, pluginEntry) {
+  let pluginName;
+  if (pluginEntry.startsWith("@")) {
+    const versionAt = pluginEntry.indexOf("@", 1);
+    pluginName = versionAt === -1 ? pluginEntry : pluginEntry.slice(0, versionAt);
+  } else {
+    pluginName = pluginEntry.split("@")[0] || pluginEntry;
+  }
+  const filteredPlugins = existingPlugins.filter((p) => p !== pluginName && !p.startsWith(`${pluginName}@`));
+  filteredPlugins.push(pluginEntry);
+  return filteredPlugins;
+}
+function copyFileIfMissing(sourcePath, targetPath, stats) {
+  if (!fs.existsSync(sourcePath)) {
+    stats.missingSources.push(sourcePath);
+    return;
+  }
+  if (fs.existsSync(targetPath)) {
+    stats.skipped += 1;
+    return;
+  }
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+  stats.copied += 1;
+}
+function copyDirectoryFilesIfMissing(sourceDir, targetDir, stats) {
+  if (!fs.existsSync(sourceDir)) {
+    stats.missingSources.push(sourceDir);
+    return;
+  }
+  fs.mkdirSync(targetDir, { recursive: true });
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectoryFilesIfMissing(sourcePath, targetPath, stats);
+      continue;
+    }
+    if (entry.isFile()) {
+      copyFileIfMissing(sourcePath, targetPath, stats);
+    }
+  }
+}
+function scaffoldProjectOpencode(projectDir, packageRoot = getPackageRoot()) {
+  const projectOpencodeDir = path.join(projectDir, ".opencode");
+  const stats = {
+    copied: 0,
+    skipped: 0,
+    missingSources: []
+  };
+  fs.mkdirSync(projectOpencodeDir, { recursive: true });
+  copyFileIfMissing(path.join(packageRoot, "AGENTS.md"), path.join(projectOpencodeDir, "AGENTS.md"), stats);
+  copyDirectoryFilesIfMissing(path.join(packageRoot, "command"), path.join(projectOpencodeDir, "command"), stats);
+  copyDirectoryFilesIfMissing(path.join(packageRoot, "skill"), path.join(projectOpencodeDir, "skill"), stats);
+  copyDirectoryFilesIfMissing(path.join(packageRoot, "memory", "_templates"), path.join(projectOpencodeDir, "memory", "_templates"), stats);
+  copyDirectoryFilesIfMissing(path.join(packageRoot, "src", "agents"), path.join(projectOpencodeDir, "src", "agents"), stats);
+  copyFileIfMissing(path.join(packageRoot, "README.md"), path.join(projectOpencodeDir, "README-clikit.md"), stats);
+  const indexPath = path.join(projectOpencodeDir, "index.ts");
+  if (!fs.existsSync(indexPath)) {
+    fs.writeFileSync(indexPath, `import CliKitPlugin from "${PLUGIN_NAME}";
+
+export default CliKitPlugin;
+`);
+    stats.copied += 1;
+  } else {
+    stats.skipped += 1;
+  }
+  return stats;
+}
+function getShellRcFiles() {
+  const home = getRealHome();
+  const rcFiles = [];
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) {
+    rcFiles.push(path.join(home, ".zshrc"));
+  } else if (shell.includes("fish")) {
+    rcFiles.push(path.join(home, ".config", "fish", "config.fish"));
+  } else {
+    rcFiles.push(path.join(home, ".bashrc"));
+    const bashProfile = path.join(home, ".bash_profile");
+    if (fs.existsSync(bashProfile)) {
+      rcFiles.push(bashProfile);
+    }
+  }
+  return rcFiles;
+}
+function ensureEnvInShellRc(key, value) {
+  const exportLine = `export ${key}=${value}`;
+  const marker = `# Added by clikit-plugin`;
+  const block = `
+${marker}
+${exportLine}
+`;
+  const rcFiles = getShellRcFiles();
+  for (const rcFile of rcFiles) {
+    try {
+      const existing = fs.existsSync(rcFile) ? fs.readFileSync(rcFile, "utf-8") : "";
+      if (existing.includes(`export ${key}=`) || existing.includes(`${key}=`)) {
+        console.log(`\u2713 ${key} already set in ${rcFile}`);
+        continue;
+      }
+      fs.appendFileSync(rcFile, block, "utf-8");
+      console.log(`\u2713 Added ${exportLine} to ${rcFile}`);
+    } catch (err) {
+      console.warn(`\u26A0 Could not write to ${rcFile}: ${err}`);
+    }
+  }
+}
+function removeLegacyGlobalPluginAssets(configDir) {
+  const legacyPluginPath = path.join(configDir, "plugins", "clikit.js");
+  const legacyAgentsDir = path.join(configDir, "plugins", "agents");
+  const legacyCommandDir = path.join(configDir, "command");
+  const legacyStatusPath = path.join(legacyCommandDir, "status.md");
+  const legacyStatusBeadsPath = path.join(legacyCommandDir, "status-beads.md");
+  if (fs.existsSync(legacyPluginPath)) {
+    fs.rmSync(legacyPluginPath, { force: true });
+    console.log(`\u2713 Removed legacy local plugin file: ${legacyPluginPath}`);
+  }
+  if (fs.existsSync(legacyAgentsDir)) {
+    fs.rmSync(legacyAgentsDir, { recursive: true, force: true });
+    console.log(`\u2713 Removed legacy local agents directory: ${legacyAgentsDir}`);
+  }
+  if (fs.existsSync(legacyStatusPath)) {
+    fs.rmSync(legacyStatusPath, { force: true });
+    console.log(`\u2713 Removed legacy command file: ${legacyStatusPath}`);
+  }
+  if (fs.existsSync(legacyStatusBeadsPath)) {
+    fs.rmSync(legacyStatusBeadsPath, { force: true });
+    console.log(`\u2713 Removed legacy command file: ${legacyStatusBeadsPath}`);
+  }
+}
+function getRealHome() {
+  if (process.env.SNAP_REAL_HOME) {
+    return process.env.SNAP_REAL_HOME;
+  }
+  const home = os.homedir();
+  const snapMatch = home.match(/^(\/home\/[^/]+)\/snap\//);
+  if (snapMatch) {
+    return snapMatch[1];
+  }
+  return home;
+}
+function getConfigDir() {
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return process.env.OPENCODE_CONFIG_DIR;
+  }
+  const home = getRealHome();
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "opencode");
+  }
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(home, ".config"), "opencode");
+}
+function getConfigPath() {
+  const configDir = getConfigDir();
+  const jsonPath = path.join(configDir, "opencode.json");
+  const jsoncPath = path.join(configDir, "opencode.jsonc");
+  if (fs.existsSync(jsoncPath))
+    return jsoncPath;
+  if (fs.existsSync(jsonPath))
+    return jsonPath;
+  return jsonPath;
+}
+function getCliKitConfigPath(configDir = getConfigDir()) {
+  const candidates = ["clikit.jsonc", "clikit.json", "clikit.config.json"];
+  for (const name of candidates) {
+    const fullPath = path.join(configDir, name);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return path.join(configDir, "clikit.json");
+}
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+}
+function parseConfig(configPath) {
+  try {
+    if (!fs.existsSync(configPath)) {
+      return { config: {}, raw: "", parseError: null };
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    try {
+      const parsed = JSON.parse(content);
+      return { config: parsed, raw: content, parseError: null };
+    } catch {
+      const cleaned = content.replace(/\/\*[\s\S]*?\*\//g, "");
+      const cleanedTrailing = cleaned.replace(/,\s*([}\]])/g, "$1");
+      const parsed = JSON.parse(cleanedTrailing);
+      return { config: parsed, raw: content, parseError: null };
+    }
+  } catch (err) {
+    const raw = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf-8") : "";
+    return { config: {}, raw, parseError: String(err) };
+  }
+}
+function writeConfig(configPath, config) {
+  ensureConfigDir();
+  const tmpPath = `${configPath}.tmp`;
+  const content = JSON.stringify(config, null, 2) + `
+`;
+  fs.writeFileSync(tmpPath, content);
+  fs.renameSync(tmpPath, configPath);
+}
+async function install(options2) {
+  const pluginEntry = getPluginEntry();
+  try {
+    ensureConfigDir();
+    const configPath = getConfigPath();
+    const result = parseConfig(configPath);
+    if (result.parseError && result.raw.trim()) {
+      console.error(`\u2717 Config file has syntax errors and cannot be safely modified.`);
+      console.error(`  Error: ${result.parseError}`);
+      console.error(`  Please fix the config file manually.`);
+      return 1;
+    }
+    const config = result.config;
+    const existingPlugins = Array.isArray(config.plugin) ? config.plugin.filter((p) => typeof p === "string") : [];
+    const filteredPlugins = upsertPluginEntry(existingPlugins, pluginEntry);
+    const finalPlugins = upsertPluginEntry(filteredPlugins, DCP_PLUGIN_ENTRY);
+    const pluginMergedConfig = { ...config, plugin: finalPlugins };
+    writeConfig(configPath, pluginMergedConfig);
+    if (options2.includeProjectScaffold) {
+      const projectDir = resolveProjectDir();
+      scaffoldProjectOpencode(projectDir);
+    }
+    removeLegacyGlobalPluginAssets(getConfigDir());
+    ensureEnvInShellRc("OPENCODE_ENABLE_EXA", "1");
+    const memoryDir = path.join(getConfigDir(), "memory");
+    const memorySubdirs = ["specs", "plans", "research", "reviews", "handoffs", "beads", "prds"];
+    for (const subdir of memorySubdirs) {
+      const dir = path.join(memoryDir, subdir);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+    const clikitConfigPath = getCliKitConfigPath();
+    if (!fs.existsSync(clikitConfigPath)) {
+      const defaultConfig = {
+        $schema: `https://unpkg.com/${PLUGIN_NAME}@latest/schema.json`,
+        disabled_agents: [],
+        disabled_commands: [],
+        disabled_skills: [],
+        agents: {},
+        commands: {},
+        skills: {
+          enable: [],
+          disable: []
+        },
+        hooks: {}
+      };
+      writeConfig(clikitConfigPath, defaultConfig);
+    }
+    console.log(`\u2713 CliKit installed (${pluginEntry})`);
+    console.log(`\u2713 DCP installed (${DCP_PLUGIN_ENTRY})`);
+    console.log(`\u2713 Config: ${configPath}`);
+    console.log("\u2713 Restart OpenCode");
+    return 0;
+  } catch (err) {
+    console.error(`\u2717 Install failed: ${err}`);
+    return 1;
+  }
+}
+function help() {
+  console.log(`
+CliKit - OpenCode Plugin
+
+Usage:
+  bun x clikit-plugin <command>
+
+Commands:
+  install     Install CliKit globally for OpenCode
+  help        Show this help message
+  version     Show version
+
+Install options:
+  --project   Also scaffold project .opencode files (default: disabled)
+
+Examples:
+  bun x clikit-plugin install
+  bun x clikit-plugin install --project
+`);
+}
+function version() {
+  console.log(`clikit-plugin v${getPackageVersion()}`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || "help";
+  const flags = args.slice(1);
+  let exitCode = 0;
+  switch (command) {
+    case "install":
+    case "i":
+      exitCode = await install({
+        includeProjectScaffold: flags.includes("--project")
+      });
+      break;
+    case "help":
+    case "-h":
+    case "--help":
+      help();
+      break;
+    case "version":
+    case "-v":
+    case "--version":
+      version();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      help();
+      exitCode = 1;
+  }
+  process.exit(exitCode);
+}
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -3733,7 +4099,7 @@ __export(exports_external, {
 // node_modules/zod/v4/core/index.js
 var exports_core2 = {};
 __export(exports_core2, {
-  version: () => version,
+  version: () => version2,
   util: () => exports_util,
   treeifyError: () => treeifyError,
   toJSONSchema: () => toJSONSchema,
@@ -4229,10 +4595,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4591,11 +4957,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -4763,7 +5129,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path = []) => {
+  const processError = (error2, path2 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -4773,7 +5139,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4805,8 +5171,8 @@ function treeifyError(error, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -4990,10 +5356,10 @@ var nanoid = /^[a-zA-Z0-9_-]{21}$/;
 var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
 var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
 var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-var uuid = (version) => {
-  if (!version)
+var uuid = (version2) => {
+  if (!version2)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 };
 var uuid4 = /* @__PURE__ */ uuid(4);
 var uuid6 = /* @__PURE__ */ uuid(6);
@@ -5652,7 +6018,7 @@ class Doc {
 }
 
 // node_modules/zod/v4/core/versions.js
-var version = {
+var version2 = {
   major: 4,
   minor: 1,
   patch: 8
@@ -5664,7 +6030,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   inst ?? (inst = {});
   inst._zod.def = def;
   inst._zod.bag = inst._zod.bag || {};
-  inst._zod.version = version;
+  inst._zod.version = version2;
   const checks = [...inst._zod.def.checks ?? []];
   if (inst._zod.traits.has("$ZodCheck")) {
     checks.unshift(inst);
@@ -15823,15 +16189,18 @@ tool.schema = exports_external;
 // src/index.ts
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
+import * as fs11 from "fs";
+import * as path11 from "path";
+import * as os3 from "os";
 
 // src/agents/index.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // src/hooks/error-logger.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var BLOCKED_TOOL_ERROR_PREFIX = "[CliKit] Blocked tool execution:";
 var _initErrorBuffer = [];
 function bufferInitError(source, level, message, context) {
@@ -15874,10 +16243,10 @@ function formatHookErrorLog(hookName, error45, context) {
 }
 function writeErrorLog(hookName, error45, projectDir, context) {
   try {
-    const logDir = path.join(projectDir, ".opencode");
-    const logPath = path.join(logDir, "error-log.txt");
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
+    const logDir = path2.join(projectDir, ".opencode");
+    const logPath = path2.join(logDir, "error-log.txt");
+    if (!fs2.existsSync(logDir)) {
+      fs2.mkdirSync(logDir, { recursive: true });
     }
     const timestamp = new Date().toISOString();
     const message = getErrorMessage(error45);
@@ -15894,15 +16263,15 @@ ${stack}`] : [],
       ""
     ].join(`
 `);
-    fs.appendFileSync(logPath, entry, "utf-8");
+    fs2.appendFileSync(logPath, entry, "utf-8");
   } catch {}
 }
 function writeBufferedErrorLog(entry, projectDir) {
   try {
-    const logDir = path.join(projectDir, ".opencode");
-    const logPath = path.join(logDir, "error-log.txt");
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
+    const logDir = path2.join(projectDir, ".opencode");
+    const logPath = path2.join(logDir, "error-log.txt");
+    if (!fs2.existsSync(logDir)) {
+      fs2.mkdirSync(logDir, { recursive: true });
     }
     const timestamp = new Date().toISOString();
     const contextStr = entry.context && Object.keys(entry.context).length > 0 ? `context: ${JSON.stringify(entry.context, null, 2)}` : "";
@@ -15915,29 +16284,29 @@ function writeBufferedErrorLog(entry, projectDir) {
       ""
     ].join(`
 `);
-    fs.appendFileSync(logPath, line, "utf-8");
+    fs2.appendFileSync(logPath, line, "utf-8");
   } catch {}
 }
 
 // src/agents/index.ts
 var AGENTS_DIR_CANDIDATES = [
   import.meta.dir,
-  path2.join(import.meta.dir, "../src/agents"),
-  path2.join(import.meta.dir, "../../src/agents"),
-  path2.join(import.meta.dir, "../agents")
+  path3.join(import.meta.dir, "../src/agents"),
+  path3.join(import.meta.dir, "../../src/agents"),
+  path3.join(import.meta.dir, "../agents")
 ];
 function resolveAgentsDir() {
   for (const dir of AGENTS_DIR_CANDIDATES) {
-    if (!fs2.existsSync(dir))
+    if (!fs3.existsSync(dir))
       continue;
     try {
-      const hasAgentFiles = fs2.readdirSync(dir).some((f) => f.endsWith(".md") && f !== "AGENTS.md");
+      const hasAgentFiles = fs3.readdirSync(dir).some((f) => f.endsWith(".md") && f !== "AGENTS.md");
       if (hasAgentFiles)
         return dir;
     } catch {}
   }
   for (const dir of AGENTS_DIR_CANDIDATES) {
-    if (fs2.existsSync(dir)) {
+    if (fs3.existsSync(dir)) {
       return dir;
     }
   }
@@ -15946,7 +16315,7 @@ function resolveAgentsDir() {
 var VALID_MODES = new Set(["subagent", "primary", "all"]);
 function validateFrontmatter(frontmatter, filePath) {
   const warnings = [];
-  const name = path2.basename(filePath, ".md");
+  const name = path3.basename(filePath, ".md");
   if (!frontmatter.description) {
     warnings.push(`[${name}] Missing 'description' \u2014 agent will have empty description`);
   }
@@ -15969,7 +16338,7 @@ function validateFrontmatter(frontmatter, filePath) {
 }
 function parseAgentMarkdown(filePath) {
   try {
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const content = fs3.readFileSync(filePath, "utf-8");
     const { data: frontmatter, content: body } = import_gray_matter.default(content);
     const warnings = validateFrontmatter(frontmatter, filePath);
     for (const warning of warnings) {
@@ -16005,13 +16374,13 @@ function parseAgentMarkdown(filePath) {
 function loadAgents() {
   const agents = {};
   const agentsDir = resolveAgentsDir();
-  if (!fs2.existsSync(agentsDir)) {
+  if (!fs3.existsSync(agentsDir)) {
     return agents;
   }
-  const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f !== "AGENTS.md").sort();
+  const files = fs3.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f !== "AGENTS.md").sort();
   for (const file2 of files) {
-    const agentName = path2.basename(file2, ".md");
-    const agentPath = path2.join(agentsDir, file2);
+    const agentName = path3.basename(file2, ".md");
+    const agentPath = path3.join(agentsDir, file2);
     const agent = parseAgentMarkdown(agentPath);
     if (agent) {
       agents[agentName] = agent;
@@ -16022,10 +16391,10 @@ function loadAgents() {
 var _cachedAgents = null;
 var _cachedAgentsFingerprint = "";
 function getAgentsFingerprint(agentsDir) {
-  const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f !== "AGENTS.md").sort();
+  const files = fs3.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f !== "AGENTS.md").sort();
   const parts = files.map((file2) => {
-    const fullPath = path2.join(agentsDir, file2);
-    const stat = fs2.statSync(fullPath);
+    const fullPath = path3.join(agentsDir, file2);
+    const stat = fs3.statSync(fullPath);
     const size = stat.size;
     return `${file2}:${stat.mtimeMs}:${size}`;
   });
@@ -16047,16 +16416,16 @@ function getBuiltinAgents() {
 
 // src/commands/index.ts
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var COMMANDS_DIR_CANDIDATES = [
-  path3.join(import.meta.dir, "../command"),
-  path3.join(import.meta.dir, "../../command"),
-  path3.join(import.meta.dir, "../../../command")
+  path4.join(import.meta.dir, "../command"),
+  path4.join(import.meta.dir, "../../command"),
+  path4.join(import.meta.dir, "../../../command")
 ];
 function resolveCommandsDir() {
   for (const dir of COMMANDS_DIR_CANDIDATES) {
-    if (fs3.existsSync(dir)) {
+    if (fs4.existsSync(dir)) {
       return dir;
     }
   }
@@ -16064,7 +16433,7 @@ function resolveCommandsDir() {
 }
 function parseCommandMarkdown(filePath) {
   try {
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const content = fs4.readFileSync(filePath, "utf-8");
     const { data: frontmatter, content: body } = import_gray_matter2.default(content);
     const config2 = {
       description: frontmatter.description || "",
@@ -16091,13 +16460,13 @@ function parseCommandMarkdown(filePath) {
 function loadCommands() {
   const commands = {};
   const commandsDir = resolveCommandsDir();
-  if (!fs3.existsSync(commandsDir)) {
+  if (!fs4.existsSync(commandsDir)) {
     return commands;
   }
-  const files = fs3.readdirSync(commandsDir).filter((f) => f.endsWith(".md")).sort();
+  const files = fs4.readdirSync(commandsDir).filter((f) => f.endsWith(".md")).sort();
   for (const file2 of files) {
-    const commandName = path3.basename(file2, ".md");
-    const commandPath = path3.join(commandsDir, file2);
+    const commandName = path4.basename(file2, ".md");
+    const commandPath = path4.join(commandsDir, file2);
     const command = parseCommandMarkdown(commandPath);
     if (command) {
       commands[commandName] = command;
@@ -16108,10 +16477,10 @@ function loadCommands() {
 var _cachedCommands = null;
 var _cachedCommandsFingerprint = "";
 function getCommandsFingerprint(commandsDir) {
-  const files = fs3.readdirSync(commandsDir).filter((f) => f.endsWith(".md")).sort();
+  const files = fs4.readdirSync(commandsDir).filter((f) => f.endsWith(".md")).sort();
   const parts = files.map((file2) => {
-    const fullPath = path3.join(commandsDir, file2);
-    const stat = fs3.statSync(fullPath);
+    const fullPath = path4.join(commandsDir, file2);
+    const stat = fs4.statSync(fullPath);
     return `${file2}:${stat.mtimeMs}`;
   });
   return parts.join("|");
@@ -16132,16 +16501,16 @@ function getBuiltinCommands() {
 
 // src/skills/index.ts
 var import_gray_matter3 = __toESM(require_gray_matter(), 1);
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 var SKILLS_DIR_CANDIDATES = [
-  path4.join(import.meta.dir, "../skill"),
-  path4.join(import.meta.dir, "../../skill"),
-  path4.join(import.meta.dir, "../../../skill")
+  path5.join(import.meta.dir, "../skill"),
+  path5.join(import.meta.dir, "../../skill"),
+  path5.join(import.meta.dir, "../../../skill")
 ];
 function resolveSkillsDir() {
   for (const dir of SKILLS_DIR_CANDIDATES) {
-    if (fs4.existsSync(dir)) {
+    if (fs5.existsSync(dir)) {
       return dir;
     }
   }
@@ -16150,23 +16519,23 @@ function resolveSkillsDir() {
 function getBuiltinSkills() {
   const skills = {};
   const skillsDir = resolveSkillsDir();
-  if (!fs4.existsSync(skillsDir)) {
+  if (!fs5.existsSync(skillsDir)) {
     bufferInitError("skills", "warn", `Skills directory not found: ${skillsDir}`);
     return skills;
   }
-  const skillDirs = fs4.readdirSync(skillsDir, { withFileTypes: true });
+  const skillDirs = fs5.readdirSync(skillsDir, { withFileTypes: true });
   for (const dirent of skillDirs) {
     if (!dirent.isDirectory())
       continue;
     const skillName = dirent.name;
-    const skillPath = path4.join(skillsDir, skillName);
-    const skillMdPath = path4.join(skillPath, "SKILL.md");
-    if (!fs4.existsSync(skillMdPath)) {
+    const skillPath = path5.join(skillsDir, skillName);
+    const skillMdPath = path5.join(skillPath, "SKILL.md");
+    if (!fs5.existsSync(skillMdPath)) {
       bufferInitError("skills", "warn", `Missing SKILL.md for skill: ${skillName}`, { skillPath });
       continue;
     }
     try {
-      const fileContent = fs4.readFileSync(skillMdPath, "utf-8");
+      const fileContent = fs5.readFileSync(skillMdPath, "utf-8");
       const { data, content } = import_gray_matter3.default(fileContent);
       skills[skillName] = {
         name: data.name || skillName,
@@ -16185,9 +16554,9 @@ function getBuiltinSkills() {
 }
 
 // src/config.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import * as os from "os";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as os2 from "os";
 var DEFAULT_CONFIG = {
   disabled_agents: [],
   disabled_commands: [],
@@ -16277,15 +16646,15 @@ var DEFAULT_CONFIG = {
 };
 function getUserConfigDir() {
   if (process.platform === "win32") {
-    return process.env.APPDATA || path5.join(os.homedir(), "AppData", "Roaming");
+    return process.env.APPDATA || path6.join(os2.homedir(), "AppData", "Roaming");
   }
-  return process.env.XDG_CONFIG_HOME || path5.join(os.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path6.join(os2.homedir(), ".config");
 }
 function getOpenCodeConfigDir() {
   if (process.env.OPENCODE_CONFIG_DIR) {
     return process.env.OPENCODE_CONFIG_DIR;
   }
-  return path5.join(getUserConfigDir(), "opencode");
+  return path6.join(getUserConfigDir(), "opencode");
 }
 function stripJsonComments(content) {
   let result = "";
@@ -16343,10 +16712,10 @@ function stripJsonComments(content) {
 }
 function loadJsonFile(filePath) {
   try {
-    if (!fs5.existsSync(filePath)) {
+    if (!fs6.existsSync(filePath)) {
       return null;
     }
-    const content = fs5.readFileSync(filePath, "utf-8");
+    const content = fs6.readFileSync(filePath, "utf-8");
     try {
       return JSON.parse(content);
     } catch {
@@ -16380,12 +16749,12 @@ function loadCliKitConfig(projectDirectory) {
   const userBaseDir = getOpenCodeConfigDir();
   const projectBaseDirs = [
     safeDir,
-    path5.join(safeDir, ".opencode")
+    path6.join(safeDir, ".opencode")
   ];
   const configCandidates = ["clikit.jsonc", "clikit.json", "clikit.config.json"];
   let config2 = { ...DEFAULT_CONFIG };
   for (const candidate of configCandidates) {
-    const userConfigPath = path5.join(userBaseDir, candidate);
+    const userConfigPath = path6.join(userBaseDir, candidate);
     const userConfig = loadJsonFile(userConfigPath);
     if (userConfig) {
       config2 = deepMerge(config2, userConfig);
@@ -16394,7 +16763,7 @@ function loadCliKitConfig(projectDirectory) {
   }
   for (const baseDir of projectBaseDirs) {
     for (const candidate of configCandidates) {
-      const projectConfigPath = path5.join(baseDir, candidate);
+      const projectConfigPath = path6.join(baseDir, candidate);
       const projectConfig = loadJsonFile(projectConfigPath);
       if (projectConfig) {
         config2 = deepMerge(config2, projectConfig);
@@ -16904,8 +17273,8 @@ function formatTruncationLog(result) {
   return `[CliKit:truncator] Truncated output: ${result.originalLines} \u2192 ${result.truncatedLines} lines, saved ${(saved / 1024).toFixed(1)}KB`;
 }
 // src/hooks/memory-digest.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import { Database } from "bun:sqlite";
 function parseJsonArray(value) {
   if (typeof value !== "string" || !value.trim())
@@ -16925,7 +17294,7 @@ function formatDate(iso) {
   }
 }
 function writeTopicFile(memoryDir, type, heading, rows) {
-  const topicPath = path6.join(memoryDir, `${type}.md`);
+  const topicPath = path7.join(memoryDir, `${type}.md`);
   const lines = [];
   lines.push(`# ${heading}`);
   lines.push("");
@@ -16966,16 +17335,16 @@ function writeTopicFile(memoryDir, type, heading, rows) {
     lines.push("---");
     lines.push("");
   }
-  fs6.writeFileSync(topicPath, lines.join(`
+  fs7.writeFileSync(topicPath, lines.join(`
 `), "utf-8");
 }
 function generateMemoryDigest(projectDir, config2) {
   const result = { written: false, path: "", counts: {} };
   if (typeof projectDir !== "string" || !projectDir)
     return result;
-  const memoryDir = path6.join(projectDir, ".opencode", "memory");
-  const dbPath = path6.join(memoryDir, "memory.db");
-  if (!fs6.existsSync(dbPath)) {
+  const memoryDir = path7.join(projectDir, ".opencode", "memory");
+  const dbPath = path7.join(memoryDir, "memory.db");
+  if (!fs7.existsSync(dbPath)) {
     return result;
   }
   const compactMode = config2?.compact_mode !== false;
@@ -17040,14 +17409,14 @@ function generateMemoryDigest(projectDir, config2) {
     sections.push("*No observations found in memory database.*");
     sections.push("");
   }
-  const digestPath = path6.join(memoryDir, "_digest.md");
+  const digestPath = path7.join(memoryDir, "_digest.md");
   const content = sections.join(`
 `);
   try {
-    if (!fs6.existsSync(memoryDir)) {
-      fs6.mkdirSync(memoryDir, { recursive: true });
+    if (!fs7.existsSync(memoryDir)) {
+      fs7.mkdirSync(memoryDir, { recursive: true });
     }
-    fs6.writeFileSync(digestPath, content, "utf-8");
+    fs7.writeFileSync(digestPath, content, "utf-8");
     result.written = true;
     result.path = digestPath;
   } catch {}
@@ -17061,8 +17430,8 @@ function formatDigestLog(result) {
   return `[CliKit:memory-digest] Generated digest: ${parts || "empty"}`;
 }
 // src/hooks/todo-beads-sync.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import { Database as Database2 } from "bun:sqlite";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -17217,8 +17586,8 @@ function syncTodosToBeads(projectDirectory, sessionID, todos, config2) {
       skippedReason: "Todo sync disabled; Beads is authoritative"
     };
   }
-  const beadsDbPath = path7.join(projectDirectory, ".beads", "beads.db");
-  if (!fs7.existsSync(beadsDbPath)) {
+  const beadsDbPath = path8.join(projectDirectory, ".beads", "beads.db");
+  if (!fs8.existsSync(beadsDbPath)) {
     return {
       synced: false,
       sessionID,
@@ -17248,7 +17617,7 @@ function syncTodosToBeads(projectDirectory, sessionID, todos, config2) {
   throw lastError instanceof Error ? lastError : new Error("Todo-Beads sync failed after retries");
 }
 function flushBeadsJsonl(projectDirectory, result) {
-  const jsonlPath = path7.join(projectDirectory, ".beads", "issues.jsonl");
+  const jsonlPath = path8.join(projectDirectory, ".beads", "issues.jsonl");
   execFileAsync("bd", ["export", "--force", "-o", jsonlPath], {
     cwd: projectDirectory,
     timeout: 5000
@@ -17265,8 +17634,8 @@ function formatTodoBeadsSyncLog(result) {
   return `[CliKit:todo-beads-sync] session=${result.sessionID} todos=${result.totalTodos} created=${result.created} updated=${result.updated} closed=${result.closed}`;
 }
 // src/hooks/beads-context.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 import { Database as Database3 } from "bun:sqlite";
 var BEADS_CONTEXT_BUSY_TIMEOUT_MS = 2000;
 var PRIORITY_LABELS = {
@@ -17282,8 +17651,8 @@ var STATUS_ICONS = {
   closed: "\u2713"
 };
 function openBeadsDbReadonly(projectDirectory) {
-  const beadsDbPath = path8.join(projectDirectory, ".beads", "beads.db");
-  if (!fs8.existsSync(beadsDbPath)) {
+  const beadsDbPath = path9.join(projectDirectory, ".beads", "beads.db");
+  if (!fs9.existsSync(beadsDbPath)) {
     return null;
   }
   try {
@@ -17440,8 +17809,8 @@ function shouldAttemptTilthForTool(toolName, toolInput) {
   const normalized = toolName.toLowerCase();
   if (!normalized.includes("read"))
     return false;
-  const path9 = extractFilePath(toolInput);
-  return typeof path9 === "string" && path9.length > 0;
+  const path10 = extractFilePath(toolInput);
+  return typeof path10 === "string" && path10.length > 0;
 }
 function extractFilePath(toolInput) {
   for (const key of ["filePath", "file_path", "path", "file"]) {
@@ -17527,12 +17896,12 @@ import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 
 // src/tools/memory-db.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 import { Database as Database4 } from "bun:sqlite";
 function getMemoryPaths(projectDir = process.cwd()) {
-  const memoryDir = path9.join(projectDir, ".opencode", "memory");
-  const memoryDbPath = path9.join(memoryDir, "memory.db");
+  const memoryDir = path10.join(projectDir, ".opencode", "memory");
+  const memoryDbPath = path10.join(memoryDir, "memory.db");
   return { memoryDir, memoryDbPath };
 }
 function ensureObservationSchema(db) {
@@ -17594,8 +17963,8 @@ function ensureObservationSchema(db) {
 function openMemoryDb(options2 = {}) {
   const { projectDir, readonly: readonly2 = false } = options2;
   const { memoryDir, memoryDbPath } = getMemoryPaths(projectDir);
-  if (!readonly2 && !fs9.existsSync(memoryDir)) {
-    fs9.mkdirSync(memoryDir, { recursive: true });
+  if (!readonly2 && !fs10.existsSync(memoryDir)) {
+    fs10.mkdirSync(memoryDir, { recursive: true });
   }
   const db = new Database4(memoryDbPath, readonly2 ? { readonly: true } : undefined);
   if (!readonly2) {
@@ -17953,6 +18322,49 @@ function buildSummary(sections, maxTokens) {
 
 // src/index.ts
 var execFileAsync3 = promisify3(execFile3);
+var DCP_PLUGIN_ENTRY2 = "@tarquinen/opencode-dcp@beta";
+var DCP_PLUGIN_BASE = "@tarquinen/opencode-dcp";
+function ensureDcpInConfig() {
+  try {
+    const configDir = (() => {
+      if (process.env.OPENCODE_CONFIG_DIR)
+        return process.env.OPENCODE_CONFIG_DIR;
+      const home = (() => {
+        if (process.env.SNAP_REAL_HOME)
+          return process.env.SNAP_REAL_HOME;
+        const h = os3.homedir();
+        const m = h.match(/^(\/home\/[^/]+)\/snap\//);
+        return m ? m[1] : h;
+      })();
+      if (process.platform === "win32") {
+        return path11.join(process.env.APPDATA || path11.join(home, "AppData", "Roaming"), "opencode");
+      }
+      return path11.join(process.env.XDG_CONFIG_HOME || path11.join(home, ".config"), "opencode");
+    })();
+    const jsoncPath = path11.join(configDir, "opencode.jsonc");
+    const jsonPath = path11.join(configDir, "opencode.json");
+    const configPath = fs11.existsSync(jsoncPath) ? jsoncPath : jsonPath;
+    if (!fs11.existsSync(configPath))
+      return;
+    const raw = fs11.readFileSync(configPath, "utf-8");
+    let config2;
+    try {
+      config2 = JSON.parse(raw);
+    } catch {
+      const cleaned = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([}\]])/g, "$1");
+      config2 = JSON.parse(cleaned);
+    }
+    const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((p) => typeof p === "string") : [];
+    const hasDcp = plugins.some((p) => p === DCP_PLUGIN_BASE || p.startsWith(`${DCP_PLUGIN_BASE}@`));
+    if (hasDcp)
+      return;
+    const updated = upsertPluginEntry(plugins, DCP_PLUGIN_ENTRY2);
+    const tmpPath = `${configPath}.tmp`;
+    fs11.writeFileSync(tmpPath, JSON.stringify({ ...config2, plugin: updated }, null, 2) + `
+`);
+    fs11.renameSync(tmpPath, configPath);
+  } catch {}
+}
 var CliKitPlugin = async (ctx) => {
   const todosBySession = new Map;
   const defaultMcpEntries = {
@@ -18209,6 +18621,7 @@ ${(content || "").trim()}`.trim();
     ].join(`
 `);
   }
+  ensureDcpInConfig();
   const pluginConfig = loadCliKitConfig(ctx.directory) ?? {};
   const debugLogsEnabled = pluginConfig.hooks?.session_logging === true && process.env.CLIKIT_DEBUG === "1";
   const toolLogsEnabled = pluginConfig.hooks?.tool_logging === true && process.env.CLIKIT_DEBUG === "1";