ccjk 13.5.3 → 13.5.4

package/README.md

@@ -122,10 +122,10 @@ npx ccjk browser open https://example.com --headed
 ## 🔥 Features That Matter
 
 ### 🧠 Persistent Memory
-AI remembers your codebase, conventions, and decisions across sessions.
+Manage Claude Code memory and project notes from the CLI.
 ```bash
-ccjk memory --enable
-# Now Claude knows your project structure forever
+ccjk memory
+ccjk memory --edit
 ```
 
 ### 🤖 Agent Teams (NEW)
@@ -249,8 +249,8 @@ ccjk browser status
 ccjk browser stop
 
 # Memory & Context
-ccjk memory --enable
-ccjk compact         # Clean up conversation
+ccjk memory
+ccjk memory --edit
 
 # Zero-Config Permission Presets (NEW)
 ccjk zc --list       # List available presets

package/dist/chunks/boost.mjs

@@ -3,11 +3,12 @@ import { existsSync, readFileSync } from 'node:fs';
 import process__default from 'node:process';
 import { SETTINGS_FILE } from './constants.mjs';
 import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import { r as runHealthCheck } from '../shared/ccjk.Crd_nEfj.mjs';
+import { r as runHealthCheck } from '../shared/ccjk.xkKNsC02.mjs';
 import '../shared/ccjk.BAGoDD49.mjs';
 import 'node:os';
 import './index5.mjs';
 import 'node:url';
+import './memory-check.mjs';
 import 'node:path';
 import 'fs';
 import 'constants';
@@ -15,6 +16,12 @@ import 'stream';
 import 'util';
 import 'assert';
 import 'path';
+import './memory-paths.mjs';
+import '../shared/ccjk.BBtCGd_g.mjs';
+import './index6.mjs';
+import './fs-operations.mjs';
+import 'node:crypto';
+import 'node:fs/promises';
 
 function analyzeProject(root) {
   const cwd = process__default.cwd();

package/dist/chunks/ccjk-config.mjs

@@ -66,6 +66,9 @@ function createDefaultTomlConfig(preferredLang = "en", claudeCodeInstallType = "
     codex: {
       enabled: false,
       systemPromptStyle: "senior-architect"
+    },
+    storage: {
+      memory: {}
     }
   };
 }
@@ -93,6 +96,9 @@ function migrateFromJsonConfig(jsonConfig) {
     codex: {
       enabled: jsonConfig.codeToolType === "codex",
       systemPromptStyle: jsonConfig.systemPromptStyle || defaultConfig.codex.systemPromptStyle
+    },
+    storage: {
+      memory: {}
     }
   };
   return tomlConfig;
@@ -113,6 +119,14 @@ function updateTomlConfig(configPath, updates) {
     codex: {
       ...existingConfig.codex,
       ...updates.codex
+    },
+    storage: {
+      ...existingConfig.storage,
+      ...updates.storage,
+      memory: {
+        ...existingConfig.storage?.memory || {},
+        ...updates.storage?.memory || {}
+      }
     }
   };
   writeTomlConfig(configPath, updatedConfig);
@@ -236,6 +250,9 @@ function writeZcfConfig(config) {
         tomlConfig.claudeCode.version = existingTomlConfig.claudeCode.version;
       }
     }
+    if (existingTomlConfig?.storage) {
+      tomlConfig.storage = existingTomlConfig.storage;
+    }
     writeTomlConfig(ZCF_CONFIG_FILE, tomlConfig);
   } catch {
   }

package/dist/chunks/context.mjs

@@ -1,6 +1,20 @@
 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';
+import { constants, existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import a from './index2.mjs';
+import { getTranslation } from './index5.mjs';
+import { inspectMemoryFiles } from './memory-sync.mjs';
+import '../shared/ccjk.BAGoDD49.mjs';
+import 'node:process';
+import 'node:url';
+import 'node:path';
+import './memory-paths.mjs';
+import './constants.mjs';
+import 'node:os';
+import '../shared/ccjk.BBtCGd_g.mjs';
+import './index6.mjs';
+import './fs-operations.mjs';
+import 'node:crypto';
 
 function buildContextPack(intelligence, options = {}) {
   const {
@@ -590,6 +604,303 @@ async function analyzeProject(projectRoot = ".") {
   };
 }
 
+async function analyzeContext() {
+  const t = getTranslation();
+  console.log(a.green.bold(`
+\u{1F50D} ${t("context.analyzing")}
+`));
+  const analysis = analyzeDirectory(process.cwd());
+  console.log(a.white(`${t("context.filesInContext")}: ${a.bold(analysis.files.length.toString())}`));
+  console.log(a.white(`${t("context.estimatedTokens")}: ${a.bold(analysis.totalTokens.toLocaleString())}`));
+  console.log(a.white(`${t("context.totalSize")}: ${a.bold(formatBytes(analysis.totalSize))}
+`));
+  if (analysis.largestFiles.length > 0) {
+    console.log(a.yellow(`${t("context.largestFiles")}:
+`));
+    for (const file of analysis.largestFiles.slice(0, 5)) {
+      const sizeStr = formatBytes(file.size);
+      const tokensStr = file.tokens.toLocaleString();
+      console.log(`  ${a.white(file.path)}`);
+      console.log(`    ${a.dim(`${t("context.size")}: ${sizeStr} | ${t("context.tokens")}: ${tokensStr}`)}`);
+    }
+    console.log();
+  }
+}
+async function showContextStatus() {
+  const t = getTranslation();
+  const memoryStatus = inspectMemoryFiles({ projectPath: process.cwd() });
+  console.log(a.green.bold(`
+\u{1F4CA} ${t("context.status")}
+`));
+  console.log(a.white(`Project: ${a.bold(process.cwd())}`));
+  const claudeMdPath = join(process.cwd(), "CLAUDE.md");
+  const hasClaudeMd = existsSync(claudeMdPath);
+  console.log(`${hasClaudeMd ? a.green("\u2713") : a.red("\u2717")} CLAUDE.md`);
+  if (hasClaudeMd) {
+    const stats = lstatSync(claudeMdPath);
+    const content = readFileSync(claudeMdPath, "utf-8");
+    const tokens = estimateTokens(content);
+    console.log(`  ${a.dim(`${t("context.size")}: ${formatBytes(stats.size)} | ${t("context.tokens")}: ${tokens.toLocaleString()}`)}`);
+  }
+  console.log();
+  const claudeIgnorePath = join(process.cwd(), ".claudeignore");
+  const hasIgnore = existsSync(claudeIgnorePath);
+  console.log(`${hasIgnore ? a.green("\u2713") : a.yellow("\u25CB")} .claudeignore`);
+  const contextFiles = findContextFiles(process.cwd());
+  console.log(`
+${a.white(`${t("context.additionalFiles")}: ${contextFiles.length}`)}
+`);
+  for (const file of contextFiles.slice(0, 10)) {
+    const tokens = estimateTokens(readFileSync(file, "utf-8"));
+    lstatSync(file).size;
+    console.log(`  ${a.white(file)} ${a.dim(`(${tokens.toLocaleString()} ${t("context.tokens")})`)}`);
+  }
+  if (contextFiles.length > 10) {
+    console.log(`  ${a.dim(`... and ${contextFiles.length - 10} more`)}`);
+  }
+  console.log(a.yellow("\nMemory\n"));
+  console.log(`  ${a.white(`State: ${describeMemorySyncState(memoryStatus.syncState)}`)}`);
+  console.log(`  ${a.dim(`Claude: ${memoryStatus.paths.claude}`)}`);
+  console.log(`  ${a.dim(`CCJK:   ${memoryStatus.paths.ccjk}`)}`);
+  if (memoryStatus.parseMode === "structured") {
+    console.log(`  ${a.dim(`Entries: ${memoryStatus.entryCount} | Facts: ${memoryStatus.factCount} | Patterns: ${memoryStatus.patternCount} | Decisions: ${memoryStatus.decisionCount}`)}`);
+  } else if (memoryStatus.parseMode === "freeform") {
+    console.log(`  ${a.dim("Structured parsing: freeform notes detected")}`);
+  } else {
+    console.log(`  ${a.dim("Structured parsing: no memory content found")}`);
+  }
+  console.log(a.yellow("\nNext Commands\n"));
+  console.log(`  ${a.white("ccjk context status")} ${a.dim("Review project context readiness")}`);
+  console.log(`  ${a.white("ccjk memory --status")} ${a.dim("Inspect Claude and CCJK memory files")}`);
+  console.log(`  ${a.white("ccjk memory --doctor")} ${a.dim("Run memory diagnostics and recommendations")}`);
+  console.log(`  ${a.white("ccjk context --show")} ${a.dim("Preview loaded context layers")}`);
+  console.log();
+}
+function describeMemorySyncState(syncState) {
+  switch (syncState) {
+    case "in-sync":
+      return "Claude and CCJK memory are in sync";
+    case "claude-only":
+      return "Only Claude memory has content";
+    case "ccjk-only":
+      return "Only CCJK memory has content";
+    case "claude-newer":
+      return "Claude memory is newer than the CCJK mirror";
+    case "ccjk-newer":
+      return "CCJK mirror is newer than Claude memory";
+    case "empty":
+      return "No project memory found";
+  }
+}
+async function compressContext() {
+  const t = getTranslation();
+  console.log(a.green.bold(`
+\u{1F5DC}\uFE0F  ${t("context.compressing")}
+`));
+  const analysis = analyzeDirectory(process.cwd());
+  const duplicates = findDuplicates(analysis.files);
+  const largeFiles = analysis.files.filter((f) => f.tokens > 1e3);
+  const binaryFiles = analysis.files.filter((f) => f.type === "binary");
+  let totalSavings = 0;
+  if (duplicates.length > 0) {
+    console.log(a.yellow(`${t("context.duplicatesFound")}: ${duplicates.length}
+`));
+    totalSavings += duplicates.length * 500;
+  }
+  if (largeFiles.length > 0) {
+    console.log(a.yellow(`${t("context.largeFiles")}: ${largeFiles.length}
+`));
+    for (const file of largeFiles.slice(0, 5)) {
+      console.log(`  ${a.white(file.path)} (${file.tokens.toLocaleString()} ${t("context.tokens")})`);
+    }
+    if (largeFiles.length > 5) {
+      console.log(`  ${a.dim(`... and ${largeFiles.length - 5} more`)}`);
+    }
+    console.log();
+    totalSavings += largeFiles.reduce((sum, f) => sum + Math.floor(f.tokens * 0.3), 0);
+  }
+  if (binaryFiles.length > 0) {
+    console.log(a.yellow(`${t("context.binaryFiles")}: ${binaryFiles.length}
+`));
+    console.log(a.dim(`${t("context.binaryNote")}
+`));
+    totalSavings += binaryFiles.length * 200;
+  }
+  if (totalSavings > 0) {
+    console.log(a.green(`${t("context.estimatedSavings")}: ${a.bold(totalSavings.toLocaleString())} ${t("context.tokens")}
+`));
+  } else {
+    console.log(a.dim(`${t("context.noCompressionNeeded")}
+`));
+  }
+}
+async function optimizeContext() {
+  const t = getTranslation();
+  console.log(a.green.bold(`
+\u26A1 ${t("context.optimizing")}
+`));
+  const analysis = analyzeDirectory(process.cwd());
+  const suggestions = [];
+  const largeFiles = analysis.files.filter((f) => f.tokens > 1e3);
+  if (largeFiles.length > 0) {
+    suggestions.push(`${t("context.suggestionLargeFiles")}: ${largeFiles.map((f) => f.path).join(", ")}`);
+  }
+  if (analysis.files.length > 20) {
+    suggestions.push(`${t("context.suggestionManyFiles")}: ${analysis.files.length}`);
+  }
+  if (!existsSync(join(process.cwd(), ".claudeignore"))) {
+    suggestions.push(t("context.suggestionClaudeignore"));
+  }
+  if (suggestions.length === 0) {
+    console.log(a.green(`${t("context.optimized")}
+`));
+  } else {
+    console.log(a.yellow(`${t("context.suggestions")}:
+`));
+    for (const suggestion of suggestions) {
+      console.log(`  \u2022 ${suggestion}`);
+    }
+    console.log();
+  }
+}
+function analyzeDirectory(dir) {
+  const files = [];
+  let totalTokens = 0;
+  let totalSize = 0;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (["node_modules", ".git", "dist", "build", ".next", "target"].includes(entry.name)) {
+          continue;
+        }
+        continue;
+      }
+      const filePath = join(dir, entry.name);
+      const fileType = getFileType(entry.name);
+      if (fileType === "binary") {
+        continue;
+      }
+      try {
+        const stats = lstatSync(filePath);
+        const content = readFileSync(filePath, "utf-8");
+        const tokens = estimateTokens(content);
+        files.push({
+          path: filePath,
+          size: stats.size,
+          tokens,
+          type: fileType
+        });
+        totalTokens += tokens;
+        totalSize += stats.size;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const largestFiles = [...files].sort((a, b) => b.tokens - a.tokens);
+  return {
+    files,
+    totalTokens,
+    totalSize,
+    largestFiles
+  };
+}
+function findContextFiles(dir) {
+  const contextFiles = [];
+  const contextPatterns = [
+    "CLAUDE.md",
+    "README.md",
+    "package.json",
+    "tsconfig.json",
+    ".gitignore",
+    ".claudeignore"
+  ];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (contextPatterns.includes(entry)) {
+        contextFiles.push(join(dir, entry));
+      }
+    }
+  } catch {
+  }
+  return contextFiles;
+}
+function findDuplicates(files) {
+  const seen = /* @__PURE__ */ new Map();
+  const duplicates = [];
+  for (const file of files) {
+    const name = file.path.split("/").pop() || file.path;
+    if (!seen.has(name)) {
+      seen.set(name, []);
+    }
+    seen.get(name).push(file);
+  }
+  for (const [, group] of seen) {
+    if (group.length > 1) {
+      duplicates.push(...group.slice(1));
+    }
+  }
+  return duplicates;
+}
+function getFileType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  if (["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "c", "cpp", "h", "hpp"].includes(ext || "")) {
+    return "code";
+  }
+  if (["md", "markdown", "txt"].includes(ext || "")) {
+    return "markdown";
+  }
+  if (["json", "yaml", "yml", "toml", "xml"].includes(ext || "")) {
+    return "text";
+  }
+  if (["png", "jpg", "jpeg", "gif", "ico", "pdf", "zip", "tar", "gz"].includes(ext || "")) {
+    return "binary";
+  }
+  return "text";
+}
+function estimateTokens(text) {
+  const chineseChars = (text.match(/[\u4E00-\u9FA5]/g) || []).length;
+  const nonChineseChars = text.length - chineseChars;
+  return Math.ceil(chineseChars / 2 + nonChineseChars / 4);
+}
+function formatBytes(bytes) {
+  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 `${Number.parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
+}
+async function handleContextCommand(args) {
+  const [action, ..._rest] = args;
+  switch (action) {
+    case "analyze":
+      await analyzeContext();
+      break;
+    case "status":
+      await showContextStatus();
+      break;
+    case "compress":
+      await compressContext();
+      break;
+    case "optimize":
+      await optimizeContext();
+      break;
+    default:
+      showContextHelp();
+  }
+}
+function showContextHelp() {
+  console.log(a.green.bold("\n\u{1F4DD} Context Commands\n"));
+  console.log(a.white("  ccjk context analyze   ") + a.dim("Analyze context usage"));
+  console.log(a.white("  ccjk context status    ") + a.dim("Show context status"));
+  console.log(a.white("  ccjk context compress  ") + a.dim("Compress context"));
+  console.log(a.white("  ccjk context optimize   ") + a.dim("Optimize context"));
+  console.log();
+}
+
 async function contextBuild(options = {}) {
   const {
     target: _target = "claude-code",
@@ -645,6 +956,10 @@ async function contextDoctor() {
   console.log("\n\u2705 Context health check complete");
 }
 async function contextCommand(options = {}) {
+  if (options.action && ["analyze", "compress", "optimize", "status"].includes(options.action)) {
+    await handleContextCommand([options.action]);
+    return;
+  }
   if (options.action === "refresh") {
     await contextRefresh();
     return;

package/dist/chunks/features.mjs

@@ -720,18 +720,18 @@ async function configureMergedPermissionsFeature() {
   }
 }
 async function configureMemoryFeature() {
-  const { AutoMemoryBridge } = await import('./auto-memory-bridge.mjs');
   const inquirer2 = (await import('./index3.mjs').then(function (n) { return n.c; })).default;
   const ansis2 = (await import('./index2.mjs')).default;
   const { execSync } = await import('node:child_process');
   const fs = await import('node:fs/promises');
-  const path = await import('node:path');
-  const os = await import('node:os');
+  const { getCcjkMemoryPath, getClaudeMemoryPath } = await import('./memory-paths.mjs');
+  const { inspectMemoryFiles, syncMemoryFiles } = await import('./memory-sync.mjs');
+  const { memoryCheck } = await import('./memory-check.mjs');
   console.log(ansis2.cyan(`
 ${i18n.t("memory:title")}`));
-  const bridge = new AutoMemoryBridge();
-  const claudeMemoryPath = path.join(os.homedir(), ".claude", "projects", "-Users-lu-ccjk-public", "memory", "MEMORY.md");
-  const ccjkMemoryPath = path.join(os.homedir(), ".ccjk", "memory", "MEMORY.md");
+  const projectPath = process__default.cwd();
+  const claudeMemoryPath = getClaudeMemoryPath(projectPath);
+  const ccjkMemoryPath = getCcjkMemoryPath(projectPath);
   let claudeMemoryExists = false;
   let ccjkMemoryExists = false;
   try {
@@ -756,6 +756,8 @@ ${ansis2.bold(i18n.t("memory:currentStatus"))}`);
       name: "action",
       message: i18n.t("memory:selectAction"),
       choices: [
+        { name: "Status", value: "status" },
+        { name: "Doctor", value: "doctor" },
         { name: i18n.t("memory:viewMemory"), value: "view" },
         { name: i18n.t("memory:editMemory"), value: "edit" },
         { name: i18n.t("memory:syncNow"), value: "sync" },
@@ -765,8 +767,34 @@ ${ansis2.bold(i18n.t("memory:currentStatus"))}`);
     }
   ]);
   switch (action) {
+    case "status": {
+      const inspection = inspectMemoryFiles({ projectPath });
+      console.log(ansis2.bold("\nMemory Status"));
+      console.log(ansis2.gray("\u2500".repeat(50)));
+      console.log(`State: ${inspection.syncState}`);
+      console.log(`Source: ${inspection.source}`);
+      console.log(`Claude: ${inspection.paths.claude}`);
+      console.log(`CCJK:   ${inspection.paths.ccjk}`);
+      console.log(`Entries: ${inspection.entryCount}`);
+      console.log(ansis2.gray("\u2500".repeat(50)));
+      break;
+    }
+    case "doctor": {
+      const health = await memoryCheck.check();
+      console.log(ansis2.bold("\nMemory Doctor"));
+      console.log(ansis2.gray("\u2500".repeat(50)));
+      console.log(`${health.message} (${health.score}/100)`);
+      for (const detail of health.details || []) {
+        console.log(detail);
+      }
+      if (health.fix) {
+        console.log(ansis2.yellow(`Fix: ${health.fix}`));
+      }
+      console.log(ansis2.gray("\u2500".repeat(50)));
+      break;
+    }
     case "view": {
-      const memoryPath = path.join(os.homedir(), ".claude", "projects", "-Users-lu-ccjk-public", "memory", "MEMORY.md");
+      const memoryPath = getClaudeMemoryPath(projectPath);
       try {
         const content = await fs.readFile(memoryPath, "utf-8");
         console.log(`
@@ -780,7 +808,7 @@ ${ansis2.bold(i18n.t("memory:memoryContent"))}`);
       break;
     }
     case "edit": {
-      const memoryPath = path.join(os.homedir(), ".claude", "projects", "-Users-lu-ccjk-public", "memory", "MEMORY.md");
+      const memoryPath = getClaudeMemoryPath(projectPath);
       const editor = process__default.env.EDITOR || "nano";
       try {
         execSync(`${editor} "${memoryPath}"`, { stdio: "inherit" });
@@ -793,7 +821,7 @@ ${ansis2.bold(i18n.t("memory:memoryContent"))}`);
     case "sync": {
       console.log(ansis2.cyan(i18n.t("memory:syncing")));
       try {
-        await bridge.syncToClaude();
+        syncMemoryFiles({ projectPath });
         console.log(ansis2.green(i18n.t("memory:syncComplete")));
       } catch (error) {
         console.log(ansis2.red(i18n.t("memory:syncError")));

package/dist/chunks/index4.mjs

@@ -1,4 +1,4 @@
-export { r as runHealthCheck } from '../shared/ccjk.Crd_nEfj.mjs';
+export { r as runHealthCheck } from '../shared/ccjk.xkKNsC02.mjs';
 import 'node:fs';
 import './constants.mjs';
 import 'node:os';
@@ -6,6 +6,7 @@ import './index5.mjs';
 import 'node:process';
 import 'node:url';
 import '../shared/ccjk.bQ7Dh1g4.mjs';
+import './memory-check.mjs';
 import 'node:path';
 import '../shared/ccjk.BAGoDD49.mjs';
 import 'fs';
@@ -14,3 +15,9 @@ import 'stream';
 import 'util';
 import 'assert';
 import 'path';
+import './memory-paths.mjs';
+import '../shared/ccjk.BBtCGd_g.mjs';
+import './index6.mjs';
+import './fs-operations.mjs';
+import 'node:crypto';
+import 'node:fs/promises';