ccjk 13.6.7 → 14.0.1

package/dist/chunks/claude-config.mjs

@@ -1,286 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { CLAUDE_VSC_CONFIG_FILE, CLAUDE_DIR, ClAUDE_CONFIG_FILE } from './constants.mjs';
-import { ensureI18nInitialized, i18n } from './index2.mjs';
-import { readJsonConfig, writeJsonConfig, backupJsonConfig } from './json-config.mjs';
-import { i as isWindows, l as getMcpCommand } from './platform.mjs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-
-function mergeArraysUnique(arr1, arr2) {
-  const combined = [...arr1 || [], ...arr2 || []];
-  return [...new Set(combined)];
-}
-function isPlainObject(value) {
-  return value !== null && typeof value === "object" && value.constructor === Object && Object.prototype.toString.call(value) === "[object Object]";
-}
-function deepMerge(target, source, options = {}) {
-  const { mergeArrays = false, arrayMergeStrategy = "replace" } = options;
-  const result = { ...target };
-  for (const key in source) {
-    const sourceValue = source[key];
-    const targetValue = result[key];
-    if (sourceValue === void 0) {
-      continue;
-    }
-    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
-      result[key] = deepMerge(targetValue, sourceValue, options);
-    } else if (Array.isArray(sourceValue)) {
-      if (!mergeArrays || !Array.isArray(targetValue)) {
-        result[key] = sourceValue;
-      } else {
-        switch (arrayMergeStrategy) {
-          case "concat":
-            result[key] = [...targetValue, ...sourceValue];
-            break;
-          case "unique":
-            result[key] = mergeArraysUnique(targetValue, sourceValue);
-            break;
-          case "replace":
-          default:
-            result[key] = sourceValue;
-            break;
-        }
-      }
-    } else {
-      result[key] = sourceValue;
-    }
-  }
-  return result;
-}
-function deepClone(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (obj instanceof Date) {
-    return new Date(obj.getTime());
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => deepClone(item));
-  }
-  if (isPlainObject(obj)) {
-    const cloned = {};
-    for (const key in obj) {
-      cloned[key] = deepClone(obj[key]);
-    }
-    return cloned;
-  }
-  return obj;
-}
-
-function readMcpConfig() {
-  return readJsonConfig(ClAUDE_CONFIG_FILE);
-}
-function writeMcpConfig(config) {
-  writeJsonConfig(ClAUDE_CONFIG_FILE, config);
-}
-function backupMcpConfig() {
-  const backupBaseDir = join(CLAUDE_DIR, "backup");
-  return backupJsonConfig(ClAUDE_CONFIG_FILE, backupBaseDir);
-}
-function mergeMcpServers(existing, newServers) {
-  const config = existing || { mcpServers: {} };
-  if (!config.mcpServers) {
-    config.mcpServers = {};
-  }
-  Object.assign(config.mcpServers, newServers);
-  return config;
-}
-function replaceMcpServers(existing, newServers) {
-  const config = existing ? { ...existing } : { mcpServers: {} };
-  config.mcpServers = { ...newServers };
-  return config;
-}
-function applyPlatformCommand(config) {
-  if (isWindows() && config.command) {
-    const mcpCmd = getMcpCommand(config.command);
-    if (mcpCmd[0] === "cmd") {
-      config.command = mcpCmd[0];
-      config.args = [...mcpCmd.slice(1), ...config.args || []];
-    }
-  }
-}
-function buildMcpServerConfig(baseConfig, apiKey, placeholder = "YOUR_EXA_API_KEY", envVarName) {
-  const config = deepClone(baseConfig);
-  applyPlatformCommand(config);
-  if (!apiKey) {
-    return config;
-  }
-  if (envVarName && config.env) {
-    config.env[envVarName] = apiKey;
-    return config;
-  }
-  if (config.args) {
-    config.args = config.args.map((arg) => arg.replace(placeholder, apiKey));
-  }
-  if (config.url) {
-    config.url = config.url.replace(placeholder, apiKey);
-  }
-  return config;
-}
-function fixWindowsMcpConfig(config) {
-  if (!isWindows() || !config.mcpServers) {
-    return config;
-  }
-  const fixed = { ...config };
-  for (const [, serverConfig] of Object.entries(fixed.mcpServers)) {
-    if (serverConfig && typeof serverConfig === "object" && "command" in serverConfig) {
-      applyPlatformCommand(serverConfig);
-    }
-  }
-  return fixed;
-}
-function addCompletedOnboarding() {
-  try {
-    let config = readMcpConfig();
-    if (!config) {
-      config = { mcpServers: {} };
-    }
-    if (config.hasCompletedOnboarding === true) {
-      return;
-    }
-    config.hasCompletedOnboarding = true;
-    writeMcpConfig(config);
-  } catch (error) {
-    console.error("Failed to add onboarding flag", error);
-    throw error;
-  }
-}
-function ensureApiKeyApproved(config, apiKey) {
-  if (!apiKey || typeof apiKey !== "string" || apiKey.trim() === "") {
-    return config;
-  }
-  const truncatedApiKey = apiKey.substring(0, 20);
-  const updatedConfig = { ...config };
-  if (!updatedConfig.customApiKeyResponses) {
-    updatedConfig.customApiKeyResponses = {
-      approved: [],
-      rejected: []
-    };
-  }
-  if (!Array.isArray(updatedConfig.customApiKeyResponses.approved)) {
-    updatedConfig.customApiKeyResponses.approved = [];
-  }
-  if (!Array.isArray(updatedConfig.customApiKeyResponses.rejected)) {
-    updatedConfig.customApiKeyResponses.rejected = [];
-  }
-  const rejectedIndex = updatedConfig.customApiKeyResponses.rejected.indexOf(truncatedApiKey);
-  if (rejectedIndex > -1) {
-    updatedConfig.customApiKeyResponses.rejected.splice(rejectedIndex, 1);
-  }
-  if (!updatedConfig.customApiKeyResponses.approved.includes(truncatedApiKey)) {
-    updatedConfig.customApiKeyResponses.approved.push(truncatedApiKey);
-  }
-  return updatedConfig;
-}
-function manageApiKeyApproval(apiKey) {
-  try {
-    let config = readMcpConfig();
-    if (!config) {
-      config = { mcpServers: {} };
-    }
-    const updatedConfig = ensureApiKeyApproved(config, apiKey);
-    writeMcpConfig(updatedConfig);
-  } catch (error) {
-    ensureI18nInitialized();
-    console.error(i18n.t("mcp:apiKeyApprovalFailed"), error);
-  }
-}
-function setPrimaryApiKey() {
-  try {
-    let config = readJsonConfig(CLAUDE_VSC_CONFIG_FILE);
-    if (!config) {
-      config = {};
-    }
-    config.primaryApiKey = "ccjk";
-    writeJsonConfig(CLAUDE_VSC_CONFIG_FILE, config);
-  } catch (error) {
-    ensureI18nInitialized();
-    console.error(i18n.t("mcp:primaryApiKeySetFailed"), error);
-  }
-}
-function setMyclaudeProviderProfiles(profiles, activeProfileId) {
-  const config = readMcpConfig() || { mcpServers: {} };
-  config.myclaudeProviderProfiles = profiles;
-  config.myclaudeActiveProviderProfileId = activeProfileId ?? profiles[0]?.id;
-  writeMcpConfig(config);
-}
-function setMyclaudeActiveProviderProfile(activeProfileId) {
-  const config = readMcpConfig() || { mcpServers: {} };
-  config.myclaudeActiveProviderProfileId = activeProfileId ?? "";
-  writeMcpConfig(config);
-}
-function toMyclaudeProviderProfile(profile, existing) {
-  return {
-    id: profile.id || existing?.id || profile.name,
-    name: profile.name,
-    provider: profile.provider || existing?.provider || "custom",
-    apiKey: profile.apiKey,
-    baseUrl: profile.baseUrl,
-    model: profile.primaryModel,
-    fastModel: profile.defaultHaikuModel,
-    authType: profile.authType,
-    primaryModel: profile.primaryModel,
-    defaultHaikuModel: profile.defaultHaikuModel,
-    defaultSonnetModel: profile.defaultSonnetModel,
-    defaultOpusModel: profile.defaultOpusModel
-  };
-}
-function syncMyclaudeProviderProfilesFromClaudeConfig(configData) {
-  if (!configData) {
-    clearMyclaudeProviderProfiles();
-    return;
-  }
-  const existingProfiles = readMcpConfig()?.myclaudeProviderProfiles || [];
-  const existingById = new Map(existingProfiles.map((profile) => [String(profile.id), profile]));
-  const profiles = Object.entries(configData.profiles).map(([id, profile]) => toMyclaudeProviderProfile({ ...profile, id }, existingById.get(id)));
-  setMyclaudeProviderProfiles(profiles, configData.currentProfileId ?? "");
-}
-function clearMyclaudeProviderProfiles() {
-  const config = readMcpConfig();
-  if (!config) {
-    return;
-  }
-  delete config.myclaudeProviderProfiles;
-  delete config.myclaudeActiveProviderProfileId;
-  writeMcpConfig(config);
-}
-function syncMcpPermissions() {
-  const mcpConfig = readMcpConfig();
-  const mcpServerIds = Object.keys(mcpConfig?.mcpServers || {});
-  const settingsPath = join(CLAUDE_DIR, "settings.json");
-  if (!existsSync(settingsPath))
-    return;
-  try {
-    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    if (!settings.permissions?.allow)
-      return;
-    const nonMcpPerms = settings.permissions.allow.filter(
-      (p) => !p.startsWith("mcp__")
-    );
-    const mcpPerms = mcpServerIds.map((id) => `mcp__${id}`);
-    settings.permissions.allow = [...nonMcpPerms, ...mcpPerms];
-    writeJsonConfig(settingsPath, settings);
-  } catch {
-  }
-}
-
-const claudeConfig = {
-  __proto__: null,
-  addCompletedOnboarding: addCompletedOnboarding,
-  backupMcpConfig: backupMcpConfig,
-  buildMcpServerConfig: buildMcpServerConfig,
-  clearMyclaudeProviderProfiles: clearMyclaudeProviderProfiles,
-  ensureApiKeyApproved: ensureApiKeyApproved,
-  fixWindowsMcpConfig: fixWindowsMcpConfig,
-  manageApiKeyApproval: manageApiKeyApproval,
-  mergeMcpServers: mergeMcpServers,
-  readMcpConfig: readMcpConfig,
-  replaceMcpServers: replaceMcpServers,
-  setMyclaudeActiveProviderProfile: setMyclaudeActiveProviderProfile,
-  setMyclaudeProviderProfiles: setMyclaudeProviderProfiles,
-  setPrimaryApiKey: setPrimaryApiKey,
-  syncMcpPermissions: syncMcpPermissions,
-  syncMyclaudeProviderProfilesFromClaudeConfig: syncMyclaudeProviderProfilesFromClaudeConfig,
-  writeMcpConfig: writeMcpConfig
-};
-
-export { buildMcpServerConfig as a, backupMcpConfig as b, syncMyclaudeProviderProfilesFromClaudeConfig as c, setPrimaryApiKey as d, addCompletedOnboarding as e, fixWindowsMcpConfig as f, deepMerge as g, setMyclaudeProviderProfiles as h, clearMyclaudeProviderProfiles as i, replaceMcpServers as j, syncMcpPermissions as k, claudeConfig as l, mergeMcpServers as m, readMcpConfig as r, setMyclaudeActiveProviderProfile as s, writeMcpConfig as w };

package/dist/chunks/intent-engine.mjs

@@ -1,142 +0,0 @@
-import process__default from 'node:process';
-
-const INTENT_RULES = [
-  {
-    keywords: ["commit", "\u63D0\u4EA4", "\u63D0\u4EA4\u4EE3\u7801", "git commit", "\u4FDD\u5B58\u66F4\u6539"],
-    skill: "commit",
-    confidence: 0.9,
-    description: "Smart commit with AI-generated messages"
-  },
-  {
-    keywords: ["github", "gh", "pr", "pull request", "merge request", "\u5408\u5E76\u8BF7\u6C42"],
-    skill: "github",
-    confidence: 0.85,
-    description: "GitHub operations"
-  },
-  {
-    keywords: ["review", "\u5BA1\u67E5", "code review", "\u4EE3\u7801\u5BA1\u67E5", "\u68C0\u67E5\u4EE3\u7801"],
-    skill: "review",
-    confidence: 0.85,
-    description: "Code review"
-  },
-  {
-    keywords: ["test", "\u6D4B\u8BD5", "run test", "\u8FD0\u884C\u6D4B\u8BD5", "testing"],
-    skill: "test",
-    confidence: 0.8,
-    description: "Run tests"
-  },
-  {
-    keywords: ["doc", "\u6587\u6863", "documentation", "\u751F\u6210\u6587\u6863", "generate doc"],
-    skill: "doc",
-    confidence: 0.8,
-    description: "Generate documentation"
-  },
-  {
-    keywords: ["deploy", "\u90E8\u7F72", "deployment", "\u53D1\u5E03", "release"],
-    skill: "deploy",
-    confidence: 0.85,
-    description: "Deploy application"
-  },
-  {
-    keywords: ["fix", "\u4FEE\u590D", "bug", "debug", "\u8C03\u8BD5", "error", "\u9519\u8BEF"],
-    skill: "fix",
-    confidence: 0.75,
-    description: "Fix bugs and errors"
-  },
-  {
-    keywords: ["refactor", "\u91CD\u6784", "optimize", "\u4F18\u5316", "improve", "\u6539\u8FDB"],
-    skill: "refactor",
-    confidence: 0.75,
-    description: "Refactor code"
-  }
-];
-function recognizeIntent(input) {
-  const normalizedInput = input.toLowerCase().trim();
-  let bestMatch = null;
-  let highestScore = 0;
-  for (const rule of INTENT_RULES) {
-    const matchedKeywords = [];
-    let score = 0;
-    for (const keyword of rule.keywords) {
-      if (normalizedInput.includes(keyword.toLowerCase())) {
-        matchedKeywords.push(keyword);
-        if (normalizedInput === keyword.toLowerCase()) {
-          score += 1;
-        } else {
-          score += 0.5;
-        }
-      }
-    }
-    const confidence = score / rule.keywords.length;
-    if (confidence >= rule.confidence && score > highestScore) {
-      highestScore = score;
-      bestMatch = {
-        skill: rule.skill,
-        confidence,
-        description: rule.description,
-        matchedKeywords
-      };
-    }
-  }
-  return bestMatch;
-}
-function shouldTriggerSkill(args) {
-  if (args.length > 0 && args[0].startsWith("/")) {
-    return null;
-  }
-  const knownCommands = [
-    "init",
-    "update",
-    "doctor",
-    "help",
-    "mcp",
-    "skill",
-    "agent",
-    "hook",
-    "memory",
-    "quick-setup",
-    "config",
-    "template",
-    "brain",
-    "session"
-  ];
-  if (args.length > 0 && knownCommands.includes(args[0])) {
-    return null;
-  }
-  const input = args.join(" ");
-  return recognizeIntent(input);
-}
-async function executeSkill(skillName, _originalArgs) {
-  try {
-    const { executeSlashCommand } = await import('./slash-commands.mjs');
-    const skillCommand = `/${skillName}`;
-    const handled = await executeSlashCommand(skillCommand);
-    return handled;
-  } catch (error) {
-    console.error(`Failed to execute skill "${skillName}":`, error);
-    return false;
-  }
-}
-async function handleIntentRecognition() {
-  const args = process__default.argv.slice(2);
-  const intent = shouldTriggerSkill(args);
-  if (!intent) {
-    return false;
-  }
-  if (intent.confidence >= 0.9) {
-    console.log(`\u{1F3AF} Detected intent: ${intent.description}`);
-    console.log(`   Executing skill: /${intent.skill}
-`);
-    return await executeSkill(intent.skill);
-  }
-  if (intent.confidence >= 0.7) {
-    console.log(`\u{1F914} Did you mean: /${intent.skill} (${intent.description})?`);
-    console.log(`   Matched keywords: ${intent.matchedKeywords.join(", ")}`);
-    console.log(`   Confidence: ${(intent.confidence * 100).toFixed(0)}%
-`);
-    return await executeSkill(intent.skill);
-  }
-  return false;
-}
-
-export { executeSkill, handleIntentRecognition, recognizeIntent, shouldTriggerSkill };