ccjk 14.0.0 → 14.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "14.0.0",
+  "version": "14.0.1",
   "packageManager": "pnpm@10.17.1",
   "description": "Production-ready AI dev environment for Claude Code, Codex, and modern coding workflows with 30-second onboarding, persistent memory, Agent Teams, remote control, and capability discovery.",
   "author": {

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 };

package/dist/chunks/smart-defaults.mjs

@@ -1,425 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { CCJK_CONFIG_DIR, CODE_TOOL_INFO } from './constants.mjs';
-import { writeJsonConfig } from './json-config.mjs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import { g as getPlatform, h as commandExists } from './platform.mjs';
-import { s as scanProject } from '../shared/ccjk.DJuyfrlL.mjs';
-
-const ORCHESTRATION_LEVELS = ["off", "minimal", "standard", "max"];
-function parseOrchestrationLevel(value) {
-  if (!value) {
-    return "max";
-  }
-  const normalized = value.trim().toLowerCase();
-  if (ORCHESTRATION_LEVELS.includes(normalized)) {
-    return normalized;
-  }
-  throw new Error(`Invalid orchestration level: ${value}. Valid values: ${ORCHESTRATION_LEVELS.join(", ")}`);
-}
-function buildDefaults(level) {
-  if (level === "off") {
-    return {
-      planForNonTrivial: false,
-      useSubagentsForResearch: false,
-      verifyBeforeDone: false,
-      rootCauseFirst: true,
-      lessonsLoop: false
-    };
-  }
-  if (level === "minimal") {
-    return {
-      planForNonTrivial: true,
-      useSubagentsForResearch: false,
-      verifyBeforeDone: true,
-      rootCauseFirst: true,
-      lessonsLoop: false
-    };
-  }
-  if (level === "max") {
-    return {
-      planForNonTrivial: true,
-      useSubagentsForResearch: true,
-      verifyBeforeDone: true,
-      rootCauseFirst: true,
-      lessonsLoop: true
-    };
-  }
-  return {
-    planForNonTrivial: true,
-    useSubagentsForResearch: true,
-    verifyBeforeDone: true,
-    rootCauseFirst: true,
-    lessonsLoop: true
-  };
-}
-function resolveOrchestrationLevelFromRuntime(runtime) {
-  if (!runtime) {
-    return "max";
-  }
-  if (runtime.isCI || runtime.isContainer) {
-    return "minimal";
-  }
-  if (runtime.isSSH) {
-    return "minimal";
-  }
-  return "max";
-}
-function writeOrchestrationPolicy(params) {
-  const filePath = join(CCJK_CONFIG_DIR, "orchestration.json");
-  const policy = {
-    version: "1.0.0",
-    enabled: params.level !== "off",
-    level: params.level,
-    language: params.language,
-    defaults: buildDefaults(params.level),
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    source: params.source
-  };
-  writeJsonConfig(filePath, policy, { atomic: true });
-  return filePath;
-}
-
-class SmartDefaultsDetector {
-  /**
-   * Detect environment and generate smart defaults
-   */
-  async detect(cwd) {
-    const platform = getPlatform();
-    const apiKey = this.detectApiKey();
-    const apiProvider = this.detectApiProvider(apiKey);
-    const ccVersion = await this.detectClaudeCodeVersion();
-    const projectContext = scanProject(cwd);
-    return {
-      // Environment detection
-      platform,
-      homeDir: homedir(),
-      // API configuration
-      apiKey,
-      apiProvider,
-      // Recommended MCP services based on platform + project
-      mcpServices: this.getRecommendedMcpServices(platform, projectContext),
-      // Essential skills — reduced in CI/container (non-interactive)
-      skills: projectContext.runtime.isCI || projectContext.runtime.isContainer ? ["ccjk:git-commit"] : [
-        "ccjk:git-commit",
-        "ccjk:feat",
-        "ccjk:workflow",
-        "ccjk:init-project",
-        "ccjk:git-worktree"
-      ],
-      // Core agents — skip in CI/container (non-interactive)
-      agents: projectContext.runtime.isCI || projectContext.runtime.isContainer ? [] : [
-        "typescript-cli-architect",
-        "ccjk-testing-specialist"
-      ],
-      // Code tool detection
-      codeToolType: this.detectCodeToolType(),
-      // Workflow preferences
-      workflows: {
-        outputStyle: "engineer-professional",
-        gitWorkflow: projectContext.usesConventionalCommits ? "conventional-commits" : "conventional-commits",
-        sixStepWorkflow: true,
-        orchestrationLevel: resolveOrchestrationLevelFromRuntime(projectContext.runtime)
-      },
-      // Tool integrations
-      tools: {
-        ccr: this.shouldEnableCCR(),
-        cometix: this.shouldEnableCometix(),
-        ccusage: this.shouldEnableCCUsage()
-      },
-      // Claude Code native features
-      claudeCodeVersion: ccVersion,
-      nativeFeatures: this.detectNativeFeatures(ccVersion),
-      // Project context
-      projectContext,
-      // Recommended hooks based on project toolchain
-      recommendedHooks: this.getRecommendedHooks(projectContext),
-      // SSH session flag for quick-setup notice
-      sshDetected: projectContext.runtime.isSSH || void 0
-    };
-  }
-  /**
-   * Detect installed Claude Code version
-   */
-  async detectClaudeCodeVersion() {
-    const candidateCommands = [
-      CODE_TOOL_INFO["claude-code"].runtimeCommand,
-      CODE_TOOL_INFO.myclaude.runtimeCommand
-    ];
-    for (const command of candidateCommands) {
-      try {
-        if (!await commandExists(command)) {
-          continue;
-        }
-        const output = execSync(`${command} --version 2>/dev/null || echo ""`, {
-          encoding: "utf-8",
-          timeout: 5e3
-        }).trim();
-        const match = output.match(/(\d+\.\d+\.\d+)/);
-        if (match) {
-          return match[1];
-        }
-      } catch {
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Detect which Claude Code native features are available
-   * based on installed version
-   */
-  detectNativeFeatures(version) {
-    return {
-      hooks: this.versionSupports(version, "1.0.6"),
-      plansDirectory: this.versionSupports(version, "1.0.10"),
-      memory: this.versionSupports(version, "1.0.12"),
-      subagents: this.versionSupports(version, "1.0.3"),
-      toolSearch: this.versionSupports(version, "1.0.10"),
-      statusLine: this.versionSupports(version, "1.0.8")
-    };
-  }
-  /**
-   * Check if a version meets the minimum requirement
-   */
-  versionSupports(version, minVersion) {
-    if (!version)
-      return false;
-    const parts = version.split(".").map(Number);
-    const minParts = minVersion.split(".").map(Number);
-    for (let i = 0; i < 3; i++) {
-      if ((parts[i] || 0) > (minParts[i] || 0))
-        return true;
-      if ((parts[i] || 0) < (minParts[i] || 0))
-        return false;
-    }
-    return true;
-  }
-  /**
-   * Detect API key from environment variables
-   */
-  detectApiKey() {
-    const envVars = [
-      "ANTHROPIC_API_KEY",
-      "CLAUDE_API_KEY",
-      "API_KEY"
-    ];
-    for (const envVar of envVars) {
-      const value = process.env[envVar];
-      if (value && value.length >= 10) {
-        return value;
-      }
-    }
-    const claudeConfigPath = join(homedir(), ".config", "claude", "config.json");
-    if (existsSync(claudeConfigPath)) {
-      try {
-        const configContent = readFileSync(claudeConfigPath, "utf-8");
-        const config = JSON.parse(configContent);
-        if (config.apiKey && config.apiKey.length >= 10) {
-          return config.apiKey;
-        }
-      } catch {
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Detect API provider based on API key pattern
-   */
-  detectApiProvider(apiKey) {
-    if (!apiKey) {
-      return void 0;
-    }
-    if (apiKey.startsWith("sk-ant-")) {
-      return "anthropic";
-    }
-    return void 0;
-  }
-  /**
-   * Detect installed code tool type (instance method delegates to static)
-   */
-  detectCodeToolType() {
-    return SmartDefaultsDetector.detectCodeToolType();
-  }
-  /**
-   * Detect installed code tool type by checking filesystem markers.
-   * This is a static method so it can be called without instantiating the full detector.
-   */
-  static detectCodeToolType() {
-    const myclaudeMarkers = [
-      join(homedir(), ".claude.json"),
-      join(homedir(), ".claude", "config.json")
-    ];
-    try {
-      if (myclaudeMarkers.some((p) => existsSync(p))) {
-        const globalConfigPath = join(homedir(), ".claude.json");
-        if (existsSync(globalConfigPath)) {
-          const configContent = readFileSync(globalConfigPath, "utf-8");
-          const config = JSON.parse(configContent);
-          if (config.myclaudeActiveProviderProfileId || config.myclaudeProviderProfiles) {
-            return "myclaude";
-          }
-        }
-      }
-    } catch {
-    }
-    const claudeCodePaths = [
-      join(homedir(), ".claude"),
-      join(homedir(), ".config", "claude")
-    ];
-    if (claudeCodePaths.some((p) => existsSync(p))) {
-      return "claude-code";
-    }
-    const codexPath = join(homedir(), ".codex");
-    if (existsSync(codexPath)) {
-      return "codex";
-    }
-    return "myclaude";
-  }
-  /**
-   * Check if CCR (Claude Code Router) should be enabled
-   */
-  shouldEnableCCR() {
-    const ccrPaths = [
-      join(homedir(), ".local", "bin", "ccr"),
-      join(homedir(), ".cargo", "bin", "ccr"),
-      "/usr/local/bin/ccr"
-    ];
-    return ccrPaths.some((path) => existsSync(path));
-  }
-  /**
-   * Check if Cometix should be enabled
-   */
-  shouldEnableCometix() {
-    const cometixPaths = [
-      join(homedir(), ".local", "bin", "cometix"),
-      join(homedir(), ".cargo", "bin", "cometix"),
-      "/usr/local/bin/cometix"
-    ];
-    return cometixPaths.some((path) => existsSync(path));
-  }
-  /**
-   * Check if CCUsage should be enabled
-   */
-  shouldEnableCCUsage() {
-    const ccusagePaths = [
-      join(homedir(), ".local", "bin", "ccusage"),
-      join(homedir(), ".cargo", "bin", "ccusage"),
-      "/usr/local/bin/ccusage"
-    ];
-    return ccusagePaths.some((path) => existsSync(path));
-  }
-  /**
-   * Get recommended MCP services based on environment + project context
-   */
-  getRecommendedMcpServices(platform, project) {
-    return ["context7"];
-  }
-  /**
-   * Get recommended hook template IDs based on project toolchain
-   */
-  getRecommendedHooks(project) {
-    const runtime = project.runtime;
-    if (runtime.isCI) {
-      const hooks2 = [];
-      if (project.linter !== "none")
-        hooks2.push("pre-commit-lint-check");
-      if (project.testRunner !== "none")
-        hooks2.push("test-before-commit");
-      return hooks2;
-    }
-    if (runtime.isContainer) {
-      const hooks2 = [];
-      if (project.linter !== "none")
-        hooks2.push("pre-commit-lint-check");
-      if (project.testRunner !== "none")
-        hooks2.push("test-before-commit");
-      return hooks2;
-    }
-    const hooks = [];
-    if (!runtime.isHeadless) {
-      hooks.push("block-dev-server");
-    }
-    hooks.push("git-push-confirm");
-    const jsLangs = ["typescript", "javascript"];
-    if (jsLangs.includes(project.language)) {
-      hooks.push("warn-console-log");
-    }
-    hooks.push("block-unwanted-docs");
-    if (project.testRunner !== "none") {
-      hooks.push("test-before-commit");
-    }
-    if (project.formatter !== "none") {
-      hooks.push("auto-format-on-save");
-    }
-    if (project.linter !== "none") {
-      hooks.push("pre-commit-lint-check");
-    }
-    return hooks;
-  }
-  /**
-   * Get recommended skills based on user type
-   */
-  getRecommendedSkills(userType = "intermediate") {
-    const core = [
-      "ccjk:git-commit",
-      "ccjk:init-project"
-    ];
-    if (userType === "beginner") {
-      return [...core, "ccjk:workflow"];
-    }
-    if (userType === "intermediate") {
-      return [...core, "ccjk:feat", "ccjk:workflow", "ccjk:git-worktree"];
-    }
-    if (userType === "advanced") {
-      return [
-        ...core,
-        "ccjk:feat",
-        "ccjk:workflow",
-        "ccjk:git-worktree",
-        "ccjk:git-rollback",
-        "ccjk:git-cleanBranches"
-      ];
-    }
-    return core;
-  }
-  /**
-   * Validate detected defaults
-   */
-  validateDefaults(defaults) {
-    const issues = [];
-    if (defaults.apiKey) {
-      if (defaults.apiKey.length < 10) {
-        issues.push("API key appears too short to be valid");
-      } else if (defaults.apiProvider === "anthropic" && !defaults.apiKey.startsWith("sk-ant-")) {
-        issues.push("API key format appears invalid (should start with sk-ant-)");
-      }
-    }
-    if (!["darwin", "linux", "win32"].includes(defaults.platform)) {
-      issues.push(`Platform ${defaults.platform} may not be fully supported`);
-    }
-    if (!existsSync(defaults.homeDir)) {
-      issues.push("Home directory is not accessible");
-    }
-    return {
-      valid: issues.length === 0,
-      issues
-    };
-  }
-}
-async function detectSmartDefaults() {
-  const detector = new SmartDefaultsDetector();
-  return detector.detect();
-}
-function detectCodeToolType() {
-  return SmartDefaultsDetector.detectCodeToolType();
-}
-
-const smartDefaults = {
-  __proto__: null,
-  SmartDefaultsDetector: SmartDefaultsDetector,
-  detectCodeToolType: detectCodeToolType,
-  detectSmartDefaults: detectSmartDefaults
-};
-
-export { detectCodeToolType as a, detectSmartDefaults as d, parseOrchestrationLevel as p, smartDefaults as s, writeOrchestrationPolicy as w };