ccjk 2.0.20 → 2.2.1

package/dist/chunks/shencha.mjs

@@ -0,0 +1,320 @@
+import { readFile } from 'node:fs/promises';
+import process from 'node:process';
+import ansis from 'ansis';
+import { resolve } from 'pathe';
+
+class LLMScanner {
+  llmClient;
+  constructor(llmClient) {
+    this.llmClient = llmClient;
+  }
+  /**
+   * LLM autonomously discovers what to scan
+   */
+  async discoverScanTargets(context) {
+    const projectName = context.projectName || "unknown";
+    const rootDir = context.rootDir || context.rootPath;
+    const languages = context.languages || [];
+    const frameworks = context.frameworks || [context.framework].filter(Boolean);
+    const fileStructure = context.fileStructure || context.sourceDirs;
+    const prompt = `Analyze this project and identify scan targets:
+
+Project: ${projectName}
+Root: ${rootDir}
+Languages: ${languages.join(", ")}
+Frameworks: ${frameworks.join(", ")}
+
+File structure summary:
+${fileStructure.slice(0, 50).join("\n")}
+${fileStructure.length > 50 ? `... and ${fileStructure.length - 50} more files` : ""}
+
+Identify:
+1. Critical code paths that need security auditing
+2. Files with potential performance issues
+3. Code that might have quality problems
+4. Configuration files that need validation
+
+For each target, provide:
+- path: file or directory path
+- type: 'file' | 'directory' | 'pattern'
+- priority: 'critical' | 'high' | 'medium' | 'low'
+- reason: why this should be scanned
+
+Return as JSON array.`;
+    const response = await this.llmClient.complete(prompt);
+    return this.parseTargets(response);
+  }
+  /**
+   * LLM decides how to scan each target
+   */
+  async determineScanStrategy(target) {
+    const prompt = `Determine the best scanning strategy for:
+
+Target: ${target.path}
+Type: ${target.type}
+Priority: ${target.priority}
+Reason: ${target.reason}
+
+What should we look for? Consider:
+1. Security vulnerabilities (injection, XSS, auth issues)
+2. Performance problems (N+1 queries, memory leaks, slow algorithms)
+3. Code quality (complexity, duplication, dead code)
+4. Best practices violations
+5. Potential bugs and edge cases
+
+Return a scanning strategy as JSON:
+{
+  "focusAreas": ["security", "performance", "quality"],
+  "patterns": ["regex patterns to search for"],
+  "checks": ["specific things to verify"],
+  "depth": "shallow" | "deep" | "comprehensive"
+}`;
+    const response = await this.llmClient.complete(prompt);
+    return this.parseStrategy(response);
+  }
+  /**
+   * LLM executes scan with dynamic approach
+   */
+  async executeScan(target, strategy, fileContent) {
+    const focusAreas = strategy.focusAreas || [];
+    const prompt = `Scan this code for issues:
+
+File: ${target.path}
+Focus Areas: ${focusAreas.join(", ")}
+Checks: ${strategy.checks.join(", ")}
+Depth: ${strategy.depth}
+
+Code:
+\`\`\`
+${fileContent.slice(0, 1e4)}
+${fileContent.length > 1e4 ? "\n... [truncated]" : ""}
+\`\`\`
+
+Analyze and identify all issues. For each issue provide:
+{
+  "id": "unique-id",
+  "type": "security" | "performance" | "quality" | "bug" | "style",
+  "severity": "critical" | "high" | "medium" | "low",
+  "title": "brief title",
+  "description": "detailed description",
+  "location": {
+    "file": "path",
+    "startLine": number,
+    "endLine": number,
+    "snippet": "code snippet"
+  },
+  "suggestion": "how to fix",
+  "confidence": 0.0 to 1.0
+}
+
+Return as JSON array of issues. Be thorough but avoid false positives.`;
+    const response = await this.llmClient.complete(prompt);
+    const issues = this.parseIssues(response, target.path);
+    return {
+      target,
+      strategy,
+      issues,
+      timestamp: /* @__PURE__ */ new Date(),
+      scannedAt: /* @__PURE__ */ new Date(),
+      duration: 0,
+      metrics: { linesScanned: fileContent.split("\n").length },
+      notes: ""
+    };
+  }
+  /**
+   * Batch scan multiple targets
+   */
+  async scanAll(context, readFile) {
+    const targets = await this.discoverScanTargets(context);
+    const results = [];
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    targets.sort((a, b) => (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2));
+    for (const target of targets) {
+      if (target.type === "file") {
+        try {
+          const strategy = await this.determineScanStrategy(target);
+          const content = await readFile(target.path);
+          const result = await this.executeScan(target, strategy, content);
+          results.push(result);
+        } catch (error) {
+          console.warn(`Could not scan ${target.path}: ${error}`);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Parse targets from LLM response
+   */
+  parseTargets(response) {
+    try {
+      const json = this.extractJson(response);
+      return json.map((t) => ({
+        path: t.path,
+        type: t.type || "file",
+        priority: t.priority || 5,
+        complexity: t.complexity || "medium",
+        reason: t.reason || "",
+        tags: t.tags || []
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Parse strategy from LLM response
+   */
+  parseStrategy(response) {
+    try {
+      const json = this.extractJson(response);
+      return {
+        type: json.type || "comprehensive",
+        focusAreas: json.focusAreas || ["security", "quality"],
+        checks: json.checks || [],
+        depth: json.depth || "deep",
+        contextFiles: json.contextFiles || [],
+        model: json.model || "sonnet"
+      };
+    } catch {
+      return {
+        type: "comprehensive",
+        focusAreas: ["security", "quality"],
+        checks: [],
+        depth: "deep",
+        contextFiles: [],
+        model: "sonnet"
+      };
+    }
+  }
+  /**
+   * Parse issues from LLM response
+   */
+  parseIssues(response, filePath) {
+    try {
+      const json = this.extractJson(response);
+      if (!Array.isArray(json))
+        return [];
+      return json.map((i, idx) => {
+        const issueType = this.mapIssueType(i.type);
+        const category = this.mapCategory(issueType);
+        return {
+          id: i.id || `issue-${idx}`,
+          type: issueType,
+          category,
+          severity: this.mapSeverity(i.severity),
+          title: i.title || "Untitled issue",
+          description: i.description || "",
+          file: i.location?.file || filePath,
+          line: i.location?.startLine || 1,
+          column: i.location?.column,
+          snippet: i.location?.snippet || "",
+          location: {
+            file: i.location?.file || filePath,
+            startLine: i.location?.startLine || 1,
+            endLine: i.location?.endLine || i.location?.startLine || 1,
+            snippet: i.location?.snippet || ""
+          },
+          suggestion: i.suggestion || "",
+          suggestedFix: i.suggestion || "",
+          confidence: i.confidence || 0.5,
+          autoFixable: i.autoFixable ?? false
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Extract JSON from LLM response
+   */
+  extractJson(response) {
+    if (!response || typeof response !== "string") {
+      return [];
+    }
+    try {
+      const jsonMatch = response.match(/\[[\s\S]*\]|\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+      return JSON.parse(response);
+    } catch {
+      console.warn("Failed to parse LLM response as JSON");
+      return [];
+    }
+  }
+  /**
+   * Map string to IssueType
+   */
+  mapIssueType(type) {
+    const typeMap = {
+      security: "security",
+      performance: "performance",
+      quality: "quality",
+      bug: "bug",
+      style: "style",
+      logic: "logic",
+      accessibility: "accessibility"
+    };
+    return typeMap[type?.toLowerCase()] || "quality";
+  }
+  /**
+   * Map IssueType to category (category doesn't include 'bug')
+   */
+  mapCategory(type) {
+    if (type === "bug") {
+      return "quality";
+    }
+    return type;
+  }
+  /**
+   * Map string to IssueSeverity
+   */
+  mapSeverity(severity) {
+    const severityMap = {
+      critical: "critical",
+      high: "high",
+      medium: "medium",
+      low: "low",
+      info: "info"
+    };
+    return severityMap[severity?.toLowerCase()] || "medium";
+  }
+}
+function createMockLLMClient() {
+  return {
+    async complete(_prompt) {
+      return "[]";
+    }
+  };
+}
+
+async function shenchaScan(options = {}) {
+  console.log(ansis.cyan("\u{1F50D} ShenCha: Scanning code..."));
+  const context = {
+    rootPath: process.cwd(),
+    projectName: "current-project",
+    sourceDirs: ["src"],
+    testDirs: ["tests"],
+    configFiles: []
+  };
+  const llmClient = createMockLLMClient();
+  const scanner = new LLMScanner(llmClient);
+  const readFileWrapper = async (path) => {
+    return await readFile(resolve(context.rootPath, path), "utf-8");
+  };
+  const results = await scanner.scanAll(context, readFileWrapper);
+  console.log(ansis.green(`\u2713 Scan complete. Found ${results.length} results.`));
+  if (options.output) {
+    console.log(ansis.gray(`Output saved to: ${options.output}`));
+  }
+}
+async function shenchaReport(_options = {}) {
+  console.log(ansis.cyan("\u{1F4CA} ShenCha: Generating report..."));
+  console.log(ansis.green("\u2713 Report generated."));
+}
+async function shenchaFix(_options = {}) {
+  console.log(ansis.cyan("\u{1F527} ShenCha: Fixing issues..."));
+  console.log(ansis.green("\u2713 Fixes applied."));
+}
+
+export { shenchaFix, shenchaReport, shenchaScan };

package/dist/chunks/skills-sync.mjs

@@ -1,27 +1,18 @@
 import ansis from 'ansis';
 import inquirer from 'inquirer';
-import { a as CCJK_SKILLS_DIR, Q as CCJK_CONFIG_DIR, w as writeFileAtomic, dt as getTranslation } from './simple-config.mjs';
+import { getTranslation } from './index2.mjs';
 import { createHash } from 'node:crypto';
 import { existsSync, readdirSync, readFileSync, mkdirSync } from 'node:fs';
 import process from 'node:process';
 import { join } from 'pathe';
+import { CCJK_SKILLS_DIR, CCJK_CONFIG_DIR } from './constants.mjs';
+import { writeFileAtomic } from './fs-operations.mjs';
 import { readFile, stat } from 'node:fs/promises';
 import matter from 'gray-matter';
-import 'node:os';
-import 'smol-toml';
-import 'dayjs';
-import 'node:child_process';
-import 'node:util';
 import 'node:url';
-import 'inquirer-toggle';
-import 'ora';
-import 'tinyexec';
-import 'node:path';
-import 'semver';
-import 'fs-extra';
-import 'trash';
 import 'i18next';
 import 'i18next-fs-backend';
+import 'node:os';
 
 function parseSkillMd(content, filePath = "unknown") {
   try {

package/dist/chunks/team.mjs

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import ansis from 'ansis';
+import inquirer from 'inquirer';
+import { join } from 'pathe';
+import { i18n } from './index2.mjs';
+import { writeFileAtomic } from './fs-operations.mjs';
+import 'node:process';
+import 'node:url';
+import 'i18next';
+import 'i18next-fs-backend';
+import 'node:crypto';
+import 'node:fs/promises';
+
+const TEAM_DIR = ".ccjk/team";
+const CONFIG_FILE = join(TEAM_DIR, "config.json");
+async function teamInit() {
+  if (!existsSync(TEAM_DIR)) {
+    mkdirSync(TEAM_DIR, { recursive: true });
+  }
+  const { name } = await inquirer.prompt({
+    type: "input",
+    name: "name",
+    message: i18n.t("team:enterTeamName"),
+    default: "my-team"
+  });
+  const config = {
+    name,
+    members: [],
+    sharedSettings: {}
+  };
+  writeFileAtomic(CONFIG_FILE, JSON.stringify(config, null, 2));
+  console.log(ansis.green(`\u2714 ${i18n.t("team:teamInitialized")}: ${name}`));
+}
+async function teamShare() {
+  if (!existsSync(CONFIG_FILE)) {
+    console.log(ansis.yellow(i18n.t("team:noTeamConfig")));
+    return;
+  }
+  const config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  console.log(ansis.cyan(i18n.t("team:shareConfig")));
+  console.log(JSON.stringify(config, null, 2));
+}
+async function teamSync() {
+  if (!existsSync(CONFIG_FILE)) {
+    console.log(ansis.yellow(i18n.t("team:noTeamConfig")));
+    return;
+  }
+  console.log(ansis.green(`\u2714 ${i18n.t("team:syncComplete")}`));
+}
+
+export { teamInit, teamShare, teamSync };

package/dist/chunks/tools.mjs

@@ -0,0 +1,169 @@
+import ansis from 'ansis';
+import ora from 'ora';
+import { CODE_TOOL_INFO, CODE_TOOL_TYPES } from './constants.mjs';
+import { format, i18n } from './index2.mjs';
+import { S as STATUS, C as COLORS, b as boxify } from '../shared/ccjk.BhKlRJ0h.mjs';
+import { c as getToolStatus, d as getAllToolsStatus, f as installTool } from '../shared/ccjk.n_AtlHzB.mjs';
+import 'node:os';
+import 'pathe';
+import 'node:fs';
+import 'node:process';
+import 'node:url';
+import 'i18next';
+import 'i18next-fs-backend';
+import './package.mjs';
+import 'tinyexec';
+
+async function listTools(options = {}) {
+  const spinner = ora(i18n.t("tools:scanning")).start();
+  const toolsStatus = await getAllToolsStatus();
+  spinner.stop();
+  if (options.json) {
+    console.log(JSON.stringify(toolsStatus, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(COLORS.primary("\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"));
+  console.log(COLORS.primary("\u2551") + COLORS.accent(`                    ${i18n.t("tools:title")}                    `.slice(0, 60)) + COLORS.primary("\u2551"));
+  console.log(COLORS.primary("\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"));
+  console.log("");
+  const cliTools = toolsStatus.filter((t) => CODE_TOOL_INFO[t.tool].category === "cli");
+  const extensionTools = toolsStatus.filter((t) => CODE_TOOL_INFO[t.tool].category === "extension");
+  const editorTools = toolsStatus.filter((t) => CODE_TOOL_INFO[t.tool].category === "editor");
+  const renderToolList = (tools, title) => {
+    console.log(COLORS.secondary(`  ${title}:`));
+    for (const tool of tools) {
+      const info = CODE_TOOL_INFO[tool.tool];
+      const statusIcon = tool.installed ? ansis.green("\u2713") : ansis.gray("\u25CB");
+      const version = tool.version ? ansis.cyan(` v${tool.version}`) : "";
+      const configStatus = tool.installed ? tool.configExists ? ansis.green(` [${i18n.t("tools:configured")}]`) : ansis.yellow(` [${i18n.t("tools:notConfigured")}]`) : "";
+      console.log(`    ${statusIcon} ${info.name}${version}${configStatus}`);
+      console.log(ansis.gray(`       ${info.description}`));
+    }
+    console.log("");
+  };
+  if (cliTools.length > 0)
+    renderToolList(cliTools, `\u{1F5A5}\uFE0F  ${i18n.t("tools:cliTools")}`);
+  if (extensionTools.length > 0)
+    renderToolList(extensionTools, `\u{1F50C} ${i18n.t("tools:ideExtensions")}`);
+  if (editorTools.length > 0)
+    renderToolList(editorTools, `\u270F\uFE0F  ${i18n.t("tools:aiEditors")}`);
+  const installed = toolsStatus.filter((t) => t.installed).length;
+  const configured = toolsStatus.filter((t) => t.configExists).length;
+  console.log(ansis.gray(`  ${format(i18n.t("tools:summary"), { installed: String(installed), total: String(toolsStatus.length), configured: String(configured), installedCount: String(installed) })}`));
+  console.log("");
+}
+async function installToolCommand(toolId, _options = {}) {
+  if (!CODE_TOOL_TYPES.includes(toolId)) {
+    console.log(STATUS.error(format(i18n.t("tools:unknownTool"), { tool: toolId })));
+    console.log(ansis.gray(format(i18n.t("tools:availableTools"), { tools: CODE_TOOL_TYPES.join(", ") })));
+    return;
+  }
+  const tool = toolId;
+  const info = CODE_TOOL_INFO[tool];
+  const status = await getToolStatus(tool);
+  if (status.installed) {
+    console.log(STATUS.info(format(i18n.t("tools:alreadyInstalled"), { name: info.name, version: status.version || "unknown" })));
+    return;
+  }
+  const spinner = ora(format(i18n.t("tools:installing"), { name: info.name })).start();
+  const result = await installTool(tool);
+  if (result.success) {
+    spinner.succeed(result.message);
+  } else {
+    spinner.fail(result.message);
+  }
+}
+async function showToolStatus(toolId, options = {}) {
+  if (!CODE_TOOL_TYPES.includes(toolId)) {
+    console.log(STATUS.error(format(i18n.t("tools:unknownTool"), { tool: toolId })));
+    console.log(ansis.gray(format(i18n.t("tools:availableTools"), { tools: CODE_TOOL_TYPES.join(", ") })));
+    return;
+  }
+  const tool = toolId;
+  const info = CODE_TOOL_INFO[tool];
+  const status = await getToolStatus(tool);
+  if (options.json) {
+    console.log(JSON.stringify({ ...status, info }, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(boxify(`
+${info.name}
+
+${i18n.t("tools:status")}: ${status.installed ? `\u2713 ${i18n.t("tools:installed")}` : `\u2717 ${i18n.t("tools:notInstalled")}`}
+${i18n.t("tools:version")}: ${status.version || "N/A"}
+${i18n.t("tools:config")}: ${status.configExists ? `\u2713 ${i18n.t("tools:configured")}` : `\u26A0 ${i18n.t("tools:notConfigured")}`}
+${i18n.t("tools:configPath")}: ${status.configPath}
+${i18n.t("tools:category")}: ${info.category}
+${i18n.t("tools:website")}: ${info.website}
+
+${i18n.t("tools:installCommand")}:
+  ${info.installCmd}
+`, "rounded", info.name));
+}
+async function showRecommendedTools(_options = {}) {
+  const recommended = [
+    {
+      tool: "claude-code",
+      reason: "Best for complex reasoning and code generation"
+    },
+    {
+      tool: "aider",
+      reason: "Great for terminal-based pair programming"
+    },
+    {
+      tool: "continue",
+      reason: "Excellent VS Code integration with multiple models"
+    }
+  ];
+  console.log("");
+  console.log(COLORS.secondary(`  \u{1F31F} ${i18n.t("tools:recommended")}`));
+  console.log("");
+  for (const rec of recommended) {
+    const info = CODE_TOOL_INFO[rec.tool];
+    const status = await getToolStatus(rec.tool);
+    const statusIcon = status.installed ? ansis.green("\u2713") : ansis.gray("\u25CB");
+    console.log(`  ${statusIcon} ${ansis.bold(info.name)}`);
+    console.log(ansis.gray(`     ${rec.reason}`));
+    if (!status.installed) {
+      console.log(ansis.cyan(`     ${format(i18n.t("tools:installCmd"), { cmd: info.installCmd })}`));
+    }
+    console.log("");
+  }
+}
+async function toolsCommand(action = "list", target, options = {}) {
+  switch (action) {
+    case "list":
+    case "ls":
+      await listTools(options);
+      break;
+    case "install":
+    case "i":
+      if (!target) {
+        console.log(STATUS.error(i18n.t("tools:specifyTool")));
+        console.log(ansis.gray(format(i18n.t("tools:usage"), { action: "install" })));
+        console.log(ansis.gray(format(i18n.t("tools:availableTools"), { tools: CODE_TOOL_TYPES.join(", ") })));
+        return;
+      }
+      await installToolCommand(target, options);
+      break;
+    case "status":
+    case "s":
+      if (!target) {
+        await listTools(options);
+      } else {
+        await showToolStatus(target, options);
+      }
+      break;
+    case "recommend":
+    case "rec":
+      await showRecommendedTools(options);
+      break;
+    default:
+      console.log(STATUS.error(format(i18n.t("tools:unknownAction"), { action })));
+      console.log(ansis.gray(i18n.t("tools:availableActions")));
+  }
+}
+
+export { toolsCommand as default, installToolCommand, listTools, showRecommendedTools, showToolStatus, toolsCommand };