ccjk 13.3.5 → 13.3.7

package/dist/chunks/context.mjs

@@ -0,0 +1,659 @@
+import { mkdir, writeFile, access, readFile, readdir, stat } from 'node:fs/promises';
+import { d as dirname, j as join, r as relative } from '../shared/ccjk.bQ7Dh1g4.mjs';
+import { constants } from 'node:fs';
+
+function buildContextPack(intelligence, options = {}) {
+  const {
+    projectName = "Unknown Project",
+    projectDescription = "No description provided",
+    includeCommands = true,
+    includeRepoMap = true
+  } = options;
+  return {
+    projectIdentity: buildProjectIdentity(projectName, projectDescription, intelligence.stack),
+    stack: intelligence.stack,
+    commands: includeCommands ? intelligence.commands : [],
+    repoTopology: includeRepoMap ? buildRepoTopology(intelligence.repoMap) : "",
+    testPolicy: buildTestPolicy(intelligence.commands),
+    riskZones: identifyRiskZones(intelligence.repoMap),
+    retrievalInstructions: buildRetrievalInstructions(intelligence.stack),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildProjectIdentity(name, description, stack) {
+  const parts = [
+    `Project: ${name}`,
+    `Description: ${description}`,
+    ""
+  ];
+  if (stack.languages.length > 0) {
+    parts.push(`Languages: ${stack.languages.join(", ")}`);
+  }
+  if (stack.frameworks.length > 0) {
+    const frameworkList = stack.frameworks.map((f) => `${f.name}${f.version ? ` ${f.version}` : ""}`).join(", ");
+    parts.push(`Frameworks: ${frameworkList}`);
+  }
+  if (stack.packageManager) {
+    parts.push(`Package Manager: ${stack.packageManager}`);
+  }
+  if (stack.runtime) {
+    parts.push(`Runtime: ${stack.runtime}`);
+  }
+  return parts.join("\n");
+}
+function buildRepoTopology(repoMap) {
+  const parts = ["Repository Structure:", ""];
+  const byType = /* @__PURE__ */ new Map();
+  for (const dir of repoMap.directories) {
+    const dirs = byType.get(dir.type) || [];
+    dirs.push(dir);
+    byType.set(dir.type, dirs);
+  }
+  const typeOrder = [
+    "source",
+    "test",
+    "config",
+    "docs",
+    "assets",
+    "other"
+  ];
+  for (const type of typeOrder) {
+    const dirs = byType.get(type);
+    if (dirs && dirs.length > 0) {
+      parts.push(`${type.toUpperCase()}:`);
+      for (const dir of dirs.slice(0, 5)) {
+        parts.push(`  - ${dir.relativePath} (${dir.fileCount} files)`);
+      }
+      parts.push("");
+    }
+  }
+  parts.push(`Total: ${repoMap.totalFiles} files`);
+  return parts.join("\n");
+}
+function buildTestPolicy(commands) {
+  const testCommands = commands.filter((c) => c.type === "test");
+  if (testCommands.length === 0) {
+    return "No test commands detected. Consider adding tests before making changes.";
+  }
+  const parts = [
+    "Test Policy:",
+    "",
+    "Available test commands:"
+  ];
+  for (const cmd of testCommands) {
+    parts.push(`  - ${cmd.name}: ${cmd.command}`);
+  }
+  parts.push("");
+  parts.push("Always run tests before committing changes.");
+  return parts.join("\n");
+}
+function identifyRiskZones(repoMap) {
+  const riskZones = [];
+  const buildDirs = repoMap.directories.filter((d) => d.type === "build");
+  for (const dir of buildDirs) {
+    riskZones.push(`${dir.relativePath} (generated files)`);
+  }
+  const largeDirs = repoMap.directories.filter((d) => d.fileCount > 100).sort((a, b) => b.fileCount - a.fileCount).slice(0, 3);
+  for (const dir of largeDirs) {
+    riskZones.push(`${dir.relativePath} (${dir.fileCount} files - high complexity)`);
+  }
+  return riskZones;
+}
+function buildRetrievalInstructions(stack) {
+  const parts = [
+    "Retrieval-First Instructions:",
+    ""
+  ];
+  if (stack.frameworks.length > 0) {
+    parts.push("For framework-specific questions:");
+    for (const framework of stack.frameworks) {
+      parts.push(`  - ${framework.name}: Check local docs or official documentation for version ${framework.version || "latest"}`);
+    }
+    parts.push("");
+  }
+  parts.push("For repository conventions:");
+  parts.push("  - Check existing code patterns before implementing new features");
+  parts.push("  - Review test files to understand testing conventions");
+  parts.push("  - Consult configuration files for build and deployment settings");
+  return parts.join("\n");
+}
+
+async function writeClaudeContext(contextPack, outputPath) {
+  const content = formatClaudeContext(contextPack);
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, content, "utf-8");
+}
+function formatClaudeContext(pack) {
+  const sections = [];
+  sections.push("# CLAUDE.md");
+  sections.push("");
+  sections.push("This file provides guidance to Claude Code when working with code in this repository.");
+  sections.push("");
+  sections.push(`Generated: ${new Date(pack.generatedAt).toLocaleString()}`);
+  sections.push("");
+  sections.push("---");
+  sections.push("");
+  sections.push("## Project Information");
+  sections.push("");
+  sections.push(pack.projectIdentity);
+  sections.push("");
+  if (pack.stack.frameworks.length > 0) {
+    sections.push("## Technology Stack");
+    sections.push("");
+    for (const framework of pack.stack.frameworks) {
+      sections.push(`### ${framework.name}`);
+      if (framework.version) {
+        sections.push(`Version: ${framework.version}`);
+      }
+      sections.push(`Type: ${framework.type}`);
+      sections.push("");
+    }
+  }
+  if (pack.commands.length > 0) {
+    sections.push("## Available Commands");
+    sections.push("");
+    const commandsByType = /* @__PURE__ */ new Map();
+    for (const cmd of pack.commands) {
+      const cmds = commandsByType.get(cmd.type) || [];
+      cmds.push(cmd);
+      commandsByType.set(cmd.type, cmds);
+    }
+    for (const [type, commands] of commandsByType) {
+      sections.push(`### ${type.charAt(0).toUpperCase() + type.slice(1)}`);
+      sections.push("");
+      for (const cmd of commands) {
+        sections.push(`- \`${cmd.name}\`: ${cmd.command}`);
+        if (cmd.description) {
+          sections.push(`  ${cmd.description}`);
+        }
+      }
+      sections.push("");
+    }
+  }
+  if (pack.repoTopology) {
+    sections.push("## Repository Structure");
+    sections.push("");
+    sections.push(pack.repoTopology);
+    sections.push("");
+  }
+  if (pack.testPolicy) {
+    sections.push("## Testing");
+    sections.push("");
+    sections.push(pack.testPolicy);
+    sections.push("");
+  }
+  if (pack.riskZones.length > 0) {
+    sections.push("## Risk Zones");
+    sections.push("");
+    sections.push("Be cautious when modifying these areas:");
+    sections.push("");
+    for (const zone of pack.riskZones) {
+      sections.push(`- ${zone}`);
+    }
+    sections.push("");
+  }
+  if (pack.retrievalInstructions) {
+    sections.push("## Development Guidelines");
+    sections.push("");
+    sections.push(pack.retrievalInstructions);
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+
+async function detectCommands(projectRoot = ".") {
+  const commands = [];
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (await fileExists$1(packageJsonPath)) {
+    commands.push(...await detectNpmScripts(packageJsonPath));
+  }
+  const makefilePath = join(projectRoot, "Makefile");
+  if (await fileExists$1(makefilePath)) {
+    commands.push(...await detectMakeTargets(makefilePath));
+  }
+  const pyprojectPath = join(projectRoot, "pyproject.toml");
+  if (await fileExists$1(pyprojectPath)) {
+    commands.push(...await detectPoetryScripts(pyprojectPath));
+  }
+  return commands;
+}
+async function detectNpmScripts(packageJsonPath) {
+  const commands = [];
+  try {
+    const content = await readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    if (packageJson.scripts) {
+      for (const [name, command] of Object.entries(packageJson.scripts)) {
+        commands.push({
+          name,
+          command,
+          type: inferCommandType(name)
+        });
+      }
+    }
+  } catch {
+  }
+  return commands;
+}
+async function detectMakeTargets(makefilePath) {
+  const commands = [];
+  try {
+    const content = await readFile(makefilePath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const match = line.match(/^([\w-]+):\s*(.*)/);
+      if (match) {
+        const [, name, deps] = match;
+        if (!name.startsWith(".") && name !== "PHONY") {
+          commands.push({
+            name,
+            command: `make ${name}`,
+            type: inferCommandType(name),
+            description: deps || void 0
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return commands;
+}
+async function detectPoetryScripts(pyprojectPath) {
+  const commands = [];
+  try {
+    const content = await readFile(pyprojectPath, "utf-8");
+    const scriptsMatch = content.match(/\[tool\.poetry\.scripts\]([\s\S]*?)(?:\[|$)/);
+    if (scriptsMatch) {
+      const scriptsSection = scriptsMatch[1];
+      const lines = scriptsSection.split("\n");
+      for (const line of lines) {
+        const match = line.match(/^([\w-]+)\s*=\s*"([^"]+)"/);
+        if (match) {
+          const [, name, command] = match;
+          commands.push({
+            name,
+            command,
+            type: inferCommandType(name)
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return commands;
+}
+function inferCommandType(name) {
+  const lowerName = name.toLowerCase();
+  if (lowerName.includes("build") || lowerName.includes("compile")) {
+    return "build";
+  }
+  if (lowerName.includes("test") || lowerName.includes("spec")) {
+    return "test";
+  }
+  if (lowerName.includes("lint") || lowerName.includes("format")) {
+    return "lint";
+  }
+  if (lowerName.includes("dev") || lowerName.includes("watch")) {
+    return "dev";
+  }
+  if (lowerName.includes("start") || lowerName.includes("serve")) {
+    return "start";
+  }
+  if (lowerName.includes("deploy") || lowerName.includes("publish")) {
+    return "deploy";
+  }
+  return "other";
+}
+async function fileExists$1(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function mapRepository(projectRoot = ".", options = {}) {
+  const { maxDepth = 3, ignorePatterns = getDefaultIgnorePatterns() } = options;
+  const directories = [];
+  let totalFiles = 0;
+  let totalSize = 0;
+  await scanDirectory(projectRoot, projectRoot, 0, maxDepth, ignorePatterns, directories);
+  for (const dir of directories) {
+    totalFiles += dir.fileCount;
+    totalSize += dir.size;
+  }
+  return {
+    root: projectRoot,
+    directories,
+    totalFiles,
+    totalSize
+  };
+}
+async function scanDirectory(root, dir, depth, maxDepth, ignorePatterns, result) {
+  if (depth > maxDepth) {
+    return;
+  }
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    let fileCount = 0;
+    let size = 0;
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relativePath = relative(root, fullPath);
+      if (shouldIgnore(relativePath, ignorePatterns)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await scanDirectory(root, fullPath, depth + 1, maxDepth, ignorePatterns, result);
+      } else if (entry.isFile()) {
+        fileCount++;
+        try {
+          const stats = await stat(fullPath);
+          size += stats.size;
+        } catch {
+        }
+      }
+    }
+    if (fileCount > 0 || depth === 0) {
+      result.push({
+        path: dir,
+        relativePath: relative(root, dir) || ".",
+        type: inferDirectoryType(relative(root, dir)),
+        fileCount,
+        size
+      });
+    }
+  } catch {
+  }
+}
+function shouldIgnore(path, patterns) {
+  for (const pattern of patterns) {
+    if (path.includes(pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getDefaultIgnorePatterns() {
+  return [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    "coverage",
+    ".cache",
+    ".turbo",
+    "__pycache__",
+    ".pytest_cache",
+    "venv",
+    ".venv",
+    "target",
+    "vendor"
+  ];
+}
+function inferDirectoryType(path) {
+  const lowerPath = path.toLowerCase();
+  if (lowerPath.match(/^(src|lib|app|packages|components|pages|views)/)) {
+    return "source";
+  }
+  if (lowerPath.match(/^(test|tests|__tests__|spec|specs|e2e)/)) {
+    return "test";
+  }
+  if (lowerPath.match(/^(config|configs|\.config|\.github|\.vscode)/)) {
+    return "config";
+  }
+  if (lowerPath.match(/^(docs|documentation|wiki)/)) {
+    return "docs";
+  }
+  if (lowerPath.match(/^(dist|build|out|\.next|\.nuxt|target)/)) {
+    return "build";
+  }
+  if (lowerPath.match(/^(public|static|assets|images|media)/)) {
+    return "assets";
+  }
+  return "other";
+}
+
+async function detectStack(projectRoot = ".") {
+  const languages = await detectLanguages(projectRoot);
+  const frameworks = await detectFrameworks(projectRoot);
+  const packageManager = await detectPackageManager(projectRoot);
+  const runtime = await detectRuntime(projectRoot);
+  return {
+    languages,
+    frameworks,
+    packageManager,
+    runtime
+  };
+}
+async function detectLanguages(projectRoot) {
+  const languages = /* @__PURE__ */ new Set();
+  if (await fileExists(join(projectRoot, "tsconfig.json"))) {
+    languages.add("TypeScript");
+  }
+  if (await fileExists(join(projectRoot, "package.json"))) {
+    languages.add("JavaScript");
+  }
+  if (await fileExists(join(projectRoot, "requirements.txt")) || await fileExists(join(projectRoot, "pyproject.toml")) || await fileExists(join(projectRoot, "setup.py"))) {
+    languages.add("Python");
+  }
+  if (await fileExists(join(projectRoot, "go.mod"))) {
+    languages.add("Go");
+  }
+  if (await fileExists(join(projectRoot, "Cargo.toml"))) {
+    languages.add("Rust");
+  }
+  if (await fileExists(join(projectRoot, "pom.xml")) || await fileExists(join(projectRoot, "build.gradle"))) {
+    languages.add("Java");
+  }
+  return Array.from(languages);
+}
+async function detectFrameworks(projectRoot) {
+  const frameworks = [];
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    const packageJson = await readPackageJson(packageJsonPath);
+    if (packageJson) {
+      frameworks.push(...detectNodeFrameworks(packageJson));
+    }
+  }
+  const requirementsPath = join(projectRoot, "requirements.txt");
+  if (await fileExists(requirementsPath)) {
+    frameworks.push(...await detectPythonFrameworks(requirementsPath));
+  }
+  return frameworks;
+}
+function detectNodeFrameworks(packageJson) {
+  const frameworks = [];
+  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  const frameworkMap = {
+    next: { type: "fullstack" },
+    react: { type: "frontend" },
+    vue: { type: "frontend" },
+    nuxt: { type: "fullstack" },
+    svelte: { type: "frontend" },
+    angular: { type: "frontend" },
+    express: { type: "backend" },
+    fastify: { type: "backend" },
+    koa: { type: "backend" },
+    nestjs: { type: "backend" },
+    vitest: { type: "testing" },
+    jest: { type: "testing" },
+    vite: { type: "build" },
+    webpack: { type: "build" },
+    esbuild: { type: "build" }
+  };
+  for (const [name, config] of Object.entries(frameworkMap)) {
+    if (deps[name]) {
+      frameworks.push({
+        name,
+        version: deps[name].replace(/^[\^~]/, ""),
+        type: config.type
+      });
+    }
+  }
+  return frameworks;
+}
+async function detectPythonFrameworks(requirementsPath) {
+  const frameworks = [];
+  try {
+    const content = await readFile(requirementsPath, "utf-8");
+    const lines = content.split("\n");
+    const frameworkMap = {
+      django: { type: "fullstack" },
+      flask: { type: "backend" },
+      fastapi: { type: "backend" },
+      pytest: { type: "testing" }
+    };
+    for (const line of lines) {
+      const match = line.match(/^([\w-]+)(?:==|>=|<=)?([\d.]+)?/);
+      if (match) {
+        const [, name, version] = match;
+        const config = frameworkMap[name.toLowerCase()];
+        if (config) {
+          frameworks.push({
+            name,
+            version: version || null,
+            type: config.type
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return frameworks;
+}
+async function detectPackageManager(projectRoot) {
+  if (await fileExists(join(projectRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fileExists(join(projectRoot, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fileExists(join(projectRoot, "package-lock.json"))) {
+    return "npm";
+  }
+  if (await fileExists(join(projectRoot, "bun.lockb"))) {
+    return "bun";
+  }
+  return null;
+}
+async function detectRuntime(projectRoot) {
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    const packageJson = await readPackageJson(packageJsonPath);
+    if (packageJson?.engines?.node) {
+      return `Node.js ${packageJson.engines.node}`;
+    }
+    return "Node.js";
+  }
+  if (await fileExists(join(projectRoot, "go.mod"))) {
+    return "Go";
+  }
+  if (await fileExists(join(projectRoot, "Cargo.toml"))) {
+    return "Rust";
+  }
+  return null;
+}
+async function readPackageJson(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function fileExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function analyzeProject(projectRoot = ".") {
+  const [stack, commands, repoMap] = await Promise.all([
+    detectStack(projectRoot),
+    detectCommands(projectRoot),
+    mapRepository(projectRoot)
+  ]);
+  return {
+    stack,
+    commands,
+    repoMap,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+async function contextBuild(options = {}) {
+  const {
+    target: _target = "claude-code",
+    output = ".",
+    force: _force = false,
+    merge = false,
+    projectName,
+    projectDescription
+  } = options;
+  console.log("\u{1F50D} Analyzing project...");
+  const intelligence = await analyzeProject(".");
+  console.log("\u2705 Analysis complete");
+  console.log(`   Languages: ${intelligence.stack.languages.join(", ")}`);
+  console.log(`   Frameworks: ${intelligence.stack.frameworks.map((f) => f.name).join(", ")}`);
+  console.log(`   Commands: ${intelligence.commands.length}`);
+  console.log("");
+  console.log("\u{1F4E6} Building context pack...");
+  const contextPack = buildContextPack(intelligence, {
+    projectName,
+    projectDescription,
+    includeCommands: true,
+    includeRepoMap: true
+  });
+  const outputPath = join(output, "CLAUDE.md");
+  if (merge) {
+    try {
+      await readFile(outputPath, "utf-8");
+      console.log("\u{1F4DD} Merging with existing CLAUDE.md...");
+    } catch {
+    }
+  }
+  await writeClaudeContext(contextPack, outputPath);
+  console.log(`\u2705 Context pack written to: ${outputPath}`);
+}
+async function contextRefresh() {
+  console.log("\u{1F504} Refreshing context pack...");
+  await contextBuild({ force: true, merge: true });
+}
+async function contextDoctor() {
+  console.log("\u{1F50D} Running context health check...");
+  const intelligence = await analyzeProject(".");
+  console.log("\n\u{1F4CA} Project Health:");
+  console.log(`   \u2705 Languages detected: ${intelligence.stack.languages.length}`);
+  console.log(`   \u2705 Frameworks detected: ${intelligence.stack.frameworks.length}`);
+  console.log(`   \u2705 Commands detected: ${intelligence.commands.length}`);
+  console.log(`   \u2705 Directories scanned: ${intelligence.repoMap.directories.length}`);
+  if (intelligence.commands.length === 0) {
+    console.log("\n\u26A0\uFE0F  Warning: No commands detected. Consider adding package.json scripts.");
+  }
+  if (intelligence.stack.frameworks.length === 0) {
+    console.log("\n\u26A0\uFE0F  Warning: No frameworks detected. Context may be generic.");
+  }
+  console.log("\n\u2705 Context health check complete");
+}
+async function contextCommand(options = {}) {
+  if (options.action === "refresh") {
+    await contextRefresh();
+    return;
+  }
+  if (options.action === "doctor") {
+    await contextDoctor();
+    return;
+  }
+  await contextBuild(options);
+}
+
+export { contextBuild, contextCommand, contextDoctor, contextRefresh };

package/dist/chunks/dashboard.mjs

@@ -1,8 +1,8 @@
-import a from './index3.mjs';
 import { existsSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import process__default from 'node:process';
-import { i18n } from './index6.mjs';
+import a from './index2.mjs';
+import { i18n } from './index5.mjs';
 import { createHash } from 'node:crypto';
 import { exec as q } from './main.mjs';
 import { n as normalize, j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
@@ -138,11 +138,12 @@ function divider() {
   return a.gray("\u2500".repeat(50));
 }
 function formatBytes(bytes) {
-  if (bytes === 0) return "0 B";
+  if (bytes === 0)
+    return "0 B";
   const k = 1024;
   const sizes = ["B", "KB", "MB", "GB"];
   const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+  return `${(bytes / k ** i).toFixed(2)} ${sizes[i]}`;
 }
 function formatNumber(num) {
   return num.toLocaleString();
@@ -154,10 +155,14 @@ function formatDate(timestamp) {
   const date = new Date(timestamp);
   const now = Date.now();
   const diff = now - timestamp;
-  if (diff < 6e4) return "just now";
-  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
-  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
-  if (diff < 6048e5) return `${Math.floor(diff / 864e5)}d ago`;
+  if (diff < 6e4)
+    return "just now";
+  if (diff < 36e5)
+    return `${Math.floor(diff / 6e4)}m ago`;
+  if (diff < 864e5)
+    return `${Math.floor(diff / 36e5)}h ago`;
+  if (diff < 6048e5)
+    return `${Math.floor(diff / 864e5)}d ago`;
   return date.toLocaleDateString();
 }
 function statusIcon(status) {
@@ -208,7 +213,7 @@ async function collectDashboardData() {
     data.persistence.totalContexts = stats.totalContexts;
     data.persistence.databaseSize = stats.totalSize;
     if (stats.totalOriginalTokens > 0) {
-      const tokensSaved = stats.totalOriginalTokens - stats.totalCompressedTokens;
+      const _tokensSaved = stats.totalOriginalTokens - stats.totalCompressedTokens;
       data.compression.compressionRatio = stats.averageCompressionRatio;
       const oneHourAgo = Date.now() - 36e5;
       const recentContexts = persistence.queryContexts({