ccjk 1.3.1

package/dist/index.mjs

@@ -0,0 +1,1706 @@
+import { C as CCJK_PLUGINS_DIR, a as CCJK_SKILLS_DIR, b as CCJK_GROUPS_DIR, A as AIDER_DIR, c as AIDER_CONFIG_FILE, d as AIDER_ENV_FILE, e as CONTINUE_DIR, f as CONTINUE_CONFIG_FILE, s as sectionDivider, g as COLORS, S as STATUS } from './chunks/simple-config.mjs';
+export { $ as AI_OUTPUT_LANGUAGES, V as API_DEFAULT_URL, W as API_ENV_KEY, I as CCJK_CONFIG_DIR, J as CCJK_CONFIG_FILE, q as CLAUDE_DIR, u as CLAUDE_MD_FILE, w as CLAUDE_VSC_CONFIG_FILE, F as CLINE_CONFIG_FILE, E as CLINE_DIR, B as CODEX_AGENTS_FILE, z as CODEX_AUTH_FILE, y as CODEX_CONFIG_FILE, x as CODEX_DIR, D as CODEX_PROMPTS_DIR, R as CODE_TOOL_ALIASES, Q as CODE_TOOL_BANNERS, T as CODE_TOOL_INFO, O as CODE_TOOL_TYPES, H as CURSOR_CONFIG_FILE, G as CURSOR_DIR, v as ClAUDE_CONFIG_FILE, P as DEFAULT_CODE_TOOL_TYPE, _ as LANG_LABELS, L as LEGACY_ZCF_CONFIG_DIR, K as LEGACY_ZCF_CONFIG_FILE, M as LEGACY_ZCF_CONFIG_FILES, bX as PERMISSION_TEMPLATES, t as SETTINGS_FILE, Y as SUPPORTED_LANGS, Z as ZCF_CONFIG_DIR, N as ZCF_CONFIG_FILE, c3 as addAutoApprovePattern, an as addCompletedOnboarding, bp as applyAiLanguageDirective, b1 as applyCodexPlatformCommand, b_ as applyTemplate, as as backupCodexAgents, at as backupCodexComplete, au as backupCodexConfig, av as backupCodexFiles, aw as backupCodexPrompts, bg as backupExistingConfig, aj as backupMcpConfig, ae as boxify, al as buildMcpServerConfig, ch as checkAllVersions, cb as checkCcjkVersion, ca as checkClaudeCodeVersion, ax as checkCodexUpdate, cc as checkPluginVersions, j as cleanupPermissions, ay as codexSwitchToOfficialLogin, k as commandExists, bt as compareConfigs, bi as configureApi, az as configureCodexApi, b0 as configureCodexMcp, bu as consolidateConfigs, bh as copyConfigFiles, aA as createBackupDirectory, bP as createHomebrewSymlink, bs as detectAllConfigs, a3 as detectBuildTools, a5 as detectCICDSystems, aZ as detectConfigManagementMode, a2 as detectFrameworks, bK as detectInstalledVersion, a6 as detectLanguages, a1 as detectPackageManager, a8 as detectProject, a4 as detectTestFrameworks, a7 as determineProjectType, ab as displayBanner, ac as displayBannerWithInfo, bx as displayConfigScan, h as displayCurrentStatus, bz as displayHealthReport, c9 as displayPermissions, bQ as displayVerificationResult, ao as ensureApiKeyApproved, bf as ensureClaudeDir, aB as ensureEnvKeyMigration, bM as executeInstallMethod, c6 as exportPermissions, bW as exportProjectKnowledge, am as fixWindowsMcpConfig, bd as formatToolStatus, a9 as generateSuggestions, a0 as getAiOutputLanguageLabel, bb as getAllToolsInfo, b7 as getAllToolsStatus, a$ as getAvailableManagementActions, aC as getBackupMessage, aD as getCodexVersion, aE as getCurrentCodexProvider, c8 as getCurrentTemplateId, bo as getExistingApiConfig, bn as getExistingModelConfig, bG as getInstallationStatus, b8 as getInstalledTools, ag as getMcpConfigPath, l as getPlatform, bV as getProjectKnowledge, aa as getProjectSummary, be as getRecommendedTools, b2 as getToolConfigPath, b3 as getToolDir, ba as getToolInfo, b6 as getToolStatus, b5 as getToolVersion, bc as getToolsByCategory, bN as handleInstallFailure, c7 as importPermissions, n as importRecommendedEnv, o as importRecommendedPermissions, i as init, bC as installClaudeCode, bE as installCodex, aF as installCodexCli, b9 as installTool, bB as isClaudeCodeInstalled, U as isCodeToolType, aG as isCodexCliInstalled, bD as isCodexInstalled, c2 as isDirectoryTrusted, bF as isLocalClaudeCodeInstalled, c1 as isPermissionAllowed, b4 as isToolInstalled, aH as listCodexProviders, bR as loadKnowledgeBase, aq as manageApiKeyApproval, af as menuItem, m as mergeAndCleanPermissions, bj as mergeConfigs, ak as mergeMcpServers, bm as mergeSettingsFile, aI as migrateEnvKeyInContent, aJ as migrateEnvKeyToTempEnvKey, aK as needsEnvKeyMigration, p as openSettingsJson, aL as parseCodexConfig, br as promptApiConfigurationAction, bU as quickSync, aM as readCodexConfig, ah as readMcpConfig, bY as readPermissions, ap as removeApiKeyFromRejected, c4 as removeAutoApprovePattern, bH as removeLocalClaudeCode, bw as removeRedundantConfigs, aN as renderCodexConfig, ad as renderProgressBar, c5 as resetPermissions, X as resolveCodeToolType, aO as runCodexFullInit, aP as runCodexSystemPromptSelection, aQ as runCodexUninstall, aR as runCodexUpdate, aS as runCodexWorkflowImport, aT as runCodexWorkflowImportWithLanguageSelection, aU as runCodexWorkflowSelection, r as runConfigWizard, bA as runDoctor, by as runHealthCheck, bT as runOnboarding, bS as saveKnowledgeBase, bL as selectInstallMethod, bJ as setInstallMethod, ar as setPrimaryApiKey, a_ as shouldShowManagementMode, aV as switchCodexProvider, bq as switchToOfficialLogin, aW as switchToProvider, b$ as trustDirectory, bI as uninstallCodeTool, c0 as untrustDirectory, bk as updateCustomModel, bl as updateDefaultModel, ci as upgradeAll, cg as upgradeAllPlugins, ce as upgradeCcjk, cd as upgradeClaudeCode, cf as upgradePlugin, bO as verifyInstallation, aX as writeAuthFile, aY as writeCodexConfig, bv as writeConsolidatedConfig, ai as writeMcpConfig, bZ as writePermissions } from './chunks/simple-config.mjs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join } from 'pathe';
+import { exec } from 'tinyexec';
+export { configureIncrementalManagement } from './chunks/codex-config-switch.mjs';
+export { addProviderToExisting, deleteProviders, editExistingProvider, validateProviderData } from './chunks/codex-provider-manager.mjs';
+export { CodexUninstaller } from './chunks/codex-uninstaller.mjs';
+import ansis from 'ansis';
+import inquirer from 'inquirer';
+import 'node:process';
+import 'smol-toml';
+import 'dayjs';
+import 'node:child_process';
+import 'node:os';
+import 'node:util';
+import 'node:url';
+import 'inquirer-toggle';
+import 'ora';
+import 'semver';
+import 'node:fs/promises';
+import 'fs-extra';
+import 'trash';
+import 'i18next';
+import 'i18next-fs-backend';
+
+const loadedPlugins = /* @__PURE__ */ new Map();
+const PLUGIN_CONFIG_FILE = join(CCJK_PLUGINS_DIR, "plugins.json");
+function ensurePluginsDir() {
+  if (!existsSync(CCJK_PLUGINS_DIR)) {
+    mkdirSync(CCJK_PLUGINS_DIR, { recursive: true });
+  }
+}
+function createLogger(pluginName) {
+  const prefix = `[${pluginName}]`;
+  return {
+    info: (msg) => console.log(`${prefix} ${msg}`),
+    warn: (msg) => console.warn(`${prefix} ${msg}`),
+    error: (msg) => console.error(`${prefix} ${msg}`),
+    debug: (msg) => {
+      if (process.env.DEBUG)
+        console.log(`${prefix} [DEBUG] ${msg}`);
+    }
+  };
+}
+function createStorage(pluginName) {
+  const storageFile = join(CCJK_PLUGINS_DIR, pluginName, "storage.json");
+  let data = {};
+  if (existsSync(storageFile)) {
+    try {
+      data = JSON.parse(readFileSync(storageFile, "utf-8"));
+    } catch {
+      data = {};
+    }
+  }
+  const save = () => {
+    const dir = join(CCJK_PLUGINS_DIR, pluginName);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(storageFile, JSON.stringify(data, null, 2));
+  };
+  return {
+    get: (key) => data[key],
+    set: (key, value) => {
+      data[key] = value;
+      save();
+    },
+    delete: (key) => {
+      delete data[key];
+      save();
+    },
+    clear: () => {
+      data = {};
+      save();
+    }
+  };
+}
+function createContext(pluginName) {
+  const { version } = require("../../package.json");
+  return {
+    ccjkVersion: version,
+    configDir: join(CCJK_PLUGINS_DIR, pluginName),
+    i18n: require("../i18n").i18n,
+    logger: createLogger(pluginName),
+    storage: createStorage(pluginName)
+  };
+}
+function readPluginConfig() {
+  ensurePluginsDir();
+  if (existsSync(PLUGIN_CONFIG_FILE)) {
+    try {
+      return JSON.parse(readFileSync(PLUGIN_CONFIG_FILE, "utf-8"));
+    } catch {
+    }
+  }
+  return {
+    enabled: [],
+    disabled: [],
+    settings: {}
+  };
+}
+function writePluginConfig(config) {
+  ensurePluginsDir();
+  writeFileSync(PLUGIN_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+async function discoverPlugins() {
+  ensurePluginsDir();
+  const results = [];
+  const dirs = readdirSync(CCJK_PLUGINS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  for (const dir of dirs) {
+    const pluginPath = join(CCJK_PLUGINS_DIR, dir);
+    const packagePath = join(pluginPath, "package.json");
+    if (!existsSync(packagePath)) {
+      results.push({
+        name: dir,
+        path: pluginPath,
+        metadata: { name: dir, version: "0.0.0", description: "" },
+        valid: false,
+        error: "Missing package.json"
+      });
+      continue;
+    }
+    try {
+      const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
+      results.push({
+        name: pkg.name || dir,
+        path: pluginPath,
+        metadata: {
+          name: pkg.name || dir,
+          version: pkg.version || "0.0.0",
+          description: pkg.description || "",
+          author: pkg.author,
+          license: pkg.license,
+          keywords: pkg.keywords
+        },
+        valid: true
+      });
+    } catch (error) {
+      results.push({
+        name: dir,
+        path: pluginPath,
+        metadata: { name: dir, version: "0.0.0", description: "" },
+        valid: false,
+        error: error instanceof Error ? error.message : "Invalid package.json"
+      });
+    }
+  }
+  return results;
+}
+async function loadPlugin(pathOrName) {
+  const isPath = pathOrName.includes("/") || pathOrName.includes("\\");
+  const pluginPath = isPath ? pathOrName : join(CCJK_PLUGINS_DIR, pathOrName);
+  if (!existsSync(pluginPath)) {
+    console.error(`Plugin not found: ${pluginPath}`);
+    return null;
+  }
+  try {
+    const indexPath = join(pluginPath, "index.js");
+    const tsIndexPath = join(pluginPath, "index.ts");
+    let plugin;
+    if (existsSync(indexPath)) {
+      plugin = require(indexPath).default || require(indexPath);
+    } else if (existsSync(tsIndexPath)) {
+      plugin = require(tsIndexPath).default || require(tsIndexPath);
+    } else {
+      const pkg = JSON.parse(readFileSync(join(pluginPath, "package.json"), "utf-8"));
+      if (pkg.main) {
+        const mainPath = join(pluginPath, pkg.main);
+        plugin = require(mainPath).default || require(mainPath);
+      } else {
+        throw new Error("No entry point found");
+      }
+    }
+    const context = createContext(plugin.metadata.name);
+    if (plugin.onLoad) {
+      await plugin.onLoad(context);
+    }
+    const loaded = {
+      plugin,
+      path: pluginPath,
+      enabled: true,
+      loadedAt: /* @__PURE__ */ new Date()
+    };
+    loadedPlugins.set(plugin.metadata.name, loaded);
+    return loaded;
+  } catch (error) {
+    console.error(`Failed to load plugin: ${pathOrName}`, error);
+    return null;
+  }
+}
+async function unloadPlugin(name) {
+  const loaded = loadedPlugins.get(name);
+  if (!loaded)
+    return false;
+  try {
+    if (loaded.plugin.onUnload) {
+      await loaded.plugin.onUnload();
+    }
+    loadedPlugins.delete(name);
+    return true;
+  } catch (error) {
+    console.error(`Failed to unload plugin: ${name}`, error);
+    return false;
+  }
+}
+function getLoadedPlugins() {
+  return Array.from(loadedPlugins.values());
+}
+function getPluginInfo(name) {
+  const loaded = loadedPlugins.get(name);
+  if (!loaded)
+    return null;
+  return {
+    name: loaded.plugin.metadata.name,
+    version: loaded.plugin.metadata.version,
+    description: loaded.plugin.metadata.description,
+    enabled: loaded.enabled,
+    path: loaded.path,
+    author: loaded.plugin.metadata.author
+  };
+}
+async function listPlugins() {
+  const discovered = await discoverPlugins();
+  const config = readPluginConfig();
+  return discovered.map((d) => {
+    const loaded = loadedPlugins.get(d.name);
+    return {
+      name: d.name,
+      version: d.metadata.version,
+      description: d.metadata.description,
+      enabled: loaded?.enabled ?? !config.disabled.includes(d.name),
+      path: d.path,
+      author: d.metadata.author
+    };
+  });
+}
+async function enablePlugin(name) {
+  const config = readPluginConfig();
+  config.disabled = config.disabled.filter((n) => n !== name);
+  if (!config.enabled.includes(name)) {
+    config.enabled.push(name);
+  }
+  writePluginConfig(config);
+  if (!loadedPlugins.has(name)) {
+    await loadPlugin(name);
+  } else {
+    const loaded = loadedPlugins.get(name);
+    loaded.enabled = true;
+  }
+  return true;
+}
+async function disablePlugin(name) {
+  const config = readPluginConfig();
+  config.enabled = config.enabled.filter((n) => n !== name);
+  if (!config.disabled.includes(name)) {
+    config.disabled.push(name);
+  }
+  writePluginConfig(config);
+  if (loadedPlugins.has(name)) {
+    await unloadPlugin(name);
+  }
+  return true;
+}
+function getPluginWorkflows() {
+  const workflows = [];
+  for (const loaded of loadedPlugins.values()) {
+    if (loaded.enabled && loaded.plugin.workflows) {
+      workflows.push(...loaded.plugin.workflows);
+    }
+  }
+  return workflows;
+}
+function getPluginAgents() {
+  const agents = [];
+  for (const loaded of loadedPlugins.values()) {
+    if (loaded.enabled && loaded.plugin.agents) {
+      agents.push(...loaded.plugin.agents);
+    }
+  }
+  return agents;
+}
+function getPluginMcpServices() {
+  const services = [];
+  for (const loaded of loadedPlugins.values()) {
+    if (loaded.enabled && loaded.plugin.mcpServices) {
+      services.push(...loaded.plugin.mcpServices);
+    }
+  }
+  return services;
+}
+function getPluginOutputStyles() {
+  const styles = [];
+  for (const loaded of loadedPlugins.values()) {
+    if (loaded.enabled && loaded.plugin.outputStyles) {
+      styles.push(...loaded.plugin.outputStyles);
+    }
+  }
+  return styles;
+}
+function getPluginSkills() {
+  const skills = [];
+  for (const loaded of loadedPlugins.values()) {
+    if (loaded.enabled && loaded.plugin.skills) {
+      skills.push(...loaded.plugin.skills);
+    }
+  }
+  return skills;
+}
+async function initializePlugins() {
+  const config = readPluginConfig();
+  const discovered = await discoverPlugins();
+  for (const plugin of discovered) {
+    if (plugin.valid && !config.disabled.includes(plugin.name)) {
+      await loadPlugin(plugin.path);
+    }
+  }
+}
+
+let registry$1 = null;
+function ensureSkillsDir() {
+  if (!existsSync(CCJK_SKILLS_DIR)) {
+    mkdirSync(CCJK_SKILLS_DIR, { recursive: true });
+  }
+}
+function getRegistry$1() {
+  if (!registry$1) {
+    registry$1 = loadRegistry$1();
+  }
+  return registry$1;
+}
+function loadRegistry$1() {
+  ensureSkillsDir();
+  const skills = /* @__PURE__ */ new Map();
+  const categories = /* @__PURE__ */ new Map();
+  const files = readdirSync(CCJK_SKILLS_DIR).filter((f) => f.endsWith(".json"));
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(CCJK_SKILLS_DIR, file), "utf-8");
+      const skill = JSON.parse(content);
+      skills.set(skill.id, skill);
+      const categorySkills = categories.get(skill.category) || [];
+      categorySkills.push(skill.id);
+      categories.set(skill.category, categorySkills);
+    } catch {
+    }
+  }
+  return {
+    skills,
+    categories,
+    lastUpdated: /* @__PURE__ */ new Date()
+  };
+}
+function refreshRegistry$1() {
+  registry$1 = loadRegistry$1();
+}
+function getAllSkills() {
+  return Array.from(getRegistry$1().skills.values());
+}
+function getSkill(id) {
+  return getRegistry$1().skills.get(id);
+}
+function searchSkills(options) {
+  let skills = getAllSkills();
+  if (options.category) {
+    skills = skills.filter((s) => s.category === options.category);
+  }
+  if (options.enabled !== void 0) {
+    skills = skills.filter((s) => s.enabled === options.enabled);
+  }
+  if (options.tags && options.tags.length > 0) {
+    skills = skills.filter(
+      (s) => s.tags && options.tags.some((tag) => s.tags.includes(tag))
+    );
+  }
+  if (options.query) {
+    const query = options.query.toLowerCase();
+    skills = skills.filter(
+      (s) => s.id.toLowerCase().includes(query) || s.name.en.toLowerCase().includes(query) || s.name["zh-CN"].toLowerCase().includes(query) || s.triggers.some((t) => t.toLowerCase().includes(query))
+    );
+  }
+  if (options.limit) {
+    skills = skills.slice(0, options.limit);
+  }
+  return skills;
+}
+function addSkill(skill) {
+  ensureSkillsDir();
+  try {
+    const filePath = join(CCJK_SKILLS_DIR, `${skill.id}.json`);
+    writeFileSync(filePath, JSON.stringify(skill, null, 2));
+    refreshRegistry$1();
+    return {
+      skillId: skill.id,
+      success: true,
+      path: filePath
+    };
+  } catch (error) {
+    return {
+      skillId: skill.id,
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function removeSkill(id) {
+  const filePath = join(CCJK_SKILLS_DIR, `${id}.json`);
+  if (existsSync(filePath)) {
+    const fs = require("node:fs");
+    fs.unlinkSync(filePath);
+    refreshRegistry$1();
+    return true;
+  }
+  return false;
+}
+function setSkillEnabled(id, enabled) {
+  const skill = getSkill(id);
+  if (!skill)
+    return false;
+  skill.enabled = enabled;
+  addSkill(skill);
+  return true;
+}
+function exportSkills(skillIds) {
+  const skills = skillIds ? skillIds.map((id) => getSkill(id)).filter(Boolean) : getAllSkills();
+  return {
+    version: "1.0.0",
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills
+  };
+}
+function importSkills(data) {
+  return data.skills.map((skill) => addSkill(skill));
+}
+const BATCH_TEMPLATES = {
+  typescript: {
+    category: "dev",
+    skills: [
+      {
+        id: "ts-debug",
+        name: { "en": "TypeScript Debug", "zh-CN": "TypeScript \u8C03\u8BD5" },
+        description: { "en": "Debug TypeScript code", "zh-CN": "\u8C03\u8BD5 TypeScript \u4EE3\u7801" },
+        triggers: ["/ts-debug", "/tsd"],
+        templateFile: "ts-debug.md",
+        tags: ["typescript", "debug"]
+      },
+      {
+        id: "ts-refactor",
+        name: { "en": "TypeScript Refactor", "zh-CN": "TypeScript \u91CD\u6784" },
+        description: { "en": "Refactor TypeScript code", "zh-CN": "\u91CD\u6784 TypeScript \u4EE3\u7801" },
+        triggers: ["/ts-refactor", "/tsr"],
+        templateFile: "ts-refactor.md",
+        tags: ["typescript", "refactor"]
+      },
+      {
+        id: "ts-test",
+        name: { "en": "TypeScript Test", "zh-CN": "TypeScript \u6D4B\u8BD5" },
+        description: { "en": "Generate TypeScript tests", "zh-CN": "\u751F\u6210 TypeScript \u6D4B\u8BD5" },
+        triggers: ["/ts-test", "/tst"],
+        templateFile: "ts-test.md",
+        tags: ["typescript", "testing"]
+      },
+      {
+        id: "ts-type-check",
+        name: { "en": "TypeScript Type Check", "zh-CN": "TypeScript \u7C7B\u578B\u68C0\u67E5" },
+        description: { "en": "Fix TypeScript type errors", "zh-CN": "\u4FEE\u590D TypeScript \u7C7B\u578B\u9519\u8BEF" },
+        triggers: ["/ts-type", "/tstc"],
+        templateFile: "ts-type-check.md",
+        tags: ["typescript", "types"]
+      },
+      {
+        id: "ts-migrate",
+        name: { "en": "TypeScript Migration", "zh-CN": "TypeScript \u8FC1\u79FB" },
+        description: { "en": "Migrate JS to TypeScript", "zh-CN": "\u4ECE JS \u8FC1\u79FB\u5230 TypeScript" },
+        triggers: ["/ts-migrate", "/tsm"],
+        templateFile: "ts-migrate.md",
+        tags: ["typescript", "migration"]
+      }
+    ]
+  },
+  python: {
+    category: "dev",
+    skills: [
+      {
+        id: "py-debug",
+        name: { "en": "Python Debug", "zh-CN": "Python \u8C03\u8BD5" },
+        description: { "en": "Debug Python code", "zh-CN": "\u8C03\u8BD5 Python \u4EE3\u7801" },
+        triggers: ["/py-debug", "/pyd"],
+        templateFile: "py-debug.md",
+        tags: ["python", "debug"]
+      },
+      {
+        id: "py-refactor",
+        name: { "en": "Python Refactor", "zh-CN": "Python \u91CD\u6784" },
+        description: { "en": "Refactor Python code", "zh-CN": "\u91CD\u6784 Python \u4EE3\u7801" },
+        triggers: ["/py-refactor", "/pyr"],
+        templateFile: "py-refactor.md",
+        tags: ["python", "refactor"]
+      },
+      {
+        id: "py-test",
+        name: { "en": "Python Test", "zh-CN": "Python \u6D4B\u8BD5" },
+        description: { "en": "Generate Python tests", "zh-CN": "\u751F\u6210 Python \u6D4B\u8BD5" },
+        triggers: ["/py-test", "/pyt"],
+        templateFile: "py-test.md",
+        tags: ["python", "testing"]
+      }
+    ]
+  },
+  seo: {
+    category: "seo",
+    skills: [
+      {
+        id: "seo-meta",
+        name: { "en": "SEO Meta Optimization", "zh-CN": "SEO \u5143\u6570\u636E\u4F18\u5316" },
+        description: { "en": "Optimize meta tags for SEO", "zh-CN": "\u4F18\u5316 SEO \u5143\u6807\u7B7E" },
+        triggers: ["/seo-meta", "/meta"],
+        templateFile: "seo-meta.md",
+        tags: ["seo", "meta"]
+      },
+      {
+        id: "seo-sitemap",
+        name: { "en": "Sitemap Generator", "zh-CN": "\u7AD9\u70B9\u5730\u56FE\u751F\u6210" },
+        description: { "en": "Generate XML sitemap", "zh-CN": "\u751F\u6210 XML \u7AD9\u70B9\u5730\u56FE" },
+        triggers: ["/sitemap", "/seo-sitemap"],
+        templateFile: "seo-sitemap.md",
+        tags: ["seo", "sitemap"]
+      },
+      {
+        id: "seo-schema",
+        name: { "en": "Schema Markup", "zh-CN": "\u7ED3\u6784\u5316\u6570\u636E\u6807\u8BB0" },
+        description: { "en": "Add structured data markup", "zh-CN": "\u6DFB\u52A0\u7ED3\u6784\u5316\u6570\u636E\u6807\u8BB0" },
+        triggers: ["/schema", "/seo-schema"],
+        templateFile: "seo-schema.md",
+        tags: ["seo", "schema"]
+      },
+      {
+        id: "seo-cwv",
+        name: { "en": "Core Web Vitals", "zh-CN": "\u6838\u5FC3\u7F51\u9875\u6307\u6807" },
+        description: { "en": "Optimize Core Web Vitals", "zh-CN": "\u4F18\u5316\u6838\u5FC3\u7F51\u9875\u6307\u6807" },
+        triggers: ["/cwv", "/seo-cwv"],
+        templateFile: "seo-cwv.md",
+        tags: ["seo", "performance"]
+      }
+    ]
+  },
+  devops: {
+    category: "devops",
+    skills: [
+      {
+        id: "devops-docker",
+        name: { "en": "Docker Setup", "zh-CN": "Docker \u914D\u7F6E" },
+        description: { "en": "Set up Docker configuration", "zh-CN": "\u914D\u7F6E Docker" },
+        triggers: ["/docker", "/devops-docker"],
+        templateFile: "devops-docker.md",
+        tags: ["devops", "docker"]
+      },
+      {
+        id: "devops-ci",
+        name: { "en": "CI Pipeline", "zh-CN": "CI \u6D41\u6C34\u7EBF" },
+        description: { "en": "Set up CI pipeline", "zh-CN": "\u914D\u7F6E CI \u6D41\u6C34\u7EBF" },
+        triggers: ["/ci", "/devops-ci"],
+        templateFile: "devops-ci.md",
+        tags: ["devops", "ci"]
+      },
+      {
+        id: "devops-deploy",
+        name: { "en": "Deploy Script", "zh-CN": "\u90E8\u7F72\u811A\u672C" },
+        description: { "en": "Create deployment script", "zh-CN": "\u521B\u5EFA\u90E8\u7F72\u811A\u672C" },
+        triggers: ["/deploy", "/devops-deploy"],
+        templateFile: "devops-deploy.md",
+        tags: ["devops", "deploy"]
+      },
+      {
+        id: "devops-monitor",
+        name: { "en": "Monitoring Setup", "zh-CN": "\u76D1\u63A7\u914D\u7F6E" },
+        description: { "en": "Set up monitoring", "zh-CN": "\u914D\u7F6E\u76D1\u63A7" },
+        triggers: ["/monitor", "/devops-monitor"],
+        templateFile: "devops-monitor.md",
+        tags: ["devops", "monitoring"]
+      }
+    ]
+  }
+};
+function createBatchSkills(options) {
+  const results = [];
+  if (options.lang) {
+    const template = BATCH_TEMPLATES[options.lang];
+    if (template) {
+      for (const skillDef of template.skills) {
+        const skill = {
+          ...skillDef,
+          category: template.category,
+          enabled: true,
+          version: "1.0.0",
+          template: `# ${skillDef.name.en}
+
+${skillDef.description.en}
+
+This is a placeholder template.`
+        };
+        results.push(addSkill(skill));
+      }
+    }
+  }
+  if (options.seo) {
+    const template = BATCH_TEMPLATES.seo;
+    for (const skillDef of template.skills) {
+      const skill = {
+        ...skillDef,
+        category: template.category,
+        enabled: true,
+        version: "1.0.0",
+        template: `# ${skillDef.name.en}
+
+${skillDef.description.en}
+
+This is a placeholder template.`
+      };
+      results.push(addSkill(skill));
+    }
+  }
+  if (options.devops) {
+    const template = BATCH_TEMPLATES.devops;
+    for (const skillDef of template.skills) {
+      const skill = {
+        ...skillDef,
+        category: template.category,
+        enabled: true,
+        version: "1.0.0",
+        template: `# ${skillDef.name.en}
+
+${skillDef.description.en}
+
+This is a placeholder template.`
+      };
+      results.push(addSkill(skill));
+    }
+  }
+  return results;
+}
+function getBatchCategories() {
+  return Object.keys(BATCH_TEMPLATES);
+}
+
+let registry = null;
+function ensureGroupsDir() {
+  if (!existsSync(CCJK_GROUPS_DIR)) {
+    mkdirSync(CCJK_GROUPS_DIR, { recursive: true });
+  }
+}
+function getRegistry() {
+  if (!registry) {
+    registry = loadRegistry();
+  }
+  return registry;
+}
+function loadRegistry() {
+  ensureGroupsDir();
+  const groups = /* @__PURE__ */ new Map();
+  const enabledGroups = /* @__PURE__ */ new Set();
+  const registryFile = join(CCJK_GROUPS_DIR, "registry.json");
+  if (existsSync(registryFile)) {
+    try {
+      const data = JSON.parse(readFileSync(registryFile, "utf-8"));
+      for (const group of data.groups || []) {
+        groups.set(group.id, group);
+      }
+      for (const id of data.enabled || []) {
+        enabledGroups.add(id);
+      }
+    } catch {
+    }
+  }
+  if (groups.size === 0) {
+    for (const group of PREDEFINED_GROUPS) {
+      groups.set(group.id, group);
+      if (group.defaultEnabled) {
+        enabledGroups.add(group.id);
+      }
+    }
+    saveRegistry({ groups, enabledGroups, lastUpdated: /* @__PURE__ */ new Date() });
+  }
+  return {
+    groups,
+    enabledGroups,
+    lastUpdated: /* @__PURE__ */ new Date()
+  };
+}
+function saveRegistry(reg) {
+  ensureGroupsDir();
+  const registryFile = join(CCJK_GROUPS_DIR, "registry.json");
+  const data = {
+    groups: Array.from(reg.groups.values()),
+    enabled: Array.from(reg.enabledGroups),
+    lastUpdated: reg.lastUpdated.toISOString()
+  };
+  writeFileSync(registryFile, JSON.stringify(data, null, 2));
+}
+function refreshRegistry() {
+  registry = loadRegistry();
+}
+function getAllGroups() {
+  return Array.from(getRegistry().groups.values());
+}
+function getGroup(id) {
+  return getRegistry().groups.get(id);
+}
+function isGroupEnabled(id) {
+  return getRegistry().enabledGroups.has(id);
+}
+function searchGroups(options) {
+  let groups = getAllGroups();
+  if (options.category) {
+    groups = groups.filter((g) => g.category === options.category);
+  }
+  if (options.enabled !== void 0) {
+    const enabledSet = getRegistry().enabledGroups;
+    groups = groups.filter(
+      (g) => options.enabled ? enabledSet.has(g.id) : !enabledSet.has(g.id)
+    );
+  }
+  if (options.query) {
+    const query = options.query.toLowerCase();
+    groups = groups.filter(
+      (g) => g.id.toLowerCase().includes(query) || g.name.en.toLowerCase().includes(query) || g.name["zh-CN"].toLowerCase().includes(query)
+    );
+  }
+  if (options.limit) {
+    groups = groups.slice(0, options.limit);
+  }
+  return groups;
+}
+function enableGroup(id) {
+  const reg = getRegistry();
+  if (!reg.groups.has(id))
+    return false;
+  reg.enabledGroups.add(id);
+  reg.lastUpdated = /* @__PURE__ */ new Date();
+  saveRegistry(reg);
+  return true;
+}
+function disableGroup(id) {
+  const reg = getRegistry();
+  if (!reg.groups.has(id))
+    return false;
+  reg.enabledGroups.delete(id);
+  reg.lastUpdated = /* @__PURE__ */ new Date();
+  saveRegistry(reg);
+  return true;
+}
+function addGroup(group) {
+  const reg = getRegistry();
+  try {
+    reg.groups.set(group.id, group);
+    if (group.defaultEnabled) {
+      reg.enabledGroups.add(group.id);
+    }
+    reg.lastUpdated = /* @__PURE__ */ new Date();
+    saveRegistry(reg);
+    return {
+      groupId: group.id,
+      success: true,
+      installedAgents: group.agents.map((a) => a.id),
+      installedSkills: group.skills
+    };
+  } catch (error) {
+    return {
+      groupId: group.id,
+      success: false,
+      installedAgents: [],
+      installedSkills: [],
+      errors: [error instanceof Error ? error.message : "Unknown error"]
+    };
+  }
+}
+function removeGroup(id) {
+  const reg = getRegistry();
+  if (!reg.groups.has(id))
+    return false;
+  reg.groups.delete(id);
+  reg.enabledGroups.delete(id);
+  reg.lastUpdated = /* @__PURE__ */ new Date();
+  saveRegistry(reg);
+  return true;
+}
+function exportGroups(groupIds) {
+  const groups = groupIds ? groupIds.map((id) => getGroup(id)).filter(Boolean) : getAllGroups();
+  return {
+    version: "1.0.0",
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    groups
+  };
+}
+function importGroups(data) {
+  return data.groups.map((group) => addGroup(group));
+}
+function getEnabledAgents() {
+  const reg = getRegistry();
+  const agents = [];
+  for (const groupId of reg.enabledGroups) {
+    const group = reg.groups.get(groupId);
+    if (group) {
+      agents.push(...group.agents);
+    }
+  }
+  return agents;
+}
+function getEnabledSkillIds() {
+  const reg = getRegistry();
+  const skills = [];
+  for (const groupId of reg.enabledGroups) {
+    const group = reg.groups.get(groupId);
+    if (group) {
+      skills.push(...group.skills);
+    }
+  }
+  return [...new Set(skills)];
+}
+const PREDEFINED_GROUPS = [
+  // TypeScript Development Group
+  {
+    id: "typescript-dev",
+    name: { "en": "TypeScript Development", "zh-CN": "TypeScript \u5F00\u53D1" },
+    description: { "en": "Specialized agents for TypeScript development", "zh-CN": "TypeScript \u5F00\u53D1\u4E13\u7528\u4EE3\u7406" },
+    category: "language",
+    version: "1.0.0",
+    icon: "\u{1F537}",
+    defaultEnabled: false,
+    skills: ["ts-debug", "ts-refactor", "ts-test", "ts-type-check", "ts-migrate"],
+    agents: [
+      {
+        id: "ts-architect",
+        name: "TypeScript Architect",
+        description: "Designs TypeScript architecture, module structure, and type systems",
+        model: "sonnet",
+        required: true,
+        tags: ["typescript", "architecture"],
+        definition: `---
+name: ts-architect
+description: TypeScript architecture and type system expert
+model: sonnet
+---
+
+# TypeScript Architect Agent
+
+## CORE MISSION
+Design robust TypeScript architectures with proper type safety, module organization, and scalable patterns.
+
+## RESPONSIBILITIES
+- Design type-safe API interfaces
+- Create module structure and barrel exports
+- Implement generic utility types
+- Review type definitions for completeness
+- Suggest TypeScript best practices
+
+## ALLOWED ACTIONS
+- Create/modify .ts and .tsx files
+- Design type definitions
+- Implement design patterns
+- Review code architecture
+
+## FORBIDDEN ACTIONS
+- Do not modify test files (delegate to ts-tester)
+- Do not handle runtime debugging (delegate to ts-debugger)
+`
+      },
+      {
+        id: "ts-debugger",
+        name: "TypeScript Debugger",
+        description: "Debugs TypeScript runtime issues and type errors",
+        model: "sonnet",
+        required: true,
+        tags: ["typescript", "debug"],
+        definition: `---
+name: ts-debugger
+description: TypeScript debugging and error resolution expert
+model: sonnet
+---
+
+# TypeScript Debugger Agent
+
+## CORE MISSION
+Identify and resolve TypeScript compilation errors, runtime issues, and type mismatches.
+
+## RESPONSIBILITIES
+- Diagnose type errors
+- Fix runtime exceptions
+- Resolve module resolution issues
+- Debug async/await problems
+- Trace type inference failures
+
+## ALLOWED ACTIONS
+- Debug TypeScript code
+- Fix type errors
+- Add type assertions when needed
+- Improve error handling
+`
+      },
+      {
+        id: "ts-tester",
+        name: "TypeScript Tester",
+        description: "Creates comprehensive TypeScript tests",
+        model: "haiku",
+        required: false,
+        tags: ["typescript", "testing"],
+        definition: `---
+name: ts-tester
+description: TypeScript testing specialist
+model: haiku
+---
+
+# TypeScript Tester Agent
+
+## CORE MISSION
+Create comprehensive, type-safe tests for TypeScript codebases.
+
+## RESPONSIBILITIES
+- Write unit tests with proper typing
+- Create integration tests
+- Mock typed dependencies
+- Test type guards and assertions
+- Achieve high code coverage
+`
+      }
+    ]
+  },
+  // Python Development Group
+  {
+    id: "python-dev",
+    name: { "en": "Python Development", "zh-CN": "Python \u5F00\u53D1" },
+    description: { "en": "Specialized agents for Python development", "zh-CN": "Python \u5F00\u53D1\u4E13\u7528\u4EE3\u7406" },
+    category: "language",
+    version: "1.0.0",
+    icon: "\u{1F40D}",
+    defaultEnabled: false,
+    skills: ["py-debug", "py-refactor", "py-test"],
+    agents: [
+      {
+        id: "py-architect",
+        name: "Python Architect",
+        description: "Designs Python architecture and package structure",
+        model: "sonnet",
+        required: true,
+        tags: ["python", "architecture"],
+        definition: `---
+name: py-architect
+description: Python architecture and design patterns expert
+model: sonnet
+---
+
+# Python Architect Agent
+
+## CORE MISSION
+Design clean, Pythonic architectures with proper package structure and design patterns.
+
+## RESPONSIBILITIES
+- Design package/module structure
+- Implement design patterns (Factory, Strategy, etc.)
+- Create abstract base classes
+- Design API interfaces
+- Review architecture decisions
+`
+      }
+    ]
+  },
+  // SEO Team Group
+  {
+    id: "seo-team",
+    name: { "en": "SEO Team", "zh-CN": "SEO \u56E2\u961F" },
+    description: { "en": "Complete SEO optimization team", "zh-CN": "\u5B8C\u6574\u7684 SEO \u4F18\u5316\u56E2\u961F" },
+    category: "seo",
+    version: "1.0.0",
+    icon: "\u{1F50D}",
+    defaultEnabled: false,
+    skills: ["seo-meta", "seo-sitemap", "seo-schema", "seo-cwv"],
+    agents: [
+      {
+        id: "seo-meta-optimizer",
+        name: "Meta Tag Optimizer",
+        description: "Optimizes meta tags, titles, and descriptions for SEO",
+        model: "haiku",
+        required: true,
+        tags: ["seo", "meta"],
+        definition: `---
+name: seo-meta-optimizer
+description: SEO meta tag optimization specialist
+model: haiku
+---
+
+# SEO Meta Optimizer Agent
+
+## CORE MISSION
+Optimize meta tags, titles, and descriptions for maximum search visibility.
+
+## RESPONSIBILITIES
+- Audit existing meta tags
+- Write compelling title tags (50-60 chars)
+- Create engaging meta descriptions (150-160 chars)
+- Implement Open Graph tags
+- Add Twitter Card meta tags
+`
+      },
+      {
+        id: "seo-content-analyst",
+        name: "Content Analyst",
+        description: "Analyzes content for SEO optimization opportunities",
+        model: "sonnet",
+        required: true,
+        tags: ["seo", "content"],
+        definition: `---
+name: seo-content-analyst
+description: SEO content analysis specialist
+model: sonnet
+---
+
+# SEO Content Analyst Agent
+
+## CORE MISSION
+Analyze and optimize content for search engine visibility and user engagement.
+
+## RESPONSIBILITIES
+- Analyze keyword density
+- Check heading hierarchy (H1-H6)
+- Evaluate content structure
+- Suggest internal linking
+- Review image alt texts
+`
+      },
+      {
+        id: "seo-schema-expert",
+        name: "Schema Markup Expert",
+        description: "Implements structured data and schema markup",
+        model: "haiku",
+        required: false,
+        tags: ["seo", "schema"],
+        definition: `---
+name: seo-schema-expert
+description: Schema.org structured data specialist
+model: haiku
+---
+
+# SEO Schema Expert Agent
+
+## CORE MISSION
+Implement proper Schema.org structured data for enhanced search results.
+
+## RESPONSIBILITIES
+- Add JSON-LD structured data
+- Implement product schema
+- Create article/blog schema
+- Add organization schema
+- Validate with Google Rich Results Test
+`
+      }
+    ]
+  },
+  // DevOps Team Group
+  {
+    id: "devops-team",
+    name: { "en": "DevOps Team", "zh-CN": "DevOps \u56E2\u961F" },
+    description: { "en": "Complete DevOps and infrastructure team", "zh-CN": "\u5B8C\u6574\u7684 DevOps \u548C\u57FA\u7840\u8BBE\u65BD\u56E2\u961F" },
+    category: "devops",
+    version: "1.0.0",
+    icon: "\u{1F680}",
+    defaultEnabled: false,
+    skills: ["devops-docker", "devops-ci", "devops-deploy", "devops-monitor"],
+    agents: [
+      {
+        id: "devops-docker-expert",
+        name: "Docker Expert",
+        description: "Containerization and Docker configuration specialist",
+        model: "sonnet",
+        required: true,
+        tags: ["devops", "docker"],
+        definition: `---
+name: devops-docker-expert
+description: Docker and containerization specialist
+model: sonnet
+---
+
+# Docker Expert Agent
+
+## CORE MISSION
+Create efficient, secure Docker configurations for applications.
+
+## RESPONSIBILITIES
+- Write optimized Dockerfiles
+- Create docker-compose configurations
+- Implement multi-stage builds
+- Optimize image sizes
+- Configure container networking
+`
+      },
+      {
+        id: "devops-ci-expert",
+        name: "CI/CD Expert",
+        description: "Continuous integration and deployment specialist",
+        model: "sonnet",
+        required: true,
+        tags: ["devops", "ci", "cd"],
+        definition: `---
+name: devops-ci-expert
+description: CI/CD pipeline specialist
+model: sonnet
+---
+
+# CI/CD Expert Agent
+
+## CORE MISSION
+Design and implement robust CI/CD pipelines for automated testing and deployment.
+
+## RESPONSIBILITIES
+- Create GitHub Actions workflows
+- Set up GitLab CI pipelines
+- Configure automated testing
+- Implement deployment strategies
+- Set up artifact management
+`
+      }
+    ]
+  },
+  // Security Team Group
+  {
+    id: "security-team",
+    name: { "en": "Security Team", "zh-CN": "\u5B89\u5168\u56E2\u961F" },
+    description: { "en": "Security audit and vulnerability assessment team", "zh-CN": "\u5B89\u5168\u5BA1\u8BA1\u548C\u6F0F\u6D1E\u8BC4\u4F30\u56E2\u961F" },
+    category: "devops",
+    version: "1.0.0",
+    icon: "\u{1F512}",
+    defaultEnabled: false,
+    skills: [],
+    agents: [
+      {
+        id: "security-auditor",
+        name: "Security Auditor",
+        description: "Performs security audits and vulnerability assessments",
+        model: "opus",
+        required: true,
+        tags: ["security", "audit"],
+        definition: `---
+name: security-auditor
+description: Security audit and vulnerability assessment specialist
+model: opus
+---
+
+# Security Auditor Agent
+
+## CORE MISSION
+Identify and report security vulnerabilities, ensuring code follows security best practices.
+
+## RESPONSIBILITIES
+- Audit code for OWASP Top 10 vulnerabilities
+- Check for SQL injection risks
+- Identify XSS vulnerabilities
+- Review authentication implementations
+- Check authorization logic
+- Audit dependency security
+- Review secrets management
+`
+      }
+    ]
+  }
+];
+
+const DEFAULT_AIDER_CONFIG = {
+  model: "claude-3-5-sonnet-20241022",
+  editFormat: "diff",
+  autoCommits: true,
+  dirtyCommits: false,
+  darkMode: true,
+  prettyOutput: true,
+  showDiffs: true,
+  mapTokens: 1024,
+  maxChatHistory: 20,
+  cachePrompts: true
+};
+async function isAiderInstalled() {
+  try {
+    const result = await exec("aider", ["--version"]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function getAiderVersion() {
+  try {
+    const result = await exec("aider", ["--version"]);
+    return result.stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function installAider() {
+  try {
+    const result = await exec("pip", ["install", "aider-chat"]);
+    if (result.exitCode === 0) {
+      return { success: true, message: "Aider installed successfully via pip" };
+    }
+    const pipxResult = await exec("pipx", ["install", "aider-chat"]);
+    if (pipxResult.exitCode === 0) {
+      return { success: true, message: "Aider installed successfully via pipx" };
+    }
+    return { success: false, message: "Failed to install Aider" };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to install Aider: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+function ensureAiderDir() {
+  if (!existsSync(AIDER_DIR)) {
+    mkdirSync(AIDER_DIR, { recursive: true });
+  }
+}
+function readAiderConfig() {
+  if (!existsSync(AIDER_CONFIG_FILE)) {
+    return DEFAULT_AIDER_CONFIG;
+  }
+  try {
+    const content = readFileSync(AIDER_CONFIG_FILE, "utf-8");
+    return parseYamlConfig(content);
+  } catch {
+    return DEFAULT_AIDER_CONFIG;
+  }
+}
+function writeAiderConfig(config) {
+  ensureAiderDir();
+  const yamlContent = generateYamlConfig(config);
+  writeFileSync(AIDER_CONFIG_FILE, yamlContent);
+}
+function parseYamlConfig(content) {
+  const config = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const match = trimmed.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      const [, key, value] = match;
+      const normalizedKey = kebabToCamel(key);
+      if (value === "true")
+        config[normalizedKey] = true;
+      else if (value === "false")
+        config[normalizedKey] = false;
+      else if (/^\d+$/.test(value))
+        config[normalizedKey] = Number.parseInt(value);
+      else
+        config[normalizedKey] = value;
+    }
+  }
+  return config;
+}
+function generateYamlConfig(config) {
+  const lines = [
+    "# Aider Configuration",
+    "# Generated by CCJK",
+    ""
+  ];
+  for (const [key, value] of Object.entries(config)) {
+    if (value !== void 0) {
+      const yamlKey = camelToKebab(key);
+      lines.push(`${yamlKey}: ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function configureAiderApi(apiKey, apiBase) {
+  ensureAiderDir();
+  const envLines = [];
+  if (apiKey.startsWith("sk-ant")) {
+    envLines.push(`ANTHROPIC_API_KEY=${apiKey}`);
+  } else if (apiKey.startsWith("sk-")) {
+    envLines.push(`OPENAI_API_KEY=${apiKey}`);
+  } else {
+    envLines.push(`ANTHROPIC_API_KEY=${apiKey}`);
+  }
+  if (apiBase) {
+    envLines.push(`OPENAI_API_BASE=${apiBase}`);
+  }
+  writeFileSync(AIDER_ENV_FILE, envLines.join("\n"));
+}
+function getAiderModelPresets() {
+  return {
+    "claude-sonnet": {
+      model: "claude-3-5-sonnet-20241022",
+      description: "Claude 3.5 Sonnet - Best for coding"
+    },
+    "claude-opus": {
+      model: "claude-3-opus-20240229",
+      description: "Claude 3 Opus - Most capable"
+    },
+    "gpt-4o": {
+      model: "gpt-4o",
+      description: "GPT-4o - OpenAI flagship"
+    },
+    "deepseek": {
+      model: "deepseek-chat",
+      description: "DeepSeek - Cost effective"
+    },
+    "gemini": {
+      model: "gemini-1.5-pro",
+      description: "Gemini 1.5 Pro - Google AI"
+    }
+  };
+}
+async function runAider(options) {
+  const args = [];
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.autoCommit === false) {
+    args.push("--no-auto-commits");
+  }
+  if (options.message) {
+    args.push("--message", options.message);
+  }
+  if (options.files && options.files.length > 0) {
+    args.push(...options.files);
+  }
+  try {
+    const result = await exec("aider", args);
+    return {
+      success: result.exitCode === 0,
+      output: result.stdout + result.stderr
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+const DEFAULT_CONTINUE_CONFIG = {
+  models: [
+    {
+      title: "Claude 3.5 Sonnet",
+      provider: "anthropic",
+      model: "claude-3-5-sonnet-20241022"
+    }
+  ],
+  tabAutocompleteModel: {
+    title: "Starcoder2 3B",
+    provider: "ollama",
+    model: "starcoder2:3b"
+  },
+  contextProviders: [
+    { name: "code", params: {} },
+    { name: "docs", params: {} },
+    { name: "diff", params: {} },
+    { name: "terminal", params: {} },
+    { name: "problems", params: {} },
+    { name: "folder", params: {} },
+    { name: "codebase", params: {} }
+  ],
+  slashCommands: [
+    { name: "edit", description: "Edit selected code" },
+    { name: "comment", description: "Add comments to code" },
+    { name: "share", description: "Share conversation" },
+    { name: "cmd", description: "Run terminal command" },
+    { name: "commit", description: "Generate commit message" }
+  ],
+  allowAnonymousTelemetry: false
+};
+function ensureContinueDir() {
+  if (!existsSync(CONTINUE_DIR)) {
+    mkdirSync(CONTINUE_DIR, { recursive: true });
+  }
+}
+function isContinueConfigured() {
+  return existsSync(CONTINUE_CONFIG_FILE);
+}
+function readContinueConfig() {
+  if (!existsSync(CONTINUE_CONFIG_FILE)) {
+    return DEFAULT_CONTINUE_CONFIG;
+  }
+  try {
+    const content = readFileSync(CONTINUE_CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return DEFAULT_CONTINUE_CONFIG;
+  }
+}
+function writeContinueConfig(config) {
+  ensureContinueDir();
+  writeFileSync(CONTINUE_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function addContinueModel(model) {
+  const config = readContinueConfig();
+  if (!config.models) {
+    config.models = [];
+  }
+  config.models = config.models.filter((m) => m.title !== model.title);
+  config.models.push(model);
+  writeContinueConfig(config);
+}
+function removeContinueModel(title) {
+  const config = readContinueConfig();
+  if (!config.models)
+    return false;
+  const initialLength = config.models.length;
+  config.models = config.models.filter((m) => m.title !== title);
+  if (config.models.length < initialLength) {
+    writeContinueConfig(config);
+    return true;
+  }
+  return false;
+}
+function getContinueProviderPresets() {
+  return {
+    "anthropic-sonnet": {
+      title: "Claude 3.5 Sonnet",
+      provider: "anthropic",
+      model: "claude-3-5-sonnet-20241022"
+    },
+    "anthropic-opus": {
+      title: "Claude 3 Opus",
+      provider: "anthropic",
+      model: "claude-3-opus-20240229"
+    },
+    "openai-gpt4o": {
+      title: "GPT-4o",
+      provider: "openai",
+      model: "gpt-4o"
+    },
+    "openai-gpt4": {
+      title: "GPT-4 Turbo",
+      provider: "openai",
+      model: "gpt-4-turbo"
+    },
+    "ollama-llama": {
+      title: "Llama 3.1 (Local)",
+      provider: "ollama",
+      model: "llama3.1:8b"
+    },
+    "ollama-codellama": {
+      title: "Code Llama (Local)",
+      provider: "ollama",
+      model: "codellama:7b"
+    },
+    "gemini-pro": {
+      title: "Gemini Pro",
+      provider: "gemini",
+      model: "gemini-1.5-pro"
+    },
+    "deepseek-chat": {
+      title: "DeepSeek Chat",
+      provider: "deepseek",
+      model: "deepseek-chat"
+    }
+  };
+}
+function configureContinueApi(provider, apiKey, apiBase) {
+  const config = readContinueConfig();
+  if (config.models) {
+    config.models = config.models.map((model) => {
+      if (model.provider === provider) {
+        return {
+          ...model,
+          apiKey,
+          ...apiBase ? { apiBase } : {}
+        };
+      }
+      return model;
+    });
+  }
+  writeContinueConfig(config);
+}
+function addContinueMcpServer(_name, server) {
+  const config = readContinueConfig();
+  if (!config.experimental) {
+    config.experimental = {};
+  }
+  if (!config.experimental.modelContextProtocolServers) {
+    config.experimental.modelContextProtocolServers = [];
+  }
+  config.experimental.modelContextProtocolServers.push(server);
+  writeContinueConfig(config);
+}
+function addContinueCustomCommand(name, description, prompt) {
+  const config = readContinueConfig();
+  if (!config.customCommands) {
+    config.customCommands = [];
+  }
+  config.customCommands = config.customCommands.filter((c) => c.name !== name);
+  config.customCommands.push({ name, description, prompt });
+  writeContinueConfig(config);
+}
+function enableContinueContextProvider(name, params) {
+  const config = readContinueConfig();
+  if (!config.contextProviders) {
+    config.contextProviders = [];
+  }
+  if (!config.contextProviders.find((p) => p.name === name)) {
+    config.contextProviders.push({ name, params });
+    writeContinueConfig(config);
+  }
+}
+function syncSkillsToContinue(skills) {
+  const config = readContinueConfig();
+  if (!config.customCommands) {
+    config.customCommands = [];
+  }
+  for (const skill of skills) {
+    const existingIndex = config.customCommands.findIndex((c) => c.name === skill.id);
+    if (existingIndex >= 0) {
+      config.customCommands[existingIndex] = {
+        name: skill.id,
+        description: skill.description,
+        prompt: skill.template
+      };
+    } else {
+      config.customCommands.push({
+        name: skill.id,
+        description: skill.description,
+        prompt: skill.template
+      });
+    }
+  }
+  writeContinueConfig(config);
+}
+
+class MenuBuilder {
+  sections = [];
+  options;
+  constructor(options) {
+    this.options = {
+      showBack: true,
+      showExit: true,
+      boxStyle: "double",
+      ...options
+    };
+  }
+  /**
+   * Add a section to the menu
+   */
+  addSection(title, icon) {
+    this.sections.push({ title, items: [], icon });
+    return this;
+  }
+  /**
+   * Add an item to the current section
+   */
+  addItem(item) {
+    if (this.sections.length === 0) {
+      this.addSection("");
+    }
+    this.sections[this.sections.length - 1].items.push(item);
+    return this;
+  }
+  /**
+   * Add a separator
+   */
+  addSeparator() {
+    return this;
+  }
+  /**
+   * Render the menu to string
+   */
+  render() {
+    const lines = [];
+    if (this.options.breadcrumb && this.options.breadcrumb.length > 0) {
+      const breadcrumb = this.options.breadcrumb.join(" > ");
+      lines.push(ansis.gray(`  ${breadcrumb}`));
+      lines.push("");
+    }
+    lines.push(sectionDivider(this.options.title, 50));
+    if (this.options.subtitle) {
+      lines.push(ansis.gray(`  ${this.options.subtitle}`));
+    }
+    lines.push("");
+    for (const section of this.sections) {
+      const visibleItems = section.items.filter(
+        (item) => item.visible ? item.visible() : true
+      );
+      if (visibleItems.length === 0)
+        continue;
+      if (section.title) {
+        const icon = section.icon ? `${section.icon} ` : "";
+        lines.push(ansis.white.bold(`  ${icon}${section.title}`));
+      }
+      for (const item of visibleItems) {
+        const keyPart = item.disabled ? ansis.gray(`[${item.key}]`) : item.highlight ? ansis.yellow.bold(`[${item.key}]`) : ansis.cyan.bold(`[${item.key}]`);
+        const iconPart = item.icon ? `${item.icon} ` : "";
+        const labelPart = item.disabled ? ansis.gray(item.label) : item.highlight ? ansis.yellow(item.label) : ansis.white(item.label);
+        const descPart = item.description ? ansis.gray(` - ${item.description}`) : "";
+        lines.push(`    ${keyPart} ${iconPart}${labelPart}${descPart}`);
+      }
+      lines.push("");
+    }
+    const systemItems = [];
+    if (this.options.showBack) {
+      systemItems.push(`${ansis.gray("[B]")} ${ansis.gray("Back")}`);
+    }
+    if (this.options.showExit) {
+      systemItems.push(`${ansis.gray("[Q]")} ${ansis.gray("Quit")}`);
+    }
+    if (systemItems.length > 0) {
+      lines.push(`  ${systemItems.join("  ")}`);
+    }
+    lines.push(ansis.cyan("\u2550".repeat(50)));
+    return lines.join("\n");
+  }
+  /**
+   * Display menu and handle input
+   */
+  async show() {
+    console.log(this.render());
+    const validKeys = /* @__PURE__ */ new Set();
+    const keyMap = /* @__PURE__ */ new Map();
+    for (const section of this.sections) {
+      for (const item2 of section.items) {
+        if (item2.visible ? item2.visible() : true) {
+          if (!item2.disabled) {
+            validKeys.add(item2.key.toLowerCase());
+            validKeys.add(item2.key.toUpperCase());
+            keyMap.set(item2.key.toLowerCase(), item2);
+          }
+        }
+      }
+    }
+    if (this.options.showBack) {
+      validKeys.add("b");
+      validKeys.add("B");
+    }
+    if (this.options.showExit) {
+      validKeys.add("q");
+      validKeys.add("Q");
+    }
+    const { choice } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "choice",
+        message: COLORS.primary("Select option:"),
+        validate: (value) => {
+          if (validKeys.has(value)) {
+            return true;
+          }
+          return "Invalid option. Please try again.";
+        }
+      }
+    ]);
+    const key = choice.toLowerCase();
+    if (key === "b" && this.options.showBack) {
+      return { action: "back" };
+    }
+    if (key === "q" && this.options.showExit) {
+      return { action: "exit" };
+    }
+    const item = keyMap.get(key);
+    if (item) {
+      return item.action();
+    }
+    return { action: "continue" };
+  }
+  /**
+   * Run menu loop until exit or back
+   */
+  async loop() {
+    while (true) {
+      const result = await this.show();
+      if (result.action === "exit" || result.action === "back") {
+        return result;
+      }
+    }
+  }
+}
+async function showQuickMenu(title, items) {
+  const builder = new MenuBuilder({ title, showBack: false });
+  for (const item of items) {
+    builder.addItem({
+      key: item.key,
+      label: item.label,
+      action: async () => {
+        await item.action();
+        return { action: "continue" };
+      }
+    });
+  }
+  await builder.show();
+}
+async function confirm(message, defaultValue = false) {
+  const { result } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "result",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return result;
+}
+function showStatus(type, message) {
+  console.log(STATUS[type](message));
+}
+
+export { AIDER_CONFIG_FILE, AIDER_DIR, AIDER_ENV_FILE, CCJK_GROUPS_DIR, CCJK_PLUGINS_DIR, CCJK_SKILLS_DIR, COLORS, CONTINUE_CONFIG_FILE, CONTINUE_DIR, MenuBuilder, STATUS, addContinueCustomCommand, addContinueMcpServer, addContinueModel, addGroup, addSkill, configureAiderApi, configureContinueApi, confirm, createBatchSkills, disableGroup, disablePlugin, discoverPlugins, enableContinueContextProvider, enableGroup, enablePlugin, ensureAiderDir, ensureContinueDir, ensureGroupsDir, ensurePluginsDir, ensureSkillsDir, exportGroups, exportSkills, getAiderModelPresets, getAiderVersion, getAllGroups, getAllSkills, getBatchCategories, getContinueProviderPresets, getEnabledAgents, getEnabledSkillIds, getGroup, getRegistry as getGroupRegistry, getLoadedPlugins, getPluginAgents, getPluginInfo, getPluginMcpServices, getPluginOutputStyles, getPluginSkills, getPluginWorkflows, getSkill, getRegistry$1 as getSkillRegistry, importGroups, importSkills, initializePlugins, installAider, isAiderInstalled, isContinueConfigured, isGroupEnabled, listPlugins, loadPlugin, readAiderConfig, readContinueConfig, readPluginConfig, refreshRegistry as refreshGroupRegistry, refreshRegistry$1 as refreshSkillRegistry, removeContinueModel, removeGroup, removeSkill, runAider, searchGroups, searchSkills, sectionDivider, setSkillEnabled, showQuickMenu, showStatus, syncSkillsToContinue, unloadPlugin, writeAiderConfig, writeContinueConfig, writePluginConfig };