ccjk 2.4.4 → 2.6.0

package/dist/shared/{ccjk.CURU8gbR.mjs → ccjk.CUdzQluX.mjs}

@@ -1,6 +1,6 @@
 import { DEFAULT_CODE_TOOL_TYPE } from '../chunks/constants.mjs';
 import { i18n } from '../chunks/index2.mjs';
-import { e as readZcfConfigAsync } from '../chunks/ccjk-config.mjs';
+import { readZcfConfigAsync } from '../chunks/ccjk-config.mjs';
 
 const CODE_TYPE_ABBREVIATIONS = {
   cc: "claude-code",

package/dist/shared/{ccjk.ByTIGCUC.mjs → ccjk.Dut3wyoP.mjs}

@@ -6,7 +6,7 @@ import { readFile, writeFileAtomic, ensureDir } from '../chunks/fs-operations.mj
 import { fileURLToPath } from 'node:url';
 import { exec } from 'tinyexec';
 import { CLAUDE_DIR, SETTINGS_FILE } from '../chunks/constants.mjs';
-import { m as mergeAndCleanPermissions } from '../chunks/codex.mjs';
+import { m as mergeAndCleanPermissions } from '../chunks/config.mjs';
 import { getPlatform } from '../chunks/platform.mjs';
 
 function detectProjectContext(projectPath = process__default.cwd()) {

package/dist/shared/ccjk.J8YiPsOw.mjs

@@ -0,0 +1,259 @@
+const DEFAULT_CONFIG = {
+  checkInterval: 5 * 60 * 1e3,
+  // 5 minutes
+  timeout: 1e4,
+  // 10 seconds
+  degradedLatencyThreshold: 2e3,
+  // 2 seconds
+  unhealthyLatencyThreshold: 5e3,
+  // 5 seconds
+  degradedSuccessRateThreshold: 0.8,
+  // 80%
+  unhealthySuccessRateThreshold: 0.5,
+  // 50%
+  maxConsecutiveFailures: 3
+};
+class ProviderHealthMonitor {
+  healthData = /* @__PURE__ */ new Map();
+  monitoringInterval = null;
+  config;
+  providers = [];
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Set providers to monitor
+   */
+  setProviders(providers) {
+    this.providers = providers;
+    for (const provider of providers) {
+      if (!this.healthData.has(provider.id)) {
+        this.healthData.set(provider.id, {
+          providerId: provider.id,
+          latency: 0,
+          successRate: 1,
+          lastCheck: 0,
+          status: "unknown",
+          consecutiveFailures: 0,
+          totalRequests: 0,
+          successfulRequests: 0
+        });
+      }
+    }
+  }
+  /**
+   * Check health of a single provider
+   */
+  async checkHealth(provider) {
+    const startTime = Date.now();
+    try {
+      const baseUrl = provider.claudeCode?.baseUrl || provider.codex?.baseUrl;
+      if (!baseUrl) {
+        return {
+          success: false,
+          latency: 0,
+          error: "No base URL configured",
+          timestamp: Date.now()
+        };
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      try {
+        const response = await fetch(baseUrl, {
+          method: "HEAD",
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "CCJK-Health-Monitor/1.0"
+          }
+        });
+        clearTimeout(timeoutId);
+        const latency = Date.now() - startTime;
+        const success = response.ok || response.status === 404;
+        return {
+          success,
+          latency,
+          timestamp: Date.now()
+        };
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === "AbortError") {
+          return {
+            success: false,
+            latency: this.config.timeout,
+            error: "Request timeout",
+            timestamp: Date.now()
+          };
+        }
+        return {
+          success: false,
+          latency: Date.now() - startTime,
+          error: error instanceof Error ? error.message : "Unknown error",
+          timestamp: Date.now()
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        latency: Date.now() - startTime,
+        error: error instanceof Error ? error.message : "Unknown error",
+        timestamp: Date.now()
+      };
+    }
+  }
+  /**
+   * Update health data based on check result
+   */
+  updateHealthData(providerId, result) {
+    const health = this.healthData.get(providerId);
+    if (!health) {
+      return;
+    }
+    health.totalRequests++;
+    if (result.success) {
+      health.successfulRequests++;
+      health.consecutiveFailures = 0;
+    } else {
+      health.consecutiveFailures++;
+    }
+    health.successRate = health.successfulRequests / health.totalRequests;
+    if (result.success) {
+      health.latency = health.latency === 0 ? result.latency : health.latency * 0.7 + result.latency * 0.3;
+    }
+    health.lastCheck = result.timestamp;
+    health.status = this.determineStatus(health);
+    this.healthData.set(providerId, health);
+  }
+  /**
+   * Determine provider status based on health metrics
+   */
+  determineStatus(health) {
+    if (health.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+      return "unhealthy";
+    }
+    if (health.successRate < this.config.unhealthySuccessRateThreshold) {
+      return "unhealthy";
+    }
+    if (health.successRate < this.config.degradedSuccessRateThreshold) {
+      return "degraded";
+    }
+    if (health.successfulRequests > 0) {
+      if (health.latency > this.config.unhealthyLatencyThreshold) {
+        return "unhealthy";
+      }
+      if (health.latency > this.config.degradedLatencyThreshold) {
+        return "degraded";
+      }
+    }
+    return "healthy";
+  }
+  /**
+   * Get health data for a specific provider
+   */
+  getProviderHealth(providerId) {
+    return this.healthData.get(providerId);
+  }
+  /**
+   * Get all healthy providers
+   */
+  getHealthyProviders() {
+    return this.providers.filter((provider) => {
+      const health = this.healthData.get(provider.id);
+      return health && health.status === "healthy";
+    });
+  }
+  /**
+   * Get all providers sorted by health score
+   */
+  getProvidersByHealth() {
+    return [...this.providers].sort((a, b) => {
+      const healthA = this.healthData.get(a.id);
+      const healthB = this.healthData.get(b.id);
+      if (!healthA || !healthB) {
+        return 0;
+      }
+      const scoreA = this.calculateHealthScore(healthA);
+      const scoreB = this.calculateHealthScore(healthB);
+      return scoreB - scoreA;
+    });
+  }
+  /**
+   * Calculate health score for a provider
+   */
+  calculateHealthScore(health) {
+    const statusWeight = {
+      healthy: 1,
+      degraded: 0.6,
+      unhealthy: 0.2,
+      unknown: 0.5
+    };
+    const normalizedLatency = Math.max(0, 1 - health.latency / 1e4);
+    return statusWeight[health.status] * 0.4 + health.successRate * 0.4 + normalizedLatency * 0.2;
+  }
+  /**
+   * Get the best provider based on health metrics
+   */
+  getBestProvider() {
+    const sortedProviders = this.getProvidersByHealth();
+    return sortedProviders.length > 0 ? sortedProviders[0] : null;
+  }
+  /**
+   * Start monitoring all providers
+   */
+  async startMonitoring() {
+    if (this.monitoringInterval) {
+      return;
+    }
+    await this.checkAllProviders();
+    this.monitoringInterval = setInterval(async () => {
+      await this.checkAllProviders();
+    }, this.config.checkInterval);
+  }
+  /**
+   * Stop monitoring
+   */
+  stopMonitoring() {
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = null;
+    }
+  }
+  /**
+   * Check health of all providers
+   */
+  async checkAllProviders() {
+    const checks = this.providers.map(async (provider) => {
+      const result = await this.checkHealth(provider);
+      this.updateHealthData(provider.id, result);
+    });
+    await Promise.all(checks);
+  }
+  /**
+   * Get all health data
+   */
+  getAllHealthData() {
+    return new Map(this.healthData);
+  }
+  /**
+   * Reset health data for a provider
+   */
+  resetProviderHealth(providerId) {
+    const health = this.healthData.get(providerId);
+    if (health) {
+      health.consecutiveFailures = 0;
+      health.totalRequests = 0;
+      health.successfulRequests = 0;
+      health.successRate = 1;
+      health.latency = 0;
+      health.status = "unknown";
+      this.healthData.set(providerId, health);
+    }
+  }
+  /**
+   * Clear all health data
+   */
+  clearAllHealthData() {
+    this.healthData.clear();
+  }
+}
+
+export { ProviderHealthMonitor as P };

package/dist/shared/{ccjk.CGTmRqsu.mjs → ccjk.rLRHmcqD.mjs}

@@ -2,145 +2,16 @@ import ansis from 'ansis';
 import inquirer from 'inquirer';
 import { CLAUDE_DIR, SETTINGS_FILE } from '../chunks/constants.mjs';
 import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
-import { a7 as getExistingApiConfig, a1 as configureApi, a9 as switchToOfficialLogin, $ as backupExistingConfig, a8 as applyAiLanguageDirective } from '../chunks/codex.mjs';
+import { x as getExistingApiConfig, o as configureApi, z as switchToOfficialLogin, l as backupExistingConfig, y as applyAiLanguageDirective } from '../chunks/config.mjs';
 import { fileURLToPath } from 'node:url';
 import { join, dirname } from 'pathe';
-import { u as updateZcfConfig, r as readJsonConfig, w as writeJsonConfig } from '../chunks/ccjk-config.mjs';
+import { updateZcfConfig } from '../chunks/ccjk-config.mjs';
 import { exists, removeFile, ensureDir, copyFile } from '../chunks/fs-operations.mjs';
+import { readJsonConfig, writeJsonConfig } from '../chunks/json-config.mjs';
 import { p as promptBoolean, a as addNumbersToChoices } from './ccjk.DhBeLRzf.mjs';
 import { existsSync } from 'node:fs';
 import { rm, mkdir, copyFile as copyFile$1 } from 'node:fs/promises';
-
-const WORKFLOW_CONFIG_BASE = [
-  {
-    id: "interviewWorkflow",
-    defaultSelected: true,
-    order: 1,
-    commands: ["interview.md"],
-    agents: [],
-    autoInstallAgents: false,
-    category: "interview",
-    displayCategory: "planning",
-    outputDir: "interview",
-    metadata: {
-      version: "1.0.0",
-      addedDate: "2025-01",
-      tags: ["recommended", "popular"],
-      difficulty: "beginner"
-    }
-  },
-  {
-    id: "essentialTools",
-    defaultSelected: true,
-    order: 2,
-    commands: ["init-project.md", "feat.md"],
-    agents: [
-      { id: "init-architect", filename: "init-architect.md", required: true },
-      { id: "get-current-datetime", filename: "get-current-datetime.md", required: true },
-      { id: "planner", filename: "planner.md", required: true },
-      { id: "ui-ux-designer", filename: "ui-ux-designer.md", required: true }
-    ],
-    autoInstallAgents: true,
-    category: "essential",
-    displayCategory: "planning",
-    outputDir: "essential",
-    metadata: {
-      version: "1.0.0",
-      addedDate: "2025-01",
-      tags: ["essential"],
-      difficulty: "beginner"
-    }
-  },
-  {
-    id: "gitWorkflow",
-    defaultSelected: true,
-    order: 3,
-    commands: ["git-commit.md", "git-rollback.md", "git-cleanBranches.md", "git-worktree.md"],
-    agents: [],
-    autoInstallAgents: false,
-    category: "git",
-    displayCategory: "versionControl",
-    outputDir: "git",
-    metadata: {
-      version: "1.0.0",
-      addedDate: "2025-01",
-      tags: ["popular"],
-      difficulty: "beginner"
-    }
-  },
-  {
-    id: "sixStepsWorkflow",
-    defaultSelected: false,
-    order: 4,
-    commands: ["workflow.md"],
-    agents: [],
-    autoInstallAgents: false,
-    category: "sixStep",
-    displayCategory: "development",
-    outputDir: "workflow",
-    metadata: {
-      version: "1.0.0",
-      addedDate: "2025-01",
-      tags: ["professional"],
-      difficulty: "intermediate"
-    }
-  }
-];
-function getWorkflowConfigs() {
-  ensureI18nInitialized();
-  const workflowTranslations = [
-    {
-      id: "interviewWorkflow",
-      name: i18n.t("workflow:workflowOption.interviewWorkflow"),
-      description: i18n.t("workflow:workflowDescription.interviewWorkflow"),
-      stats: i18n.t("workflow:workflowStats.interviewWorkflow")
-    },
-    {
-      id: "essentialTools",
-      name: i18n.t("workflow:workflowOption.essentialTools"),
-      description: i18n.t("workflow:workflowDescription.essentialTools"),
-      stats: i18n.t("workflow:workflowStats.essentialTools")
-    },
-    {
-      id: "gitWorkflow",
-      name: i18n.t("workflow:workflowOption.gitWorkflow"),
-      description: i18n.t("workflow:workflowDescription.gitWorkflow"),
-      stats: i18n.t("workflow:workflowStats.gitWorkflow")
-    },
-    {
-      id: "sixStepsWorkflow",
-      name: i18n.t("workflow:workflowOption.sixStepsWorkflow"),
-      description: i18n.t("workflow:workflowDescription.sixStepsWorkflow"),
-      stats: i18n.t("workflow:workflowStats.sixStepsWorkflow")
-    }
-  ];
-  return WORKFLOW_CONFIG_BASE.map((baseConfig) => {
-    const translation = workflowTranslations.find((t) => t.id === baseConfig.id);
-    return {
-      ...baseConfig,
-      name: translation?.name || baseConfig.id,
-      description: translation?.description,
-      stats: translation?.stats
-    };
-  });
-}
-function getWorkflowConfig(workflowId) {
-  return getWorkflowConfigs().find((config) => config.id === workflowId);
-}
-function getOrderedWorkflows() {
-  return getWorkflowConfigs().sort((a, b) => a.order - b.order);
-}
-function getTagLabel(tag) {
-  ensureI18nInitialized();
-  const tagKeys = {
-    recommended: "workflow:tags.recommended",
-    popular: "workflow:tags.popular",
-    new: "workflow:tags.new",
-    essential: "workflow:tags.essential",
-    professional: "workflow:tags.professional"
-  };
-  return i18n.t(tagKeys[tag]);
-}
+import { getOrderedWorkflows, getWorkflowConfig, getTagLabel } from '../chunks/workflows2.mjs';
 
 const OUTPUT_STYLES = [
   // Custom styles (have template files) - Efficiency-focused styles
@@ -745,4 +616,4 @@ async function cleanupOldVersionFiles() {
   }
 }
 
-export { WORKFLOW_CONFIG_BASE as W, configureOutputStyle as a, configureApiCompletely as c, formatApiKeyDisplay as f, modifyApiConfigPartially as m, selectAndInstallWorkflows as s, updatePromptOnly as u, validateApiKey as v };
+export { configureOutputStyle as a, configureApiCompletely as c, formatApiKeyDisplay as f, modifyApiConfigPartially as m, selectAndInstallWorkflows as s, updatePromptOnly as u, validateApiKey as v };

package/dist/shared/{ccjk.QbS8EAOd.mjs → ccjk.uVUeWAt8.mjs}

@@ -1,8 +1,9 @@
 import ansis from 'ansis';
 import inquirer from 'inquirer';
-import { af as getMcpService, r as readCodexConfig, Z as applyCodexPlatformCommand, w as writeCodexConfig, e as readMcpConfig, j as buildMcpServerConfig, f as writeMcpConfig, ab as MCP_SERVICE_CONFIGS } from '../chunks/codex.mjs';
+import { P as getMcpService, r as readCodexConfig, L as applyCodexPlatformCommand, w as writeCodexConfig, M as MCP_SERVICE_CONFIGS } from '../chunks/codex.mjs';
 import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
 import { ClAUDE_CONFIG_FILE, CODEX_CONFIG_FILE } from '../chunks/constants.mjs';
+import { r as readMcpConfig, d as buildMcpServerConfig, w as writeMcpConfig } from '../chunks/config.mjs';
 import { writeFileAtomic, exists } from '../chunks/fs-operations.mjs';
 import { isWindows, getSystemRoot } from '../chunks/platform.mjs';
 import { existsSync, unlinkSync, statSync, mkdirSync, readFileSync } from 'node:fs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "2.4.4",
+  "version": "2.6.0",
   "packageManager": "pnpm@10.17.1",
   "description": "Claude Code JinKu - Advanced AI-powered development assistant with skills, agents, and LLM-driven audit",
   "author": {