ccjk 9.5.6 → 9.7.0

package/dist/shared/{ccjk.zCqdxT2Y.mjs → ccjk.Br91zBIG.mjs}

@@ -1,6 +1,6 @@
 import ansis from 'ansis';
 import { homepage, version } from '../chunks/package.mjs';
-import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
+import { ensureI18nInitialized, i18n } from '../chunks/index.mjs';
 
 const theme = {
   // === Core Colors ===
@@ -135,4 +135,4 @@ const STATUS = {
   inProgress: status.work
 };
 
-export { STATUS as S, displayBannerWithInfo as a, boxify as b, displayBanner as d, padToDisplayWidth as p, theme as t };
+export { STATUS as S, displayBanner as a, boxify as b, displayBannerWithInfo as d, padToDisplayWidth as p, theme as t };

package/dist/shared/ccjk.CSkyCZIM.mjs

@@ -0,0 +1,638 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import process__default from 'node:process';
+import { join } from 'pathe';
+import { SETTINGS_FILE, CLAUDE_AGENTS_DIR, CCJK_SKILLS_DIR } from '../chunks/constants.mjs';
+
+function analyzeProject(root) {
+  const cwd = process__default.cwd();
+  const profile = {
+    language: "unknown",
+    frameworks: [],
+    packageManager: "unknown",
+    hasCI: false,
+    hasDocker: false,
+    hasMCP: false,
+    hasClaudeMd: false,
+    isMonorepo: false,
+    tags: []
+  };
+  const pkgPath = join(cwd, "package.json");
+  let pkg = null;
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      profile.projectName = pkg?.name;
+    } catch {
+    }
+  }
+  profile.language = detectLanguage(cwd, pkg);
+  profile.packageManager = detectPackageManager(cwd);
+  profile.frameworks = detectFrameworks(cwd, pkg);
+  profile.testFramework = detectTestFramework(cwd, pkg);
+  profile.buildTool = detectBuildTool(cwd, pkg);
+  profile.hasCI = existsSync(join(cwd, ".github/workflows")) || existsSync(join(cwd, ".gitlab-ci.yml")) || existsSync(join(cwd, ".circleci")) || existsSync(join(cwd, "Jenkinsfile"));
+  profile.hasDocker = existsSync(join(cwd, "Dockerfile")) || existsSync(join(cwd, "docker-compose.yml")) || existsSync(join(cwd, "docker-compose.yaml"));
+  profile.hasMCP = checkMcpConfigured();
+  profile.hasClaudeMd = existsSync(join(cwd, "CLAUDE.md"));
+  profile.isMonorepo = existsSync(join(cwd, "pnpm-workspace.yaml")) || existsSync(join(cwd, "lerna.json")) || pkg?.workspaces != null;
+  profile.tags = generateTags(profile);
+  return profile;
+}
+function detectLanguage(cwd, pkg) {
+  if (existsSync(join(cwd, "tsconfig.json")) || pkg?.devDependencies?.typescript) return "typescript";
+  if (existsSync(join(cwd, "pyproject.toml")) || existsSync(join(cwd, "setup.py"))) return "python";
+  if (existsSync(join(cwd, "go.mod"))) return "go";
+  if (existsSync(join(cwd, "Cargo.toml"))) return "rust";
+  if (existsSync(join(cwd, "Gemfile"))) return "ruby";
+  if (existsSync(join(cwd, "pom.xml")) || existsSync(join(cwd, "build.gradle"))) return "java";
+  if (existsSync(join(cwd, "Package.swift"))) return "swift";
+  if (pkg) return "javascript";
+  return "unknown";
+}
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "pnpm-lock.yaml")) || existsSync(join(cwd, "pnpm-workspace.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return "bun";
+  if (existsSync(join(cwd, "package-lock.json"))) return "npm";
+  return "unknown";
+}
+function detectFrameworks(_cwd, pkg) {
+  const frameworks = [];
+  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  if (allDeps?.react || allDeps?.["react-dom"]) frameworks.push("react");
+  if (allDeps?.vue) frameworks.push("vue");
+  if (allDeps?.svelte) frameworks.push("svelte");
+  if (allDeps?.angular || allDeps?.["@angular/core"]) frameworks.push("angular");
+  if (allDeps?.next) frameworks.push("nextjs");
+  if (allDeps?.nuxt) frameworks.push("nuxt");
+  if (allDeps?.astro) frameworks.push("astro");
+  if (allDeps?.express) frameworks.push("express");
+  if (allDeps?.fastify) frameworks.push("fastify");
+  if (allDeps?.koa) frameworks.push("koa");
+  if (allDeps?.hono) frameworks.push("hono");
+  if (allDeps?.["@nestjs/core"]) frameworks.push("nestjs");
+  if (allDeps?.electron) frameworks.push("electron");
+  if (allDeps?.["@tauri-apps/api"]) frameworks.push("tauri");
+  if (allDeps?.["react-native"]) frameworks.push("react-native");
+  if (allDeps?.cac || allDeps?.commander || allDeps?.yargs) frameworks.push("cli");
+  return frameworks;
+}
+function detectTestFramework(cwd, pkg) {
+  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  if (allDeps?.vitest || existsSync(join(cwd, "vitest.config.ts"))) return "vitest";
+  if (allDeps?.jest || existsSync(join(cwd, "jest.config.js"))) return "jest";
+  if (allDeps?.mocha) return "mocha";
+  if (allDeps?.playwright || allDeps?.["@playwright/test"]) return "playwright";
+  if (allDeps?.cypress) return "cypress";
+  if (existsSync(join(cwd, "pytest.ini")) || existsSync(join(cwd, "conftest.py"))) return "pytest";
+  return void 0;
+}
+function detectBuildTool(cwd, pkg) {
+  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  if (allDeps?.vite || existsSync(join(cwd, "vite.config.ts"))) return "vite";
+  if (allDeps?.webpack) return "webpack";
+  if (allDeps?.esbuild) return "esbuild";
+  if (allDeps?.unbuild) return "unbuild";
+  if (allDeps?.rollup) return "rollup";
+  if (allDeps?.turbo || existsSync(join(cwd, "turbo.json"))) return "turbo";
+  return void 0;
+}
+function checkMcpConfigured() {
+  try {
+    if (!existsSync(SETTINGS_FILE)) return false;
+    const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+    return Object.keys(settings.mcpServers || {}).length > 0;
+  } catch {
+    return false;
+  }
+}
+function generateTags(profile) {
+  const tags = [];
+  tags.push(profile.language);
+  tags.push(...profile.frameworks);
+  if (profile.testFramework) tags.push(profile.testFramework);
+  if (profile.buildTool) tags.push(profile.buildTool);
+  if (profile.packageManager !== "unknown") tags.push(profile.packageManager);
+  if (profile.hasCI) tags.push("ci");
+  if (profile.hasDocker) tags.push("docker");
+  if (profile.isMonorepo) tags.push("monorepo");
+  if (profile.frameworks.some((f) => ["react", "vue", "svelte", "angular"].includes(f))) tags.push("frontend");
+  if (profile.frameworks.some((f) => ["express", "fastify", "koa", "nestjs", "hono"].includes(f))) tags.push("backend");
+  if (profile.frameworks.some((f) => ["nextjs", "nuxt", "astro"].includes(f))) tags.push("fullstack");
+  if (profile.frameworks.includes("cli")) tags.push("cli-tool");
+  return [...new Set(tags)];
+}
+
+const SKILL_RULES = [
+  {
+    tags: ["typescript", "javascript", "python", "go", "rust", "ruby", "java"],
+    skill: { id: "git-commit", name: "Smart Git Commit", description: "AI-powered conventional commit messages", reason: "Every project needs good commits", category: "git" }
+  },
+  {
+    tags: ["typescript", "javascript", "python", "go", "rust"],
+    skill: { id: "code-review", name: "Code Review", description: "Two-phase deep code review", reason: "Catch bugs before they ship", category: "review" }
+  },
+  {
+    tags: ["react", "vue", "svelte", "angular", "frontend"],
+    skill: { id: "component-gen", name: "Component Generator", description: "Generate UI components with tests", reason: "Frontend framework detected", category: "dev" }
+  },
+  {
+    tags: ["express", "fastify", "koa", "nestjs", "hono", "backend"],
+    skill: { id: "api-design", name: "API Design", description: "Design RESTful/GraphQL APIs", reason: "Backend framework detected", category: "dev" }
+  },
+  {
+    tags: ["backend", "fullstack"],
+    skill: { id: "security-audit", name: "Security Audit", description: "Check for common vulnerabilities", reason: "Server-side code needs security review", category: "review" }
+  },
+  {
+    tags: ["vitest", "jest", "pytest", "mocha"],
+    skill: { id: "tdd-workflow", name: "TDD Workflow", description: "Test-driven development cycle", reason: "Test framework detected", category: "testing" }
+  },
+  {
+    tags: ["playwright", "cypress"],
+    skill: { id: "e2e-helper", name: "E2E Test Helper", description: "Generate end-to-end tests", reason: "E2E framework detected", category: "testing" }
+  },
+  {
+    tags: ["docker"],
+    skill: { id: "docker-optimize", name: "Docker Optimizer", description: "Optimize Dockerfile", reason: "Docker detected", category: "devops" }
+  },
+  {
+    tags: ["ci"],
+    skill: { id: "ci-pipeline", name: "CI Pipeline", description: "Optimize CI/CD pipeline", reason: "CI configuration detected", category: "devops" }
+  },
+  {
+    tags: ["cli-tool", "cli"],
+    skill: { id: "cli-ux", name: "CLI UX Design", description: "Better CLI interfaces", reason: "CLI tool detected", category: "dev" }
+  },
+  {
+    tags: ["monorepo"],
+    skill: { id: "monorepo-manage", name: "Monorepo Manager", description: "Manage packages and releases", reason: "Monorepo detected", category: "dev" }
+  },
+  {
+    tags: ["typescript", "javascript", "python"],
+    skill: { id: "doc-gen", name: "Documentation Generator", description: "Generate API docs and README", reason: "Good docs improve maintainability", category: "docs" }
+  },
+  {
+    tags: ["react", "vue", "nextjs", "nuxt", "frontend"],
+    skill: { id: "perf-audit", name: "Performance Audit", description: "Bundle size and Core Web Vitals", reason: "Frontend performance matters", category: "review" }
+  },
+  {
+    tags: ["nextjs", "nuxt", "astro", "fullstack"],
+    skill: { id: "fullstack-debug", name: "Fullstack Debugger", description: "Debug across client/server boundary", reason: "Fullstack framework detected", category: "debug" }
+  }
+];
+const MCP_RULES = [
+  {
+    tags: ["typescript", "javascript", "python", "go", "rust", "ruby", "java"],
+    mcp: { id: "context7", name: "Context7", description: "Up-to-date library docs", reason: "Essential for accurate API usage" }
+  },
+  {
+    tags: ["playwright", "frontend", "fullstack"],
+    mcp: { id: "playwright", name: "Playwright MCP", description: "Browser automation", reason: "Frontend/E2E project detected" }
+  },
+  {
+    tags: ["backend", "fullstack", "express", "fastify", "nestjs"],
+    mcp: { id: "sqlite", name: "SQLite MCP", description: "Local database", reason: "Backend project detected" }
+  },
+  {
+    tags: ["typescript", "javascript", "python", "go", "rust"],
+    mcp: { id: "mcp-search", name: "Web Search", description: "Search for docs and solutions", reason: "Quick access to online resources" }
+  }
+];
+function matchSkills(profile) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rule of SKILL_RULES) {
+    if (seen.has(rule.skill.id)) continue;
+    const matchingTags = rule.tags.filter((t) => profile.tags.includes(t));
+    if (matchingTags.length === 0) continue;
+    const matchScore = Math.min(100, Math.round(matchingTags.length / rule.tags.length * 100) + 20);
+    results.push({ ...rule.skill, matchScore });
+    seen.add(rule.skill.id);
+  }
+  results.sort((a, b) => b.matchScore - a.matchScore);
+  return results;
+}
+function matchMcpServices(profile) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rule of MCP_RULES) {
+    if (seen.has(rule.mcp.id)) continue;
+    const matchingTags = rule.tags.filter((t) => profile.tags.includes(t));
+    if (matchingTags.length === 0) continue;
+    const matchScore = Math.min(100, Math.round(matchingTags.length / rule.tags.length * 100) + 20);
+    results.push({ ...rule.mcp, matchScore });
+    seen.add(rule.mcp.id);
+  }
+  results.sort((a, b) => b.matchScore - a.matchScore);
+  return results;
+}
+function getRecommendations(profile) {
+  const skills = matchSkills(profile);
+  const mcpServices = matchMcpServices(profile);
+  const parts = [];
+  if (profile.language !== "unknown") parts.push(profile.language);
+  parts.push(...profile.frameworks.slice(0, 3));
+  const stackDesc = parts.join(" + ") || "your project";
+  return {
+    skills,
+    mcpServices,
+    summary: `Found ${skills.length} skills and ${mcpServices.length} MCP services for ${stackDesc}`
+  };
+}
+
+const agentsCheck = {
+  name: "Agents",
+  weight: 4,
+  async check() {
+    try {
+      if (!existsSync(CLAUDE_AGENTS_DIR)) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 30,
+          weight: this.weight,
+          message: "No agents directory",
+          fix: "Create agents for specialized tasks",
+          command: "ccjk ccjk:agents --list"
+        };
+      }
+      const files = readdirSync(CLAUDE_AGENTS_DIR).filter((f) => f.endsWith(".md"));
+      const agentCount = files.length;
+      if (agentCount === 0) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 30,
+          weight: this.weight,
+          message: "No agents configured",
+          fix: "Create agents for your project",
+          command: "ccjk ccjk:agents"
+        };
+      }
+      const score = Math.min(100, 40 + agentCount * 15);
+      return {
+        name: this.name,
+        status: score >= 60 ? "pass" : "warn",
+        score,
+        weight: this.weight,
+        message: `${agentCount} agent${agentCount > 1 ? "s" : ""} configured`,
+        details: files.slice(0, 5).map((f) => `  ${f.replace(".md", "")}`)
+      };
+    } catch {
+      return { name: this.name, status: "fail", score: 0, weight: this.weight, message: "Failed to read agents" };
+    }
+  }
+};
+
+const claudeMdCheck = {
+  name: "CLAUDE.md",
+  weight: 7,
+  async check() {
+    const cwd = process.cwd();
+    const claudeMdPath = join(cwd, "CLAUDE.md");
+    try {
+      if (!existsSync(claudeMdPath)) {
+        return {
+          name: this.name,
+          status: "fail",
+          score: 0,
+          weight: this.weight,
+          message: "No CLAUDE.md in project root",
+          fix: "Create CLAUDE.md for project-specific AI instructions",
+          command: "ccjk init --smart"
+        };
+      }
+      const stat = statSync(claudeMdPath);
+      const content = readFileSync(claudeMdPath, "utf-8");
+      const lines = content.split("\n").length;
+      const sizeKb = Math.round(stat.size / 1024);
+      const hasHeaders = (content.match(/^#{1,3}\s/gm) || []).length;
+      const hasCodeBlocks = (content.match(/```/g) || []).length / 2;
+      const hasBuildCommands = /build|test|lint|dev/i.test(content);
+      let score = 40;
+      if (lines > 20) score += 15;
+      if (hasHeaders >= 3) score += 15;
+      if (hasCodeBlocks >= 1) score += 10;
+      if (hasBuildCommands) score += 20;
+      score = Math.min(100, score);
+      return {
+        name: this.name,
+        status: score >= 60 ? "pass" : "warn",
+        score,
+        weight: this.weight,
+        message: `${lines} lines, ${sizeKb}KB`,
+        details: [
+          `  Sections: ${hasHeaders}`,
+          `  Code blocks: ${Math.floor(hasCodeBlocks)}`,
+          `  Build info: ${hasBuildCommands ? "yes" : "no"}`
+        ],
+        ...score < 80 && { fix: "Enrich CLAUDE.md with more project context", command: "ccjk init --smart" }
+      };
+    } catch {
+      return { name: this.name, status: "fail", score: 0, weight: this.weight, message: "Failed to read CLAUDE.md" };
+    }
+  }
+};
+
+const mcpCheck = {
+  name: "MCP Services",
+  weight: 8,
+  async check() {
+    try {
+      if (!existsSync(SETTINGS_FILE)) {
+        return {
+          name: this.name,
+          status: "fail",
+          score: 0,
+          weight: this.weight,
+          message: "No settings.json found",
+          fix: "Run ccjk init to create settings",
+          command: "ccjk init"
+        };
+      }
+      const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+      const mcpServers = settings.mcpServers || {};
+      const serverCount = Object.keys(mcpServers).length;
+      if (serverCount === 0) {
+        return {
+          name: this.name,
+          status: "fail",
+          score: 0,
+          weight: this.weight,
+          message: "No MCP services configured",
+          fix: "Install MCP services for enhanced capabilities",
+          command: "ccjk ccjk:mcp"
+        };
+      }
+      const essentialServices = ["context7"];
+      const hasEssentials = essentialServices.filter(
+        (s) => Object.keys(mcpServers).some((k) => k.toLowerCase().includes(s))
+      );
+      const score = Math.min(100, serverCount * 20 + hasEssentials.length * 20);
+      const status = score >= 60 ? "pass" : "warn";
+      const details = Object.keys(mcpServers).map((name) => `  ${name}`);
+      return {
+        name: this.name,
+        status,
+        score,
+        weight: this.weight,
+        message: `${serverCount} service${serverCount > 1 ? "s" : ""} active`,
+        details,
+        ...score < 80 && { fix: "Add more MCP services", command: "ccjk ccjk:mcp" }
+      };
+    } catch {
+      return {
+        name: this.name,
+        status: "fail",
+        score: 0,
+        weight: this.weight,
+        message: "Failed to read MCP configuration",
+        command: "ccjk doctor"
+      };
+    }
+  }
+};
+
+const modelCheck = {
+  name: "Default Model",
+  weight: 5,
+  async check() {
+    try {
+      if (!existsSync(SETTINGS_FILE)) {
+        return {
+          name: this.name,
+          status: "fail",
+          score: 0,
+          weight: this.weight,
+          message: "No settings file",
+          command: "ccjk init"
+        };
+      }
+      const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+      const hasModel = settings.model || settings.defaultModel || settings.preferredModel;
+      const hasApiKey = settings.apiKey || settings.env?.ANTHROPIC_API_KEY || process__default.env.ANTHROPIC_API_KEY;
+      if (!hasApiKey) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 40,
+          weight: this.weight,
+          message: "No API key configured (using default)",
+          fix: "Configure API for direct access",
+          command: "ccjk menu",
+          details: ["  Using Claude Code default API"]
+        };
+      }
+      return {
+        name: this.name,
+        status: "pass",
+        score: hasModel ? 100 : 70,
+        weight: this.weight,
+        message: hasModel ? `Model: ${hasModel}` : "API configured (default model)"
+      };
+    } catch {
+      return { name: this.name, status: "fail", score: 0, weight: this.weight, message: "Failed to read model config" };
+    }
+  }
+};
+
+const INVALID_PERMISSION_NAMES = /* @__PURE__ */ new Set([
+  "AllowEdit",
+  "AllowWrite",
+  "AllowRead",
+  "AllowExec",
+  "AllowCreateProcess",
+  "AllowKillProcess",
+  "AllowNetworkAccess",
+  "AllowFileSystemAccess",
+  "AllowShellAccess",
+  "AllowHttpAccess"
+]);
+function isValidPermission(perm) {
+  if (INVALID_PERMISSION_NAMES.has(perm)) return false;
+  if (["mcp__.*", "mcp__*", "mcp__(*)"].includes(perm)) return false;
+  return true;
+}
+const permissionsCheck = {
+  name: "Permissions",
+  weight: 3,
+  async check() {
+    try {
+      if (!existsSync(SETTINGS_FILE)) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 30,
+          weight: this.weight,
+          message: "No settings file",
+          command: "ccjk init"
+        };
+      }
+      const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+      const allowedTools = settings.permissions?.allow || [];
+      if (allowedTools.length === 0) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 40,
+          weight: this.weight,
+          message: "No tool permissions configured",
+          fix: "Configure permissions to reduce prompts",
+          command: "ccjk menu"
+        };
+      }
+      const invalidPerms = allowedTools.filter((p) => !isValidPermission(p));
+      const validPerms = allowedTools.filter((p) => isValidPermission(p));
+      if (invalidPerms.length > 0) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 50,
+          weight: this.weight,
+          message: `${invalidPerms.length} invalid permission(s) found (${validPerms.length} valid)`,
+          fix: "Run ccjk init to repair permissions",
+          command: "ccjk init"
+        };
+      }
+      const score = Math.min(100, 60 + validPerms.length * 2);
+      return {
+        name: this.name,
+        status: "pass",
+        score,
+        weight: this.weight,
+        message: `${validPerms.length} valid permission${validPerms.length > 1 ? "s" : ""} configured`
+      };
+    } catch {
+      return { name: this.name, status: "fail", score: 0, weight: this.weight, message: "Failed to read permissions" };
+    }
+  }
+};
+
+const skillsCheck = {
+  name: "Skills",
+  weight: 6,
+  async check() {
+    try {
+      if (!existsSync(CCJK_SKILLS_DIR)) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 20,
+          weight: this.weight,
+          message: "No skills directory found",
+          fix: "Install skills to enhance Claude Code",
+          command: "ccjk ccjk:skills"
+        };
+      }
+      const files = readdirSync(CCJK_SKILLS_DIR).filter((f) => f.endsWith(".md"));
+      const skillCount = files.length;
+      if (skillCount === 0) {
+        return {
+          name: this.name,
+          status: "warn",
+          score: 20,
+          weight: this.weight,
+          message: "No skills installed",
+          fix: "Install skills based on your project",
+          command: "ccjk ccjk:skills"
+        };
+      }
+      const score = Math.min(100, 30 + skillCount * 10);
+      return {
+        name: this.name,
+        status: score >= 60 ? "pass" : "warn",
+        score,
+        weight: this.weight,
+        message: `${skillCount} skill${skillCount > 1 ? "s" : ""} installed`,
+        details: files.slice(0, 8).map((f) => `  ${f.replace(".md", "")}`),
+        ...skillCount < 5 && { fix: "Install more project-specific skills", command: "ccjk ccjk:skills" }
+      };
+    } catch {
+      return { name: this.name, status: "fail", score: 0, weight: this.weight, message: "Failed to read skills" };
+    }
+  }
+};
+
+const DEFAULT_CHECKS = [
+  mcpCheck,
+  skillsCheck,
+  claudeMdCheck,
+  modelCheck,
+  agentsCheck,
+  permissionsCheck
+];
+function calculateGrade(score) {
+  if (score >= 95) return "S";
+  if (score >= 80) return "A";
+  if (score >= 65) return "B";
+  if (score >= 50) return "C";
+  if (score >= 30) return "D";
+  return "F";
+}
+function generateRecommendations(results) {
+  const recs = [];
+  for (const r of results) {
+    if (r.status === "fail" && r.command) {
+      recs.push({
+        priority: "high",
+        title: `Fix: ${r.name}`,
+        description: r.fix || r.message,
+        command: r.command,
+        category: mapCategory(r.name)
+      });
+    } else if (r.status === "warn" && r.command) {
+      recs.push({
+        priority: "medium",
+        title: `Improve: ${r.name}`,
+        description: r.fix || r.message,
+        command: r.command,
+        category: mapCategory(r.name)
+      });
+    }
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  recs.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return recs;
+}
+function mapCategory(name) {
+  const lower = name.toLowerCase();
+  if (lower.includes("mcp")) return "mcp";
+  if (lower.includes("skill")) return "skills";
+  if (lower.includes("agent")) return "agents";
+  if (lower.includes("model") || lower.includes("api")) return "model";
+  if (lower.includes("sync")) return "sync";
+  if (lower.includes("perm")) return "permissions";
+  return "general";
+}
+async function runHealthCheck(checks) {
+  const activeChecks = DEFAULT_CHECKS;
+  const results = [];
+  const promises = activeChecks.map(async (check) => {
+    try {
+      return await check.check();
+    } catch {
+      return {
+        name: check.name,
+        status: "fail",
+        score: 0,
+        weight: check.weight,
+        message: "Check failed unexpectedly"
+      };
+    }
+  });
+  const settled = await Promise.all(promises);
+  results.push(...settled);
+  const totalWeight = results.reduce((sum, r) => sum + r.weight, 0);
+  const weightedSum = results.reduce((sum, r) => sum + r.score * r.weight, 0);
+  const totalScore = totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+  return {
+    totalScore,
+    grade: calculateGrade(totalScore),
+    results,
+    recommendations: generateRecommendations(results),
+    timestamp: Date.now()
+  };
+}
+
+export { analyzeProject as a, getRecommendations as g, runHealthCheck as r };

package/dist/shared/{ccjk.BKoi8-Hy.mjs → ccjk.DE91nClQ.mjs}

@@ -4,7 +4,7 @@ import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { promisify } from 'node:util';
 import { join } from 'pathe';
-import { i18n } from '../chunks/index2.mjs';
+import { i18n } from '../chunks/index.mjs';
 
 const execAsync = promisify(exec);
 function getClaudePluginDir() {

package/dist/shared/{ccjk.f40us0yY.mjs → ccjk.DvIrK0wz.mjs}

@@ -1,6 +1,6 @@
 import process__default from 'node:process';
 import ansis from 'ansis';
-import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
+import { ensureI18nInitialized, i18n } from '../chunks/index.mjs';
 
 function handleExitPromptError(error) {
   const isExitError = error instanceof Error && (error.name === "ExitPromptError" || error.message?.includes("ExitPromptError") || error.message?.includes("User force closed the prompt"));
@@ -22,4 +22,4 @@ function handleGeneralError(error) {
   process__default.exit(1);
 }
 
-export { handleExitPromptError as a, handleGeneralError as h };
+export { handleGeneralError as a, handleExitPromptError as h };