ccjk 13.5.2 → 13.5.4

package/dist/chunks/memory-paths.mjs

@@ -0,0 +1,259 @@
+import { resolve } from 'node:path';
+import { CCJK_CONFIG_FILE, SUPPORTED_LANGS, DEFAULT_CODE_TOOL_TYPE, CCJK_CONFIG_DIR, CLAUDE_DIR } from './constants.mjs';
+import { p as parse } from '../shared/ccjk.BBtCGd_g.mjs';
+import { stringify } from './index6.mjs';
+import { exists, readFile, ensureDir, writeFileAtomic } from './fs-operations.mjs';
+import { d as dirname, j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
+import 'node:os';
+import './index5.mjs';
+import 'node:fs';
+import 'node:process';
+import 'node:url';
+import 'node:crypto';
+import 'node:fs/promises';
+
+const DEFAULT_CONFIG_VERSION = "4.0.0";
+function createDefaultCcjkConfig(preferredLang = "en", claudeCodeInstallType = "global") {
+  return {
+    version: DEFAULT_CONFIG_VERSION,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      preferredLang,
+      templateLang: preferredLang,
+      aiOutputLang: preferredLang === "zh-CN" ? "zh-CN" : void 0,
+      currentTool: DEFAULT_CODE_TOOL_TYPE
+    },
+    tools: {
+      claudeCode: {
+        enabled: true,
+        installType: claudeCodeInstallType,
+        outputStyles: ["speed-coder", "senior-architect", "pair-programmer"],
+        defaultOutputStyle: "senior-architect",
+        currentProfile: "",
+        profiles: {}
+      },
+      codex: {
+        enabled: false,
+        systemPromptStyle: "senior-architect"
+      }
+    },
+    storage: {
+      memory: {}
+    }
+  };
+}
+function readCcjkConfig(configPath = CCJK_CONFIG_FILE) {
+  try {
+    if (!exists(configPath)) {
+      return null;
+    }
+    const content = readFile(configPath);
+    const parsed = parse(content);
+    return convertTomlToCcjkConfig(parsed);
+  } catch (error) {
+    console.error(`Failed to read CCJK config from ${configPath}:`, error);
+    return null;
+  }
+}
+function writeCcjkConfig(config, configPath = CCJK_CONFIG_FILE) {
+  try {
+    const configDir = dirname(configPath);
+    ensureDir(configDir);
+    config.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    const tomlContent = stringify(config);
+    writeFileAtomic(configPath, tomlContent);
+  } catch (error) {
+    console.error(`Failed to write CCJK config to ${configPath}:`, error);
+    throw new Error(`Failed to write CCJK config: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function updateCcjkConfig(updates, configPath = CCJK_CONFIG_FILE) {
+  const existingConfig = readCcjkConfig(configPath) || createDefaultCcjkConfig();
+  const updatedConfig = {
+    version: updates.version || existingConfig.version,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      ...existingConfig.general,
+      ...updates.general
+    },
+    tools: {
+      ...existingConfig.tools,
+      ...updates.tools,
+      claudeCode: {
+        ...existingConfig.tools.claudeCode,
+        ...updates.tools?.claudeCode
+      },
+      codex: {
+        ...existingConfig.tools.codex,
+        ...updates.tools?.codex
+      }
+    },
+    storage: {
+      ...existingConfig.storage,
+      ...updates.storage,
+      memory: {
+        ...existingConfig.storage.memory,
+        ...updates.storage?.memory
+      }
+    }
+  };
+  writeCcjkConfig(updatedConfig, configPath);
+  return updatedConfig;
+}
+function getCcjkConfig(configPath = CCJK_CONFIG_FILE) {
+  const config = readCcjkConfig(configPath);
+  return config || createDefaultCcjkConfig();
+}
+function validateCcjkConfig(config) {
+  const errors = [];
+  if (!config || typeof config !== "object") {
+    return { valid: false, errors: ["Configuration must be an object"] };
+  }
+  const cfg = config;
+  if (!cfg.version || typeof cfg.version !== "string") {
+    errors.push("Invalid or missing version");
+  }
+  if (!cfg.general || typeof cfg.general !== "object") {
+    errors.push("Invalid or missing general section");
+  } else {
+    if (!cfg.general.preferredLang || !SUPPORTED_LANGS.includes(cfg.general.preferredLang)) {
+      errors.push(`Invalid preferredLang: ${cfg.general.preferredLang}`);
+    }
+    if (cfg.general.templateLang && !SUPPORTED_LANGS.includes(cfg.general.templateLang)) {
+      errors.push(`Invalid templateLang: ${cfg.general.templateLang}`);
+    }
+  }
+  if (!cfg.tools || typeof cfg.tools !== "object") {
+    errors.push("Invalid or missing tools section");
+  } else {
+    if (!cfg.tools.claudeCode || typeof cfg.tools.claudeCode !== "object") {
+      errors.push("Invalid or missing claudeCode tool config");
+    }
+    if (!cfg.tools.codex || typeof cfg.tools.codex !== "object") {
+      errors.push("Invalid or missing codex tool config");
+    }
+  }
+  if (!cfg.storage || typeof cfg.storage !== "object") {
+    errors.push("Invalid or missing storage section");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function convertTomlToCcjkConfig(tomlConfig) {
+  if (!tomlConfig) {
+    return null;
+  }
+  return {
+    version: tomlConfig.version || DEFAULT_CONFIG_VERSION,
+    lastUpdated: tomlConfig.lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      preferredLang: tomlConfig.general?.preferredLang || "en",
+      templateLang: tomlConfig.general?.templateLang,
+      aiOutputLang: tomlConfig.general?.aiOutputLang,
+      currentTool: tomlConfig.general?.currentTool || DEFAULT_CODE_TOOL_TYPE
+    },
+    tools: {
+      claudeCode: {
+        enabled: tomlConfig.claudeCode?.enabled ?? true,
+        installType: tomlConfig.claudeCode?.installType || "global",
+        installMethod: tomlConfig.claudeCode?.installMethod,
+        outputStyles: tomlConfig.claudeCode?.outputStyles || [],
+        defaultOutputStyle: tomlConfig.claudeCode?.defaultOutputStyle,
+        currentProfile: tomlConfig.claudeCode?.currentProfile || "",
+        profiles: tomlConfig.claudeCode?.profiles || {},
+        version: tomlConfig.claudeCode?.version
+      },
+      codex: {
+        enabled: tomlConfig.codex?.enabled ?? false,
+        systemPromptStyle: tomlConfig.codex?.systemPromptStyle || "senior-architect",
+        installMethod: tomlConfig.codex?.installMethod,
+        envKeyMigrated: tomlConfig.codex?.envKeyMigrated
+      }
+    },
+    storage: {
+      memory: {
+        claudeDir: tomlConfig.storage?.memory?.claudeDir,
+        ccjkDir: tomlConfig.storage?.memory?.ccjkDir
+      }
+    }
+  };
+}
+
+const config = {
+  /**
+   * CCJK Configuration (~/.ccjk/config.toml)
+   */
+  ccjk: {
+    /**
+     * Read CCJK configuration
+     */
+    read: readCcjkConfig,
+    /**
+     * Write CCJK configuration
+     */
+    write: writeCcjkConfig,
+    /**
+     * Update CCJK configuration with partial changes
+     */
+    update: updateCcjkConfig,
+    /**
+     * Get or create CCJK configuration (with defaults)
+     */
+    get: getCcjkConfig,
+    /**
+     * Create default CCJK configuration
+     */
+    createDefault: createDefaultCcjkConfig,
+    /**
+     * Validate CCJK configuration
+     */
+    validate: validateCcjkConfig
+  }};
+
+function getMemoryDirectoryOverrides() {
+  const ccjkConfig = config.ccjk.read();
+  return {
+    claudeDir: ccjkConfig?.storage?.memory?.claudeDir,
+    ccjkDir: ccjkConfig?.storage?.memory?.ccjkDir
+  };
+}
+function resolveClaudeDir(claudeDir) {
+  return normalizeProjectPath(claudeDir || getMemoryDirectoryOverrides().claudeDir || CLAUDE_DIR);
+}
+function resolveCcjkDir(ccjkDir) {
+  return normalizeProjectPath(ccjkDir || getMemoryDirectoryOverrides().ccjkDir || CCJK_CONFIG_DIR);
+}
+function normalizeProjectPath(projectPath) {
+  return resolve(projectPath).replace(/\\/g, "/");
+}
+function toClaudeProjectDirName(projectPath) {
+  const normalizedPath = normalizeProjectPath(projectPath).replace(/^\/+/, "");
+  return `-${normalizedPath.replace(/[:/]/g, "-")}`;
+}
+function getClaudeMemoryPath(projectPath, claudeDir) {
+  const resolvedClaudeDir = resolveClaudeDir(claudeDir);
+  if (projectPath) {
+    return join(resolvedClaudeDir, "projects", toClaudeProjectDirName(projectPath), "memory", "MEMORY.md");
+  }
+  return join(resolvedClaudeDir, "memory", "MEMORY.md");
+}
+function getCcjkMemoryPath(projectPath, ccjkDir) {
+  const resolvedCcjkDir = resolveCcjkDir(ccjkDir);
+  if (projectPath) {
+    return join(resolvedCcjkDir, "memory", "projects", toClaudeProjectDirName(projectPath), "MEMORY.md");
+  }
+  return join(resolvedCcjkDir, "memory", "global", "MEMORY.md");
+}
+function getClaudeProjectsDir(claudeDir) {
+  return join(resolveClaudeDir(claudeDir), "projects");
+}
+function getConfiguredMemoryDirectories() {
+  return {
+    claudeDir: resolveClaudeDir(),
+    ccjkDir: resolveCcjkDir()
+  };
+}
+
+export { getCcjkMemoryPath, getClaudeMemoryPath, getClaudeProjectsDir, getConfiguredMemoryDirectories, normalizeProjectPath, toClaudeProjectDirName };

package/dist/chunks/memory-sync.mjs

@@ -0,0 +1,209 @@
+import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import 'node:fs/promises';
+import { normalizeProjectPath, getCcjkMemoryPath, getClaudeMemoryPath } from './memory-paths.mjs';
+import './constants.mjs';
+import 'node:os';
+import './index5.mjs';
+import 'node:process';
+import 'node:url';
+import '../shared/ccjk.bQ7Dh1g4.mjs';
+import '../shared/ccjk.BBtCGd_g.mjs';
+import './index6.mjs';
+import './fs-operations.mjs';
+import 'node:crypto';
+
+function parseAutoMemory(content) {
+  const lines = content.split("\n");
+  const entries = [];
+  let currentEntry = null;
+  for (const line of lines) {
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headerMatch) {
+      if (currentEntry && currentEntry.content.length > 0) {
+        entries.push(currentEntry);
+      }
+      currentEntry = {
+        title: headerMatch[2].trim(),
+        content: [],
+        level: headerMatch[1].length
+      };
+    } else if (currentEntry && line.trim()) {
+      currentEntry.content.push(line);
+    }
+  }
+  if (currentEntry && currentEntry.content.length > 0) {
+    entries.push(currentEntry);
+  }
+  return entries;
+}
+function autoMemoryToBrainContext(entries, projectPath) {
+  const context = {
+    facts: [],
+    patterns: [],
+    decisions: [],
+    metadata: {
+      source: "auto-memory",
+      projectPath,
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  for (const entry of entries) {
+    const contentText = entry.content.join("\n").trim();
+    const titleLower = entry.title.toLowerCase();
+    if (titleLower.includes("architecture") || titleLower.includes("pattern") || titleLower.includes("design")) {
+      context.patterns.push({
+        name: entry.title,
+        description: contentText,
+        category: "architecture"
+      });
+    } else if (titleLower.includes("decision") || titleLower.includes("choice") || titleLower.includes("why")) {
+      context.decisions.push({
+        decision: entry.title,
+        rationale: contentText,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else {
+      context.facts.push({
+        key: entry.title,
+        value: contentText,
+        confidence: 0.9
+      });
+    }
+  }
+  return context;
+}
+
+function readMemorySnapshot(path) {
+  if (!existsSync(path)) {
+    return {
+      path,
+      content: "",
+      exists: false,
+      hasContent: false,
+      sizeBytes: 0,
+      mtimeMs: 0
+    };
+  }
+  const stats = statSync(path);
+  const content = readFileSync(path, "utf-8");
+  return {
+    path,
+    content,
+    exists: true,
+    hasContent: content.trim().length > 0,
+    sizeBytes: stats.size,
+    mtimeMs: stats.mtimeMs
+  };
+}
+function writeMemorySnapshot(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf-8");
+}
+function summarizeMemoryContent(content, projectPath) {
+  if (!content.trim()) {
+    return {
+      parseMode: "empty",
+      entryCount: 0,
+      factCount: 0,
+      patternCount: 0,
+      decisionCount: 0
+    };
+  }
+  const entries = parseAutoMemory(content);
+  if (entries.length === 0) {
+    return {
+      parseMode: "freeform",
+      entryCount: 0,
+      factCount: 0,
+      patternCount: 0,
+      decisionCount: 0
+    };
+  }
+  const context = autoMemoryToBrainContext(entries, projectPath || "global");
+  return {
+    parseMode: "structured",
+    entryCount: entries.length,
+    factCount: context.facts.length,
+    patternCount: context.patterns.length,
+    decisionCount: context.decisions.length
+  };
+}
+function inspectSnapshots(claudeSnapshot, ccjkSnapshot, projectPath) {
+  let source = "none";
+  let sourceContent = "";
+  let syncState = "empty";
+  if (claudeSnapshot.hasContent || ccjkSnapshot.hasContent) {
+    if (claudeSnapshot.hasContent && ccjkSnapshot.hasContent && claudeSnapshot.content === ccjkSnapshot.content) {
+      source = "already-synced";
+      sourceContent = claudeSnapshot.content;
+      syncState = "in-sync";
+    } else if (claudeSnapshot.hasContent && !ccjkSnapshot.hasContent) {
+      source = "claude";
+      sourceContent = claudeSnapshot.content;
+      syncState = "claude-only";
+    } else if (ccjkSnapshot.hasContent && !claudeSnapshot.hasContent) {
+      source = "ccjk";
+      sourceContent = ccjkSnapshot.content;
+      syncState = "ccjk-only";
+    } else if (claudeSnapshot.mtimeMs >= ccjkSnapshot.mtimeMs) {
+      source = "claude";
+      sourceContent = claudeSnapshot.content;
+      syncState = "claude-newer";
+    } else {
+      source = "ccjk";
+      sourceContent = ccjkSnapshot.content;
+      syncState = "ccjk-newer";
+    }
+  }
+  return {
+    source,
+    syncState,
+    snapshots: {
+      claude: {
+        exists: claudeSnapshot.exists,
+        hasContent: claudeSnapshot.hasContent,
+        sizeBytes: claudeSnapshot.sizeBytes,
+        mtimeMs: claudeSnapshot.mtimeMs
+      },
+      ccjk: {
+        exists: ccjkSnapshot.exists,
+        hasContent: ccjkSnapshot.hasContent,
+        sizeBytes: ccjkSnapshot.sizeBytes,
+        mtimeMs: ccjkSnapshot.mtimeMs
+      }
+    },
+    ...summarizeMemoryContent(sourceContent, projectPath)
+  };
+}
+function inspectMemoryFiles(options = {}) {
+  const projectPath = options.projectPath ? normalizeProjectPath(options.projectPath) : void 0;
+  const paths = {
+    claude: getClaudeMemoryPath(projectPath, options.claudeDir),
+    ccjk: getCcjkMemoryPath(projectPath, options.ccjkDir)
+  };
+  const claudeSnapshot = readMemorySnapshot(paths.claude);
+  const ccjkSnapshot = readMemorySnapshot(paths.ccjk);
+  return {
+    scope: projectPath ? "project" : "global",
+    paths,
+    ...inspectSnapshots(claudeSnapshot, ccjkSnapshot, projectPath)
+  };
+}
+function syncMemoryFiles(options = {}) {
+  const inspection = inspectMemoryFiles(options);
+  const updatedTargets = [];
+  if (inspection.source === "claude" && inspection.syncState !== "in-sync") {
+    writeMemorySnapshot(inspection.paths.ccjk, readFileSync(inspection.paths.claude, "utf-8"));
+    updatedTargets.push("ccjk");
+  } else if (inspection.source === "ccjk" && inspection.syncState !== "in-sync") {
+    writeMemorySnapshot(inspection.paths.claude, readFileSync(inspection.paths.ccjk, "utf-8"));
+    updatedTargets.push("claude");
+  }
+  return {
+    ...inspection,
+    updatedTargets
+  };
+}
+
+export { inspectMemoryFiles, syncMemoryFiles };

package/dist/chunks/memory.mjs

@@ -1,10 +1,10 @@
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import a from './index2.mjs';
 import { i as inquirer } from './index3.mjs';
 import { x as K } from './main.mjs';
-import { AutoMemoryBridge } from './auto-memory-bridge.mjs';
-import { CLAUDE_DIR } from './constants.mjs';
+import { getClaudeMemoryPath } from './memory-paths.mjs';
+import { memoryCheck } from './memory-check.mjs';
+import { inspectMemoryFiles, syncMemoryFiles } from './memory-sync.mjs';
 import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
 import '../shared/ccjk.BAGoDD49.mjs';
 import 'node:readline';
@@ -18,26 +18,118 @@ import 'tty';
 import 'fs';
 import 'child_process';
 import 'node:path';
+import 'node:os';
 import 'node:crypto';
 import 'buffer';
 import 'string_decoder';
 import 'module';
 import 'node:child_process';
 import 'node:stream';
-import 'node:fs/promises';
+import './constants.mjs';
 import './index5.mjs';
 import 'node:url';
+import '../shared/ccjk.BBtCGd_g.mjs';
+import './index6.mjs';
+import './fs-operations.mjs';
+import 'node:fs/promises';
+import 'constants';
+import 'util';
+import 'assert';
+import 'path';
 
-function getClaudeDir() {
-  return join(homedir(), CLAUDE_DIR);
+function formatTimestamp(timestampMs) {
+  if (!timestampMs) {
+    return "never";
+  }
+  return new Date(timestampMs).toISOString();
 }
-function getMemoryPath(projectPath) {
-  const claudeDir = getClaudeDir();
-  if (projectPath) {
-    const projectHash = Buffer.from(projectPath).toString("base64").replace(/[/+=]/g, "_");
-    return join(claudeDir, "projects", projectHash, "memory", "MEMORY.md");
+function formatSize(sizeBytes) {
+  return `${(sizeBytes / 1024).toFixed(2)} KB`;
+}
+function describeSyncState(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 memory content found";
+  }
+}
+async function showMemoryStatus(projectPath) {
+  const result = inspectMemoryFiles({ projectPath });
+  console.log(a.cyan.bold("\n\u{1F4CA} Memory Status"));
+  console.log(a.gray(`Scope:   ${result.scope}`));
+  console.log(a.gray(`State:   ${describeSyncState(result.syncState)}`));
+  console.log(a.gray(`Source:  ${result.source}`));
+  console.log(a.gray(`Claude:  ${result.paths.claude}`));
+  console.log(a.gray(`CCJK:    ${result.paths.ccjk}`));
+  console.log("");
+  console.log(a.bold("Claude Memory"));
+  console.log(a.gray(`  Exists:   ${result.snapshots.claude.exists ? "yes" : "no"}`));
+  console.log(a.gray(`  Content:  ${result.snapshots.claude.hasContent ? "yes" : "no"}`));
+  console.log(a.gray(`  Size:     ${formatSize(result.snapshots.claude.sizeBytes)}`));
+  console.log(a.gray(`  Updated:  ${formatTimestamp(result.snapshots.claude.mtimeMs)}`));
+  console.log(a.bold("\nCCJK Mirror"));
+  console.log(a.gray(`  Exists:   ${result.snapshots.ccjk.exists ? "yes" : "no"}`));
+  console.log(a.gray(`  Content:  ${result.snapshots.ccjk.hasContent ? "yes" : "no"}`));
+  console.log(a.gray(`  Size:     ${formatSize(result.snapshots.ccjk.sizeBytes)}`));
+  console.log(a.gray(`  Updated:  ${formatTimestamp(result.snapshots.ccjk.mtimeMs)}`));
+  if (result.parseMode === "structured") {
+    console.log(a.bold("\nStructured Summary"));
+    console.log(a.gray(`  Entries:    ${result.entryCount}`));
+    console.log(a.gray(`  Facts:      ${result.factCount}`));
+    console.log(a.gray(`  Patterns:   ${result.patternCount}`));
+    console.log(a.gray(`  Decisions:  ${result.decisionCount}`));
+  } else if (result.parseMode === "freeform") {
+    console.log(a.bold("\nStructured Summary"));
+    console.log(a.gray("  Freeform notes detected; no structured headings parsed"));
+  }
+  console.log("");
+}
+async function runMemoryDoctor(projectPath) {
+  const result = inspectMemoryFiles({ projectPath });
+  const health = await memoryCheck.check();
+  console.log(a.cyan.bold("\n\u{1FA7A} Memory Doctor"));
+  console.log(a.gray(`Project state: ${describeSyncState(result.syncState)}`));
+  console.log(a.gray(`Health score:  ${health.score}/100 (${health.status})`));
+  console.log(a.gray(`Summary:       ${health.message}`));
+  if (health.details && health.details.length > 0) {
+    console.log(a.bold("\nHealth Details"));
+    for (const detail of health.details) {
+      console.log(a.gray(`  ${detail}`));
+    }
+  }
+  const recommendations = [];
+  if (result.syncState === "claude-newer" || result.syncState === "ccjk-newer" || result.syncState === "claude-only" || result.syncState === "ccjk-only") {
+    recommendations.push("Run `ccjk memory --sync` to reconcile Claude memory and the CCJK mirror");
+  }
+  if (result.syncState === "empty") {
+    recommendations.push("Add project memory with `ccjk memory --edit` before relying on sync or doctor checks");
+  }
+  if (health.fix) {
+    recommendations.push(health.fix);
   }
-  return join(claudeDir, "memory", "MEMORY.md");
+  if (recommendations.length > 0) {
+    console.log(a.bold("\nRecommendations"));
+    for (const recommendation of recommendations) {
+      console.log(a.gray(`  - ${recommendation}`));
+    }
+  }
+  if (health.command) {
+    console.log(a.bold("\nSuggested Command"));
+    console.log(a.gray(`  ${health.command}`));
+  }
+  console.log("");
+}
+function getMemoryPath(projectPath) {
+  return getClaudeMemoryPath(projectPath);
 }
 function readMemory(memoryPath) {
   if (!existsSync(memoryPath)) {
@@ -151,20 +243,43 @@ ${formattedContent}` : formattedContent;
     console.log(a.green("\u2713 Memory replaced"));
   }
 }
-async function syncMemory(_projectPath) {
+async function syncMemory(projectPath) {
   console.log(a.cyan("\nSyncing memory with AutoMemoryBridge..."));
   try {
-    const _bridge = new AutoMemoryBridge({});
-    console.log(a.yellow("\u26A0 AutoMemoryBridge sync not yet implemented"));
-    console.log(a.green("\u2713 Memory sync placeholder executed"));
+    const result = syncMemoryFiles({ projectPath });
+    if (result.source === "none") {
+      console.log(a.yellow("\u26A0 No memory content found in Claude or CCJK storage"));
+      console.log(a.gray(`  Claude: ${result.paths.claude}`));
+      console.log(a.gray(`  CCJK:   ${result.paths.ccjk}`));
+      return;
+    }
+    const sourceLabel = result.source === "already-synced" ? "Claude and CCJK memory" : `${result.source === "claude" ? "Claude" : "CCJK"} memory`;
+    const targetLabel = result.updatedTargets.length === 0 ? "already in sync" : `updated ${result.updatedTargets.map((target) => target === "claude" ? "Claude" : "CCJK").join(", ")}`;
+    console.log(a.green(`\u2713 Synced ${sourceLabel} (${targetLabel})`));
+    console.log(a.gray(`  Claude: ${result.paths.claude}`));
+    console.log(a.gray(`  CCJK:   ${result.paths.ccjk}`));
+    if (result.parseMode === "structured") {
+      console.log(a.gray(
+        `  Structured entries: ${result.entryCount} (facts ${result.factCount}, patterns ${result.patternCount}, decisions ${result.decisionCount})`
+      ));
+    } else if (result.parseMode === "freeform") {
+      console.log(a.gray("  Synced freeform notes (no structured headings detected)"));
+    }
   } catch (error) {
     console.error(a.red("Failed to sync memory:"), error);
     throw error;
   }
 }
 async function memoryCommand(options) {
-  options.project || process.cwd();
   const memoryPath = getMemoryPath(options.project);
+  if (options.status) {
+    await showMemoryStatus(options.project);
+    return;
+  }
+  if (options.doctor) {
+    await runMemoryDoctor(options.project);
+    return;
+  }
   if (options.view) {
     const content = readMemory(memoryPath);
     const title = options.project ? `Project Memory: ${options.project}` : "Global Memory";
@@ -188,6 +303,8 @@ async function memoryCommand(options) {
       name: "action",
       message: "What would you like to do?",
       choices: [
+        { name: "\u{1F4CA} Status", value: "status" },
+        { name: "\u{1FA7A} Doctor", value: "doctor" },
         { name: "\u{1F441}\uFE0F  View memory", value: "view" },
         { name: "\u270F\uFE0F  Edit memory", value: "edit" },
         { name: "\u{1F504} Sync memory (AutoMemoryBridge)", value: "sync" },
@@ -197,6 +314,12 @@ async function memoryCommand(options) {
     }
   ]);
   switch (action) {
+    case "status":
+      await showMemoryStatus(options.project);
+      break;
+    case "doctor":
+      await runMemoryDoctor(options.project);
+      break;
     case "view": {
       const content = readMemory(memoryPath);
       const title = options.project ? `Project Memory: ${options.project}` : "Global Memory";

package/dist/chunks/menu-hierarchical.mjs

@@ -21,7 +21,7 @@ import 'string_decoder';
 import 'node:fs';
 import 'node:url';
 import '../shared/ccjk.bQ7Dh1g4.mjs';
-import '../shared/ccjk.0aJQmVxS.mjs';
+import '../shared/ccjk.miT0g_vA.mjs';
 import 'node:child_process';
 import './constants.mjs';
 import './banner.mjs';
@@ -81,7 +81,7 @@ import './uninstall.mjs';
 import '../shared/ccjk.CvChMYvB.mjs';
 import 'globby';
 import './update.mjs';
-import '../shared/ccjk.LTONy3IS.mjs';
+import '../shared/ccjk.BOfPON0N.mjs';
 
 function renderMenuHeader(context, _isZh) {
   const title = context.breadcrumb.join(i18n.t("menu:menu.breadcrumb.separator"));