ccjk 2.0.20 → 2.2.1

package/dist/shared/ccjk.B7169qud.mjs

@@ -0,0 +1,25 @@
+import process from 'node:process';
+import ansis from 'ansis';
+import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
+
+function handleExitPromptError(error) {
+  const isExitError = error instanceof Error && (error.name === "ExitPromptError" || error.message?.includes("ExitPromptError") || error.message?.includes("User force closed the prompt"));
+  if (isExitError) {
+    ensureI18nInitialized();
+    console.log(ansis.cyan(`
+${i18n.t("common:goodbye")}
+`));
+    process.exit(0);
+  }
+  return false;
+}
+function handleGeneralError(error) {
+  ensureI18nInitialized();
+  console.error(ansis.red(`${i18n.t("errors:generalError")}:`), error);
+  if (error instanceof Error) {
+    console.error(ansis.gray(`${i18n.t("errors:stackTrace")}: ${error.stack}`));
+  }
+  process.exit(1);
+}
+
+export { handleGeneralError as a, handleExitPromptError as h };

package/dist/shared/ccjk.BhKlRJ0h.mjs

@@ -0,0 +1,114 @@
+import ansis from 'ansis';
+import { homepage, version } from '../chunks/package.mjs';
+import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
+
+const COLORS = {
+  primary: ansis.hex("#00D4FF"),
+  // Cyan blue
+  secondary: ansis.hex("#00FF88"),
+  // Spring green
+  accent: ansis.hex("#FFD700"),
+  // Gold
+  warning: ansis.hex("#FFA500"),
+  // Orange
+  error: ansis.hex("#FF4444"),
+  // Red
+  success: ansis.hex("#00FF7F"),
+  // Green
+  muted: ansis.gray,
+  bold: ansis.bold
+};
+function getDisplayWidth(str) {
+  let width = 0;
+  for (const char of str) {
+    if (char.match(/[\u4E00-\u9FFF\uFF01-\uFF60\u3000-\u303F]/)) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function padToDisplayWidth(str, targetWidth) {
+  const currentWidth = getDisplayWidth(str);
+  const paddingNeeded = Math.max(0, targetWidth - currentWidth);
+  return str + " ".repeat(paddingNeeded);
+}
+function displayBanner(subtitle) {
+  ensureI18nInitialized();
+  const defaultSubtitle = i18n.t("cli:banner.subtitle");
+  const subtitleText = subtitle || defaultSubtitle;
+  const paddedSubtitle = padToDisplayWidth(subtitleText, 28);
+  console.log(
+    ansis.cyan.bold(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                               \u2551
+\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557                           \u2551
+\u2551  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D      \u2588\u2588\u2551\u2588\u2588\u2551 \u2588\u2588\u2554\u255D                           \u2551
+\u2551  \u2588\u2588\u2551      \u2588\u2588\u2551           \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2554\u255D    ${ansis.white.bold("JinKu")}                 \u2551
+\u2551  \u2588\u2588\u2551      \u2588\u2588\u2551      \u2588\u2588   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2588\u2588\u2557    ${ansis.gray(`v${version}`)}${" ".repeat(Math.max(0, 17 - version.length))}\u2551
+\u2551  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u255A\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2557                           \u2551
+\u2551   \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D   ${ansis.gray(paddedSubtitle)} \u2551
+\u2551                                                               \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+  );
+}
+function displayBannerWithInfo(subtitle) {
+  displayBanner(subtitle);
+  console.log(ansis.gray(`  ${ansis.cyan("ccjk")} - Advanced AI Development Assistant`));
+  console.log(ansis.gray(`  ${ansis.cyan(homepage)}
+`));
+}
+function renderProgressBar(progress, width = 30) {
+  const filled = Math.round(progress / 100 * width);
+  const empty = width - filled;
+  const bar = COLORS.primary("\u2588".repeat(filled)) + ansis.gray("\u2591".repeat(empty));
+  const percentage = `${Math.round(progress)}%`.padStart(4);
+  return `[${bar}] ${ansis.cyan(percentage)}`;
+}
+const BOX_CHARS = {
+  single: { tl: "\u250C", tr: "\u2510", bl: "\u2514", br: "\u2518", h: "\u2500", v: "\u2502" },
+  double: { tl: "\u2554", tr: "\u2557", bl: "\u255A", br: "\u255D", h: "\u2550", v: "\u2551" },
+  rounded: { tl: "\u256D", tr: "\u256E", bl: "\u2570", br: "\u256F", h: "\u2500", v: "\u2502" },
+  heavy: { tl: "\u250F", tr: "\u2513", bl: "\u2517", br: "\u251B", h: "\u2501", v: "\u2503" }
+};
+function boxify(content, style = "double", title) {
+  const chars = BOX_CHARS[style];
+  const lines = content.split("\n");
+  const maxWidth = Math.max(...lines.map(getDisplayWidth), title ? getDisplayWidth(title) + 4 : 0);
+  const paddedLines = lines.map((line) => {
+    const padding = maxWidth - getDisplayWidth(line);
+    return `${chars.v} ${line}${" ".repeat(padding)} ${chars.v}`;
+  });
+  let topBorder = `${chars.tl}${chars.h.repeat(maxWidth + 2)}${chars.tr}`;
+  if (title) {
+    const titlePadding = Math.floor((maxWidth - getDisplayWidth(title)) / 2);
+    topBorder = `${chars.tl}${chars.h.repeat(titlePadding)} ${title} ${chars.h.repeat(maxWidth - titlePadding - getDisplayWidth(title))}${chars.tr}`;
+  }
+  const bottomBorder = `${chars.bl}${chars.h.repeat(maxWidth + 2)}${chars.br}`;
+  return [topBorder, ...paddedLines, bottomBorder].join("\n");
+}
+function sectionDivider(title, width = 50) {
+  if (!title) {
+    return ansis.cyan("\u2550".repeat(width));
+  }
+  const padding = Math.floor((width - getDisplayWidth(title) - 2) / 2);
+  return ansis.cyan(`${"\u2550".repeat(padding)} ${ansis.white.bold(title)} ${"\u2550".repeat(width - padding - getDisplayWidth(title) - 2)}`);
+}
+const STATUS = {
+  success: (text) => `${ansis.green("\u2713")} ${text}`,
+  error: (text) => `${ansis.red("\u2717")} ${text}`,
+  warning: (text) => `${ansis.yellow("\u26A0")} ${text}`,
+  info: (text) => `${ansis.blue("\u2139")} ${text}`,
+  pending: (text) => `${ansis.gray("\u25CB")} ${text}`,
+  inProgress: (text) => `${ansis.cyan("\u25D0")} ${text}`
+};
+function menuItem(key, label, description) {
+  const keyPart = ansis.cyan.bold(`[${key}]`);
+  const labelPart = ansis.white(label);
+  const descPart = description ? ansis.gray(` - ${description}`) : "";
+  return `  ${keyPart} ${labelPart}${descPart}`;
+}
+
+export { COLORS as C, STATUS as S, displayBannerWithInfo as a, boxify as b, displayBanner as d, getDisplayWidth as g, menuItem as m, padToDisplayWidth as p, renderProgressBar as r, sectionDivider as s };

package/dist/shared/ccjk.Bi-m3LKY.mjs

@@ -0,0 +1,357 @@
+import { existsSync } from 'node:fs';
+import { readFile, mkdir, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'pathe';
+import { i18n } from '../chunks/index2.mjs';
+import { writeFileAtomicAsync } from '../chunks/fs-operations.mjs';
+
+const DEFAULT_REGISTRY_URL = "https://registry.ccjk.dev/v1";
+const DEFAULT_CACHE_CONFIG = {
+  cacheDir: join(homedir(), ".ccjk", "cache"),
+  ttl: 3600,
+  // 1 hour
+  enabled: true
+};
+const BUILTIN_PACKAGES = [
+  // Built-in packages will be added here in future versions
+];
+function getCacheFilePath(cacheDir) {
+  return join(cacheDir, "registry-cache.json");
+}
+async function isCacheValid(cacheDir, ttl) {
+  const cachePath = getCacheFilePath(cacheDir);
+  if (!existsSync(cachePath)) {
+    return false;
+  }
+  try {
+    const content = await readFile(cachePath, "utf-8");
+    const cache = JSON.parse(content);
+    const cacheTime = new Date(cache.lastUpdated).getTime();
+    const now = Date.now();
+    return now - cacheTime < ttl * 1e3;
+  } catch {
+    return false;
+  }
+}
+async function readCachedRegistry(cacheDir) {
+  const cachePath = getCacheFilePath(cacheDir);
+  if (!existsSync(cachePath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeCacheRegistry(cacheDir, registry) {
+  await mkdir(cacheDir, { recursive: true });
+  const cachePath = getCacheFilePath(cacheDir);
+  await writeFileAtomicAsync(cachePath, JSON.stringify(registry, null, 2));
+}
+async function fetchRemoteRegistry(registryUrl = DEFAULT_REGISTRY_URL, timeout = 3e4) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(`${registryUrl}/registry.json`, {
+      signal: controller.signal,
+      headers: {
+        "Accept": "application/json",
+        "User-Agent": "ccjk-cli"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return await response.json();
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function getRegistry(options = {}) {
+  const cacheConfig = { ...DEFAULT_CACHE_CONFIG, ...options.cache };
+  const registryUrl = options.registryUrl || DEFAULT_REGISTRY_URL;
+  if (cacheConfig.enabled && !options.forceRefresh) {
+    const cacheValid = await isCacheValid(cacheConfig.cacheDir, cacheConfig.ttl);
+    if (cacheValid) {
+      const cached = await readCachedRegistry(cacheConfig.cacheDir);
+      if (cached) {
+        return cached;
+      }
+    }
+  }
+  try {
+    const registry = await fetchRemoteRegistry(registryUrl);
+    if (cacheConfig.enabled) {
+      await writeCacheRegistry(cacheConfig.cacheDir, registry);
+    }
+    return registry;
+  } catch {
+    const cached = await readCachedRegistry(cacheConfig.cacheDir);
+    if (cached) {
+      return cached;
+    }
+    return {
+      version: "1.0.0",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      url: registryUrl,
+      packages: BUILTIN_PACKAGES,
+      categories: {
+        "plugin": 0,
+        "skill": 0,
+        "workflow": 0,
+        "agent": 0,
+        "mcp-service": 0,
+        "output-style": 0,
+        "bundle": 0
+      }
+    };
+  }
+}
+async function searchPackages(options = {}) {
+  const registry = await getRegistry();
+  let packages = [...registry.packages];
+  if (options.query) {
+    const query = options.query.toLowerCase();
+    packages = packages.filter(
+      (pkg) => pkg.name.toLowerCase().includes(query) || pkg.id.toLowerCase().includes(query) || pkg.keywords.some((k) => k.toLowerCase().includes(query)) || Object.values(pkg.description).some((d) => d.toLowerCase().includes(query))
+    );
+  }
+  if (options.category) {
+    packages = packages.filter((pkg) => pkg.category === options.category);
+  }
+  if (options.author) {
+    packages = packages.filter(
+      (pkg) => pkg.author.toLowerCase().includes(options.author.toLowerCase())
+    );
+  }
+  if (options.verified) {
+    packages = packages.filter((pkg) => pkg.verified === options.verified);
+  }
+  if (options.keywords?.length) {
+    packages = packages.filter(
+      (pkg) => options.keywords.some((k) => pkg.keywords.includes(k))
+    );
+  }
+  if (options.minRating) {
+    packages = packages.filter((pkg) => pkg.rating >= options.minRating);
+  }
+  if (options.supportedTool) {
+    packages = packages.filter(
+      (pkg) => pkg.supportedTools?.includes(options.supportedTool)
+    );
+  }
+  const sortBy = options.sortBy || "downloads";
+  const sortDir = options.sortDir || "desc";
+  packages.sort((a, b) => {
+    let comparison = 0;
+    switch (sortBy) {
+      case "downloads":
+        comparison = a.downloads - b.downloads;
+        break;
+      case "rating":
+        comparison = a.rating - b.rating;
+        break;
+      case "updated":
+        comparison = new Date(a.updatedAt).getTime() - new Date(b.updatedAt).getTime();
+        break;
+      case "created":
+        comparison = new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
+        break;
+      case "name":
+        comparison = a.name.localeCompare(b.name);
+        break;
+    }
+    return sortDir === "desc" ? -comparison : comparison;
+  });
+  const total = packages.length;
+  const offset = options.offset || 0;
+  const limit = options.limit || 20;
+  packages = packages.slice(offset, offset + limit);
+  return {
+    packages,
+    total,
+    offset,
+    limit,
+    query: options.query,
+    filters: options
+  };
+}
+async function getPackage(packageId) {
+  const registry = await getRegistry();
+  return registry.packages.find((pkg) => pkg.id === packageId) || null;
+}
+
+const DEFAULT_INSTALL_DIR = join(homedir(), ".ccjk", "packages");
+const INSTALLED_MANIFEST = join(homedir(), ".ccjk", "installed-packages.json");
+async function getInstalledPackages() {
+  if (!existsSync(INSTALLED_MANIFEST)) {
+    return [];
+  }
+  try {
+    const content = await readFile(INSTALLED_MANIFEST, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+async function saveInstalledPackages(packages) {
+  const dir = join(homedir(), ".ccjk");
+  await mkdir(dir, { recursive: true });
+  await writeFileAtomicAsync(INSTALLED_MANIFEST, JSON.stringify(packages, null, 2));
+}
+async function isPackageInstalled(packageId) {
+  const installed = await getInstalledPackages();
+  return installed.some((pkg) => pkg.package.id === packageId);
+}
+async function installPackage(packageId, options = {}) {
+  const startTime = Date.now();
+  try {
+    const alreadyInstalled = await isPackageInstalled(packageId);
+    if (alreadyInstalled && !options.force) {
+      const pkg2 = await getPackage(packageId);
+      if (!pkg2) {
+        return {
+          success: false,
+          package: {},
+          error: i18n.t("marketplace:packageNotFound", { name: packageId })
+        };
+      }
+      return {
+        success: true,
+        package: pkg2,
+        alreadyInstalled: true,
+        durationMs: Date.now() - startTime
+      };
+    }
+    const pkg = await getPackage(packageId);
+    if (!pkg) {
+      return {
+        success: false,
+        package: {},
+        error: i18n.t("marketplace:packageNotFound", { name: packageId })
+      };
+    }
+    const warnings = [];
+    if (options.codeToolType && pkg.supportedTools) {
+      if (!pkg.supportedTools.includes(options.codeToolType)) {
+        warnings.push(
+          i18n.t("marketplace:incompatibleTool", {
+            tool: options.codeToolType,
+            supported: pkg.supportedTools.join(", ")
+          })
+        );
+      }
+    }
+    const targetDir = options.targetDir || DEFAULT_INSTALL_DIR;
+    const installPath = join(targetDir, pkg.id);
+    await mkdir(installPath, { recursive: true });
+    const installed = await getInstalledPackages();
+    const installedPackage = {
+      package: pkg,
+      path: installPath,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "marketplace",
+      enabled: true
+    };
+    const existingIndex = installed.findIndex((p) => p.package.id === pkg.id);
+    if (existingIndex >= 0) {
+      installed[existingIndex] = installedPackage;
+    } else {
+      installed.push(installedPackage);
+    }
+    await saveInstalledPackages(installed);
+    return {
+      success: true,
+      package: pkg,
+      installedPath: installPath,
+      warnings: warnings.length > 0 ? warnings : void 0,
+      durationMs: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      package: {},
+      error: error instanceof Error ? error.message : String(error),
+      durationMs: Date.now() - startTime
+    };
+  }
+}
+async function uninstallPackage(packageId, options = {}) {
+  try {
+    const installed = await getInstalledPackages();
+    const pkg = installed.find((p) => p.package.id === packageId);
+    if (!pkg) {
+      return {
+        success: false,
+        packageId,
+        error: i18n.t("marketplace:packageNotInstalled", { name: packageId })
+      };
+    }
+    if (!options.force) {
+      const dependents = installed.filter(
+        (p) => p.package.dependencies && Object.keys(p.package.dependencies).includes(packageId)
+      );
+      if (dependents.length > 0) {
+        return {
+          success: false,
+          packageId,
+          error: i18n.t("marketplace:packageHasDependents", {
+            name: packageId,
+            dependents: dependents.map((p) => p.package.name).join(", ")
+          })
+        };
+      }
+    }
+    if (existsSync(pkg.path)) {
+      await rm(pkg.path, { recursive: true, force: true });
+    }
+    const updated = installed.filter((p) => p.package.id !== packageId);
+    await saveInstalledPackages(updated);
+    return {
+      success: true,
+      packageId
+    };
+  } catch (error) {
+    return {
+      success: false,
+      packageId,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function updatePackage(packageId) {
+  const uninstallResult = await uninstallPackage(packageId, { keepConfig: true });
+  if (!uninstallResult.success) {
+    return {
+      success: false,
+      package: {},
+      error: uninstallResult.error
+    };
+  }
+  return await installPackage(packageId, { force: true });
+}
+async function checkForUpdates() {
+  const installed = await getInstalledPackages();
+  const updates = [];
+  for (const installedPkg of installed) {
+    const latestPkg = await getPackage(installedPkg.package.id);
+    if (!latestPkg)
+      continue;
+    if (latestPkg.version !== installedPkg.package.version) {
+      updates.push({
+        id: installedPkg.package.id,
+        currentVersion: installedPkg.package.version,
+        latestVersion: latestPkg.version,
+        breaking: false,
+        // TODO: Implement semver comparison
+        changelog: latestPkg.changelog,
+        releaseDate: latestPkg.updatedAt
+      });
+    }
+  }
+  return updates;
+}
+
+export { getPackage as a, uninstallPackage as b, checkForUpdates as c, installPackage as d, getInstalledPackages as g, isPackageInstalled as i, searchPackages as s, updatePackage as u };

package/dist/shared/ccjk.COdsoe-Y.mjs

@@ -0,0 +1,64 @@
+const MCP_TIER_DEFAULTS = {
+  core: {
+    tier: "core",
+    autoStart: true,
+    idleTimeout: void 0,
+    // Never timeout
+    description: "Essential services, always available"
+  },
+  ondemand: {
+    tier: "ondemand",
+    autoStart: false,
+    idleTimeout: 300,
+    // 5 minutes
+    description: "Loaded when needed, auto-released after idle"
+  },
+  scenario: {
+    tier: "scenario",
+    autoStart: false,
+    idleTimeout: 600,
+    // 10 minutes
+    description: "Loaded for specific scenarios"
+  }
+};
+const MCP_SERVICE_TIERS = {
+  // Core services - high frequency, essential
+  "context7": "core",
+  "open-websearch": "core",
+  // On-demand services - medium frequency
+  "mcp-deepwiki": "ondemand",
+  "Playwright": "ondemand",
+  "puppeteer": "ondemand",
+  "filesystem": "ondemand",
+  "memory": "ondemand",
+  "sequential-thinking": "ondemand",
+  "fetch": "ondemand",
+  // Scenario services - low frequency, specific use cases
+  "sqlite": "scenario",
+  "spec-workflow": "scenario",
+  "serena": "scenario"
+};
+function getMcpTierConfig(serviceId) {
+  const tier = MCP_SERVICE_TIERS[serviceId] || "ondemand";
+  return MCP_TIER_DEFAULTS[tier];
+}
+function getServicesByTier(tier) {
+  return Object.entries(MCP_SERVICE_TIERS).filter(([_, t]) => t === tier).map(([id]) => id);
+}
+function isCoreService(serviceId) {
+  return MCP_SERVICE_TIERS[serviceId] === "core";
+}
+const MCP_PERFORMANCE_THRESHOLDS = {
+  /** Warning threshold for number of services */
+  warningCount: 5,
+  /** Critical threshold for number of services */
+  criticalCount: 8,
+  /** Maximum recommended services */
+  maxRecommended: 6,
+  /** Estimated memory per service (MB) */
+  estimatedMemoryPerService: 50,
+  /** Estimated CPU overhead per service (%) */
+  estimatedCpuPerService: 5
+};
+
+export { MCP_SERVICE_TIERS as M, getMcpTierConfig as a, MCP_PERFORMANCE_THRESHOLDS as b, getServicesByTier as g, isCoreService as i };

package/dist/shared/ccjk.CUdzQluX.mjs

@@ -0,0 +1,46 @@
+import { DEFAULT_CODE_TOOL_TYPE } from '../chunks/constants.mjs';
+import { i18n } from '../chunks/index2.mjs';
+import { readZcfConfigAsync } from '../chunks/ccjk-config.mjs';
+
+const CODE_TYPE_ABBREVIATIONS = {
+  cc: "claude-code",
+  cx: "codex"
+};
+async function resolveCodeType(codeTypeParam) {
+  if (codeTypeParam) {
+    const normalizedParam = codeTypeParam.toLowerCase().trim();
+    if (normalizedParam in CODE_TYPE_ABBREVIATIONS) {
+      return CODE_TYPE_ABBREVIATIONS[normalizedParam];
+    }
+    if (isValidCodeType(normalizedParam)) {
+      return normalizedParam;
+    }
+    const validAbbreviations = Object.keys(CODE_TYPE_ABBREVIATIONS);
+    const validFullTypes = Object.values(CODE_TYPE_ABBREVIATIONS);
+    const validOptions = [...validAbbreviations, ...validFullTypes].join(", ");
+    let defaultValue = DEFAULT_CODE_TOOL_TYPE;
+    try {
+      const config = await readZcfConfigAsync();
+      if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
+        defaultValue = config.codeToolType;
+      }
+    } catch {
+    }
+    throw new Error(
+      i18n.t("errors:invalidCodeType", { value: codeTypeParam, validOptions, defaultValue })
+    );
+  }
+  try {
+    const config = await readZcfConfigAsync();
+    if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
+      return config.codeToolType;
+    }
+  } catch {
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+function isValidCodeType(value) {
+  return ["claude-code", "codex"].includes(value);
+}
+
+export { resolveCodeType as r };