ccjk 14.2.2 → 15.0.0

package/dist/chunks/memory-paths.mjs

@@ -1,259 +0,0 @@
-import { resolve } from 'node:path';
-import { p as parse } from '../shared/ccjk.BBtCGd_g.mjs';
-import { stringify } from './index3.mjs';
-import { CCJK_CONFIG_FILE, SUPPORTED_LANGS, DEFAULT_CODE_TOOL_TYPE, CCJK_CONFIG_DIR, CLAUDE_DIR } from './constants.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 './index2.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

@@ -1,209 +0,0 @@
-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 '../shared/ccjk.BBtCGd_g.mjs';
-import './index3.mjs';
-import './constants.mjs';
-import 'node:os';
-import './index2.mjs';
-import 'node:process';
-import 'node:url';
-import '../shared/ccjk.bQ7Dh1g4.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 };