ccjk 9.7.0 → 9.8.1

package/dist/shared/{ccjk.CSkyCZIM.mjs → ccjk.Bndhan7G.mjs}

@@ -1,245 +1,7 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import process__default from 'node:process';
+import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { CLAUDE_AGENTS_DIR, SETTINGS_FILE, CCJK_SKILLS_DIR } from '../chunks/constants.mjs';
 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}`
-  };
-}
+import process__default from 'node:process';
 
 const agentsCheck = {
   name: "Agents",
@@ -635,4 +397,4 @@ async function runHealthCheck(checks) {
   };
 }
 
-export { analyzeProject as a, getRecommendations as g, runHealthCheck as r };
+export { runHealthCheck as r };

package/dist/shared/ccjk.CeE8RLG2.mjs

@@ -0,0 +1,62 @@
+import { detectCodeToolType } from '../chunks/smart-defaults.mjs';
+import { DEFAULT_CODE_TOOL_TYPE } from '../chunks/constants.mjs';
+import { i18n } from '../chunks/index.mjs';
+import { readZcfConfigAsync, saveZcfConfig } 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 freshDetected = detectCodeToolType();
+    if (isValidCodeType(freshDetected)) {
+      try {
+        const config = await readZcfConfigAsync();
+        if (config && config.codeToolType !== freshDetected) {
+          config.codeToolType = freshDetected;
+          await saveZcfConfig(config);
+        }
+      } catch {
+      }
+      return freshDetected;
+    }
+  } catch {
+  }
+  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 };

package/dist/shared/ccjk.DKojSRzw.mjs

@@ -0,0 +1,266 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import process__default from 'node:process';
+import { join } from 'pathe';
+
+function scanProject(cwd) {
+  const root = cwd || process__default.cwd();
+  const pkg = readPackageJson(root);
+  const language = detectLanguage(root, pkg);
+  const secondaryLanguages = detectSecondaryLanguages(root, pkg, language);
+  return {
+    language,
+    secondaryLanguages,
+    framework: detectFramework(root, pkg),
+    testRunner: detectTestRunner(root, pkg),
+    packageManager: detectPackageManager(root),
+    linter: detectLinter(root, pkg),
+    formatter: detectFormatter(root, pkg),
+    database: detectDatabase(root),
+    runtime: detectRuntime(),
+    isMonorepo: detectMonorepo(root, pkg),
+    usesConventionalCommits: detectConventionalCommits(root, pkg),
+    hasGitHooks: detectGitHooks(root, pkg),
+    hasDocker: existsSync(join(root, "Dockerfile")) || existsSync(join(root, "docker-compose.yml")) || existsSync(join(root, "docker-compose.yaml")),
+    hasCI: detectCI(root),
+    root
+  };
+}
+function readPackageJson(root) {
+  const p = join(root, "package.json");
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function hasDep(pkg, name) {
+  if (!pkg) return false;
+  return !!(pkg.dependencies?.[name] || pkg.devDependencies?.[name] || pkg.peerDependencies?.[name]);
+}
+function detectLanguage(root, pkg) {
+  if (existsSync(join(root, "tsconfig.json")) || hasDep(pkg, "typescript")) {
+    return "typescript";
+  }
+  if (existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "setup.py")) || existsSync(join(root, "requirements.txt")) || existsSync(join(root, "Pipfile"))) {
+    return "python";
+  }
+  if (existsSync(join(root, "go.mod"))) {
+    return "go";
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    return "rust";
+  }
+  if (existsSync(join(root, "pom.xml")) || existsSync(join(root, "build.gradle")) || existsSync(join(root, "build.gradle.kts"))) {
+    return "java";
+  }
+  if (existsSync(join(root, "Gemfile"))) {
+    return "ruby";
+  }
+  if (existsSync(join(root, "composer.json"))) {
+    return "php";
+  }
+  if (existsSync(join(root, "Package.swift"))) {
+    return "swift";
+  }
+  if (existsSync(join(root, "*.csproj")) || existsSync(join(root, "*.sln"))) {
+    return "csharp";
+  }
+  if (pkg) {
+    return "javascript";
+  }
+  return "unknown";
+}
+function detectSecondaryLanguages(root, pkg, primary) {
+  const langs = [];
+  const checks = [
+    ["typescript", () => existsSync(join(root, "tsconfig.json")) || hasDep(pkg, "typescript")],
+    ["javascript", () => !!pkg],
+    ["python", () => existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "requirements.txt"))],
+    ["go", () => existsSync(join(root, "go.mod"))],
+    ["rust", () => existsSync(join(root, "Cargo.toml"))]
+  ];
+  for (const [lang, check] of checks) {
+    if (lang !== primary && check()) langs.push(lang);
+  }
+  return langs;
+}
+function detectFramework(root, pkg) {
+  if (!pkg) {
+    if (existsSync(join(root, "pyproject.toml"))) {
+      const content = safeRead(join(root, "pyproject.toml"));
+      if (content.includes("fastapi")) return "fastapi";
+      if (content.includes("django")) return "django";
+      if (content.includes("flask")) return "flask";
+    }
+    if (existsSync(join(root, "requirements.txt"))) {
+      const content = safeRead(join(root, "requirements.txt"));
+      if (content.includes("fastapi")) return "fastapi";
+      if (content.includes("django")) return "django";
+      if (content.includes("flask")) return "flask";
+    }
+    return "none";
+  }
+  if (hasDep(pkg, "next")) return "next";
+  if (hasDep(pkg, "nuxt")) return "nuxt";
+  if (hasDep(pkg, "@angular/core")) return "angular";
+  if (hasDep(pkg, "svelte") || hasDep(pkg, "@sveltejs/kit")) return "svelte";
+  if (hasDep(pkg, "@nestjs/core")) return "nest";
+  if (hasDep(pkg, "@tauri-apps/api") || hasDep(pkg, "@tauri-apps/cli")) return "tauri";
+  if (hasDep(pkg, "electron")) return "electron";
+  if (hasDep(pkg, "vue")) return "vue";
+  if (hasDep(pkg, "react")) return "react";
+  if (hasDep(pkg, "fastify")) return "fastify";
+  if (hasDep(pkg, "express")) return "express";
+  return "none";
+}
+function detectTestRunner(root, pkg) {
+  if (hasDep(pkg, "vitest")) return "vitest";
+  if (hasDep(pkg, "jest") || hasDep(pkg, "@jest/core")) return "jest";
+  if (hasDep(pkg, "mocha")) return "mocha";
+  if (existsSync(join(root, "pytest.ini")) || existsSync(join(root, "conftest.py"))) return "pytest";
+  if (existsSync(join(root, "pyproject.toml"))) {
+    const content = safeRead(join(root, "pyproject.toml"));
+    if (content.includes("[tool.pytest") || content.includes("pytest")) return "pytest";
+  }
+  if (existsSync(join(root, "go.mod"))) return "go-test";
+  if (existsSync(join(root, "Cargo.toml"))) return "cargo-test";
+  if (existsSync(join(root, "pom.xml")) || existsSync(join(root, "build.gradle"))) return "junit";
+  if (existsSync(join(root, "Gemfile"))) {
+    const content = safeRead(join(root, "Gemfile"));
+    if (content.includes("rspec")) return "rspec";
+  }
+  if (hasDep(pkg, "phpunit") || existsSync(join(root, "phpunit.xml"))) return "phpunit";
+  return "none";
+}
+function detectPackageManager(root) {
+  if (existsSync(join(root, "pnpm-lock.yaml")) || existsSync(join(root, "pnpm-workspace.yaml"))) return "pnpm";
+  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn";
+  if (existsSync(join(root, "package-lock.json"))) return "npm";
+  if (existsSync(join(root, "poetry.lock"))) return "poetry";
+  if (existsSync(join(root, "Pipfile.lock")) || existsSync(join(root, "requirements.txt"))) return "pip";
+  if (existsSync(join(root, "Cargo.lock"))) return "cargo";
+  if (existsSync(join(root, "go.sum"))) return "go";
+  if (existsSync(join(root, "pom.xml"))) return "maven";
+  if (existsSync(join(root, "build.gradle")) || existsSync(join(root, "build.gradle.kts"))) return "gradle";
+  return "none";
+}
+function detectLinter(root, pkg) {
+  if (hasDep(pkg, "@biomejs/biome") || existsSync(join(root, "biome.json")) || existsSync(join(root, "biome.jsonc"))) return "biome";
+  if (hasDep(pkg, "oxlint") || hasDep(pkg, "oxc")) return "oxlint";
+  if (hasDep(pkg, "eslint") || existsSync(join(root, ".eslintrc.json")) || existsSync(join(root, ".eslintrc.js")) || existsSync(join(root, "eslint.config.js")) || existsSync(join(root, "eslint.config.mjs"))) return "eslint";
+  if (existsSync(join(root, "ruff.toml")) || existsSync(join(root, ".ruff.toml"))) return "ruff";
+  if (existsSync(join(root, "pyproject.toml"))) {
+    const content = safeRead(join(root, "pyproject.toml"));
+    if (content.includes("[tool.ruff")) return "ruff";
+    if (content.includes("[tool.pylint") || content.includes("pylint")) return "pylint";
+    if (content.includes("flake8")) return "flake8";
+  }
+  if (existsSync(join(root, ".golangci.yml")) || existsSync(join(root, ".golangci.yaml"))) return "golangci-lint";
+  if (existsSync(join(root, "Cargo.toml"))) return "clippy";
+  if (existsSync(join(root, ".rubocop.yml"))) return "rubocop";
+  return "none";
+}
+function detectFormatter(root, pkg) {
+  if (hasDep(pkg, "@biomejs/biome") || existsSync(join(root, "biome.json"))) return "biome";
+  if (hasDep(pkg, "prettier") || existsSync(join(root, ".prettierrc")) || existsSync(join(root, ".prettierrc.json")) || existsSync(join(root, "prettier.config.js")) || existsSync(join(root, "prettier.config.mjs"))) return "prettier";
+  if (existsSync(join(root, "pyproject.toml"))) {
+    const content = safeRead(join(root, "pyproject.toml"));
+    if (content.includes("[tool.ruff") && content.includes("format")) return "ruff";
+    if (content.includes("[tool.black") || content.includes("black")) return "black";
+  }
+  if (existsSync(join(root, "go.mod"))) return "gofmt";
+  if (existsSync(join(root, "Cargo.toml"))) return "rustfmt";
+  return "none";
+}
+function detectDatabase(root) {
+  for (const f of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+    const content = safeRead(join(root, f));
+    if (!content) continue;
+    if (content.includes("postgres")) return "postgresql";
+    if (content.includes("mysql") || content.includes("mariadb")) return "mysql";
+    if (content.includes("mongo")) return "mongodb";
+    if (content.includes("redis")) return "redis";
+  }
+  for (const f of [".env", ".env.local", ".env.development"]) {
+    const content = safeRead(join(root, f));
+    if (!content) continue;
+    if (content.includes("postgres")) return "postgresql";
+    if (content.includes("mysql")) return "mysql";
+    if (content.includes("mongodb") || content.includes("mongo+srv")) return "mongodb";
+    if (content.includes("redis://")) return "redis";
+  }
+  if (existsSync(join(root, "prisma", "schema.prisma"))) {
+    const content = safeRead(join(root, "prisma", "schema.prisma"));
+    if (content.includes("postgresql")) return "postgresql";
+    if (content.includes("mysql")) return "mysql";
+    if (content.includes("sqlite")) return "sqlite";
+    if (content.includes("mongodb")) return "mongodb";
+  }
+  for (const f of ["*.db", "*.sqlite", "*.sqlite3"]) {
+    if (existsSync(join(root, "db.sqlite")) || existsSync(join(root, "database.sqlite")) || existsSync(join(root, "dev.db"))) {
+      return "sqlite";
+    }
+  }
+  return "none";
+}
+function detectRuntime() {
+  const isContainer = existsSync("/.dockerenv") || existsSync("/run/.containerenv") || safeRead("/proc/1/cgroup").includes("docker");
+  const isSSH = !!process__default.env.SSH_CLIENT || !!process__default.env.SSH_TTY || !!process__default.env.SSH_CONNECTION;
+  const isCI = !!(process__default.env.CI || process__default.env.GITHUB_ACTIONS || process__default.env.GITLAB_CI || process__default.env.JENKINS_URL || process__default.env.CIRCLECI || process__default.env.TRAVIS || process__default.env.BUILDKITE);
+  const isWSL = safeRead("/proc/version").toLowerCase().includes("microsoft");
+  const isMac = process__default.platform === "darwin";
+  const hasDisplay = !!(process__default.env.DISPLAY || process__default.env.WAYLAND_DISPLAY || process__default.env.TERM_PROGRAM);
+  const isHeadless = !isMac && !hasDisplay && !isWSL;
+  const hasBrowser = isMac || hasDisplay || isWSL;
+  return {
+    isContainer,
+    isHeadless,
+    isSSH,
+    isCI,
+    isWSL,
+    hasBrowser
+  };
+}
+function detectMonorepo(root, pkg) {
+  if (pkg?.workspaces) return true;
+  if (existsSync(join(root, "pnpm-workspace.yaml"))) return true;
+  if (existsSync(join(root, "lerna.json"))) return true;
+  if (existsSync(join(root, "nx.json"))) return true;
+  if (existsSync(join(root, "turbo.json"))) return true;
+  return false;
+}
+function detectConventionalCommits(root, pkg) {
+  if (existsSync(join(root, ".commitlintrc.json")) || existsSync(join(root, ".commitlintrc.js")) || existsSync(join(root, "commitlint.config.js")) || existsSync(join(root, "commitlint.config.mjs"))) return true;
+  if (hasDep(pkg, "@commitlint/cli") || hasDep(pkg, "@commitlint/config-conventional")) return true;
+  try {
+    const log = execSync("git log --oneline -10 2>/dev/null", { cwd: root, encoding: "utf-8", timeout: 3e3 });
+    const conventionalPattern = /^[a-f0-9]+ (feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)(\(.+\))?[!]?:/m;
+    const lines = log.trim().split("\n").filter(Boolean);
+    const matches = lines.filter((l) => conventionalPattern.test(l));
+    return lines.length > 0 && matches.length / lines.length > 0.5;
+  } catch {
+    return false;
+  }
+}
+function detectGitHooks(root, pkg) {
+  if (existsSync(join(root, ".husky"))) return true;
+  if (hasDep(pkg, "husky") || hasDep(pkg, "simple-git-hooks") || hasDep(pkg, "lefthook")) return true;
+  if (existsSync(join(root, ".lefthook.yml"))) return true;
+  return false;
+}
+function detectCI(root) {
+  return existsSync(join(root, ".github", "workflows")) || existsSync(join(root, ".gitlab-ci.yml")) || existsSync(join(root, ".circleci")) || existsSync(join(root, "Jenkinsfile")) || existsSync(join(root, ".travis.yml")) || existsSync(join(root, "bitbucket-pipelines.yml"));
+}
+function safeRead(path) {
+  try {
+    if (!existsSync(path)) return "";
+    return readFileSync(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+export { scanProject as s };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "9.7.0",
+  "version": "9.8.1",
   "packageManager": "pnpm@10.17.1",
   "description": "CCJK v9.0.0 - Revolutionary AI Development Platform with Enterprise Security, Streaming Cloud Sync, CRDT Conflict Resolution, and Unified V3 Architecture",
   "author": {