gencode-ai 0.2.0 → 0.3.0

package/dist/memory/memory-manager.js

@@ -2,18 +2,18 @@
  * Memory Manager - Core memory system implementation
  *
  * Implements Claude Code compatible memory loading with merge semantics:
- * At each level, both .gencode and .claude directories are loaded.
- * Content from .gencode appears later in the context (higher priority for LLM).
+ * At each level, both .gen and .claude directories are loaded.
+ * Content from .gen appears later in the context (higher priority for LLM).
  *
  * Loading order within each level:
  * 1. .claude files first (lower priority - LLM sees earlier)
- * 2. .gencode files second (higher priority - LLM sees later)
+ * 2. .gen files second (higher priority - LLM sees later)
  *
  * Level loading order:
  * 1. Enterprise (system-wide managed, enforced)
- * 2. User (~/.gencode/ + ~/.claude/)
+ * 2. User (~/.gen/ + ~/.claude/)
  * 3. User Rules
- * 4. Extra (GENCODE_CONFIG_DIRS)
+ * 4. Extra (GEN_CONFIG)
  * 5. Project (recursive upward search)
  * 6. Project Rules
  * 7. Local (*.local.md files)
@@ -25,7 +25,7 @@ import { glob } from 'glob';
 import { ImportResolver } from './import-resolver.js';
 import { parseRuleFrontmatter, activateRules } from './rules-parser.js';
 import { DEFAULT_MEMORY_CONFIG } from './types.js';
-import { getManagedPaths, GENCODE_CONFIG_DIRS_ENV } from '../config/types.js';
+import { getManagedPaths, GEN_CONFIG_ENV } from '../config/types.js';
 export class MemoryManager {
     config;
     importResolver;
@@ -39,18 +39,19 @@ export class MemoryManager {
      * Load all memory files for the given working directory
      */
     async load(options) {
-        const { cwd, currentFile } = options;
+        const { cwd, currentFile, strategy = 'fallback' } = options;
         const files = [];
         const rules = [];
         const errors = [];
         const sources = [];
+        const skippedFiles = [];
         let totalSize = 0;
         this.importResolver.reset();
         const projectRoot = await this.findProjectRoot(cwd);
         this.importResolver.setProjectRoot(projectRoot);
         // 1. Load enterprise memory (system-wide, enforced)
-        const enterpriseFiles = await this.loadEnterpriseMemory();
-        for (const file of enterpriseFiles) {
+        const enterpriseResult = await this.loadEnterpriseMemory(strategy);
+        for (const file of enterpriseResult.files) {
             files.push(file);
             totalSize += file.content.length;
             sources.push({
@@ -61,8 +62,10 @@ export class MemoryManager {
                 size: file.content.length,
             });
         }
-        // 2. Load user-level memory (both claude and gencode)
-        const userFiles = await this.loadUserMemory();
+        skippedFiles.push(...enterpriseResult.skipped);
+        // 2. Load user-level memory (both claude and gen)
+        const userResult = await this.loadUserMemory(strategy);
+        const userFiles = userResult.files;
         for (const file of userFiles) {
             if (totalSize + file.content.length <= this.config.maxTotalSize) {
                 files.push(file);
@@ -79,7 +82,8 @@ export class MemoryManager {
                 errors.push(`Skipped ${file.path}: would exceed max total size`);
             }
         }
-        // 3. Load user-level rules (both claude and gencode)
+        skippedFiles.push(...userResult.skipped);
+        // 3. Load user-level rules (both claude and gen)
         const userRules = await this.loadUserRules();
         for (const rule of userRules) {
             rules.push(rule);
@@ -92,7 +96,8 @@ export class MemoryManager {
             });
         }
         // 4. Load extra config dirs memory
-        const extraFiles = await this.loadExtraMemory();
+        const extraResult = await this.loadExtraMemory(strategy);
+        const extraFiles = extraResult.files;
         for (const file of extraFiles) {
             if (totalSize + file.content.length <= this.config.maxTotalSize) {
                 files.push(file);
@@ -109,8 +114,10 @@ export class MemoryManager {
                 errors.push(`Skipped ${file.path}: would exceed max total size`);
             }
         }
-        // 5. Load project-level memory (both claude and gencode, recursive upward)
-        const projectFiles = await this.loadProjectMemory(cwd, projectRoot);
+        skippedFiles.push(...extraResult.skipped);
+        // 5. Load project-level memory (both claude and gen, recursive upward)
+        const projectResult = await this.loadProjectMemory(cwd, projectRoot, strategy);
+        const projectFiles = projectResult.files;
         for (const file of projectFiles) {
             if (totalSize + file.content.length <= this.config.maxTotalSize) {
                 files.push(file);
@@ -127,7 +134,8 @@ export class MemoryManager {
                 errors.push(`Skipped ${file.path}: would exceed max total size`);
             }
         }
-        // 6. Load project-level rules (both claude and gencode)
+        skippedFiles.push(...projectResult.skipped);
+        // 6. Load project-level rules (both claude and gen)
         const projectRules = await this.loadProjectRules(projectRoot);
         for (const rule of projectRules) {
             rules.push(rule);
@@ -139,8 +147,9 @@ export class MemoryManager {
                 size: rule.content.length,
             });
         }
-        // 7. Load local memory (both claude and gencode)
-        const localFiles = await this.loadLocalMemory(projectRoot);
+        // 7. Load local memory (both claude and gen)
+        const localResult = await this.loadLocalMemory(projectRoot, strategy);
+        const localFiles = localResult.files;
         for (const file of localFiles) {
             if (totalSize + file.content.length <= this.config.maxTotalSize) {
                 files.push(file);
@@ -157,6 +166,7 @@ export class MemoryManager {
                 errors.push(`Skipped ${file.path}: would exceed max total size`);
             }
         }
+        skippedFiles.push(...localResult.skipped);
         // Activate rules based on current file
         const activatedRules = activateRules(rules, currentFile);
         // Build combined context
@@ -168,6 +178,7 @@ export class MemoryManager {
             context,
             errors,
             sources,
+            skippedFiles,
         };
         return this.loadedMemory;
     }
@@ -216,47 +227,112 @@ export class MemoryManager {
             'project-rules': 'project rules',
             local: 'local personal notes',
         };
-        const namespaceLabel = namespace === 'gencode' ? 'gencode' : namespace === 'claude' ? 'claude' : 'extra';
+        const namespaceLabel = namespace === 'gen' ? 'gen' : namespace === 'claude' ? 'claude' : 'extra';
         return `${levelLabels[level]} - ${namespaceLabel}`;
     }
     /**
-     * Load enterprise-level memory files
+     * Apply merge strategy to decide which files to load
+     * Returns the files to load and the files to skip
      */
-    async loadEnterpriseMemory() {
+    async applyMergeStrategy(claudeFilePath, genFilePath, level, strategy) {
         const files = [];
+        const skipped = [];
+        switch (strategy) {
+            case 'fallback': {
+                // Try gen first, fallback to claude
+                const genFile = await this.loadFile(genFilePath, level, 'gen');
+                if (genFile) {
+                    files.push(genFile);
+                    // Only skip claude file if it exists
+                    const claudeExists = await this.fileExists(claudeFilePath);
+                    if (claudeExists) {
+                        skipped.push(claudeFilePath);
+                    }
+                }
+                else {
+                    const claudeFile = await this.loadFile(claudeFilePath, level, 'claude');
+                    if (claudeFile) {
+                        files.push(claudeFile);
+                    }
+                }
+                break;
+            }
+            case 'both': {
+                // Load both (claude first for lower priority)
+                const claudeFile = await this.loadFile(claudeFilePath, level, 'claude');
+                if (claudeFile)
+                    files.push(claudeFile);
+                const genFile = await this.loadFile(genFilePath, level, 'gen');
+                if (genFile)
+                    files.push(genFile);
+                break;
+            }
+            case 'gen-only': {
+                // Only load gen
+                const genFile = await this.loadFile(genFilePath, level, 'gen');
+                if (genFile) {
+                    files.push(genFile);
+                }
+                // Only mark as skipped if claude file exists
+                const claudeExists = await this.fileExists(claudeFilePath);
+                if (claudeExists) {
+                    skipped.push(claudeFilePath);
+                }
+                break;
+            }
+            case 'claude-only': {
+                // Only load claude
+                const claudeFile = await this.loadFile(claudeFilePath, level, 'claude');
+                if (claudeFile) {
+                    files.push(claudeFile);
+                }
+                // Only mark as skipped if gen file exists
+                const genExists = await this.fileExists(genFilePath);
+                if (genExists) {
+                    skipped.push(genFilePath);
+                }
+                break;
+            }
+        }
+        return { files, skipped };
+    }
+    /**
+     * Check if a file exists
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Load enterprise-level memory files
+     */
+    async loadEnterpriseMemory(strategy) {
         const managedPaths = getManagedPaths();
-        // Load Claude first (lower priority)
-        const claudeFile = await this.loadFile(path.join(managedPaths.claude, this.config.claudeFilename), 'enterprise', 'claude');
-        if (claudeFile) {
-            claudeFile.enforced = true;
-            files.push(claudeFile);
-        }
-        // Load GenCode second (higher priority)
-        const gencodeFile = await this.loadFile(path.join(managedPaths.gencode, this.config.gencodeFilename), 'enterprise', 'gencode');
-        if (gencodeFile) {
-            gencodeFile.enforced = true;
-            files.push(gencodeFile);
-        }
-        return files;
+        const claudePath = path.join(managedPaths.claude, this.config.claudeFilename);
+        const genPath = path.join(managedPaths.gen, this.config.genFilename);
+        const result = await this.applyMergeStrategy(claudePath, genPath, 'enterprise', strategy);
+        // Mark all enterprise files as enforced
+        for (const file of result.files) {
+            file.enforced = true;
+        }
+        return result;
     }
     /**
-     * Load user-level memory files (both claude and gencode)
+     * Load user-level memory files (both claude and gen)
      */
-    async loadUserMemory() {
+    async loadUserMemory(strategy) {
         const home = os.homedir();
-        const files = [];
-        // Load Claude first (lower priority)
-        const claudeFile = await this.loadFile(path.join(home, this.config.claudeDir, this.config.claudeFilename), 'user', 'claude');
-        if (claudeFile)
-            files.push(claudeFile);
-        // Load GenCode second (higher priority)
-        const gencodeFile = await this.loadFile(path.join(home, this.config.gencodeDir, this.config.gencodeFilename), 'user', 'gencode');
-        if (gencodeFile)
-            files.push(gencodeFile);
-        return files;
+        const claudePath = path.join(home, this.config.claudeDir, this.config.claudeFilename);
+        const genPath = path.join(home, this.config.genDir, this.config.genFilename);
+        return await this.applyMergeStrategy(claudePath, genPath, 'user', strategy);
     }
     /**
-     * Load user-level rules (both claude and gencode)
+     * Load user-level rules (both claude and gen)
      */
     async loadUserRules() {
         const home = os.homedir();
@@ -266,34 +342,32 @@ export class MemoryManager {
         const claudeRules = await this.loadRulesFromDir(claudeRulesDir, 'user-rules', 'claude');
         rules.push(...claudeRules);
         // Load GenCode rules second (higher priority)
-        const gencodeRulesDir = path.join(home, this.config.gencodeDir, this.config.rulesDir);
-        const gencodeRules = await this.loadRulesFromDir(gencodeRulesDir, 'user-rules', 'gencode');
-        rules.push(...gencodeRules);
+        const genRulesDir = path.join(home, this.config.genDir, this.config.rulesDir);
+        const genRules = await this.loadRulesFromDir(genRulesDir, 'user-rules', 'gen');
+        rules.push(...genRules);
         return rules;
     }
     /**
      * Load extra config dirs memory
      */
-    async loadExtraMemory() {
+    async loadExtraMemory(strategy) {
         const extraDirs = this.parseExtraConfigDirs();
         const files = [];
+        const skipped = [];
         for (const dir of extraDirs) {
-            // Try CLAUDE.md
-            const claudeFile = await this.loadFile(path.join(dir, this.config.claudeFilename), 'extra', 'extra');
-            if (claudeFile)
-                files.push(claudeFile);
-            // Try AGENT.md
-            const gencodeFile = await this.loadFile(path.join(dir, this.config.gencodeFilename), 'extra', 'extra');
-            if (gencodeFile)
-                files.push(gencodeFile);
-        }
-        return files;
+            const claudePath = path.join(dir, this.config.claudeFilename);
+            const genPath = path.join(dir, this.config.genFilename);
+            const result = await this.applyMergeStrategy(claudePath, genPath, 'extra', strategy);
+            files.push(...result.files);
+            skipped.push(...result.skipped);
+        }
+        return { files, skipped };
     }
     /**
-     * Parse GENCODE_CONFIG_DIRS environment variable
+     * Parse GEN_CONFIG environment variable
      */
     parseExtraConfigDirs() {
-        const value = process.env[GENCODE_CONFIG_DIRS_ENV];
+        const value = process.env[GEN_CONFIG_ENV];
         if (!value)
             return [];
         return value
@@ -303,38 +377,45 @@ export class MemoryManager {
             .map((dir) => dir.replace(/^~/, os.homedir()));
     }
     /**
-     * Load project-level memory files (both claude and gencode)
+     * Load project-level memory files (both claude and gen)
      */
-    async loadProjectMemory(cwd, projectRoot) {
-        const files = [];
-        // Load from project root - Claude files first
+    async loadProjectMemory(cwd, projectRoot, strategy) {
+        // Find first existing claude file
         const claudeCandidates = [
             path.join(projectRoot, this.config.claudeFilename),
             path.join(projectRoot, this.config.claudeDir, this.config.claudeFilename),
         ];
-        for (const filePath of claudeCandidates) {
-            const file = await this.loadFile(filePath, 'project', 'claude');
-            if (file) {
-                files.push(file);
-                break; // Only load one claude file
+        let claudePath = claudeCandidates[0]; // Default for skipped tracking
+        for (const candidate of claudeCandidates) {
+            try {
+                await fs.stat(candidate);
+                claudePath = candidate;
+                break;
+            }
+            catch {
+                continue;
             }
         }
-        // Load from project root - GenCode files second
-        const gencodeCandidates = [
-            path.join(projectRoot, this.config.gencodeFilename),
-            path.join(projectRoot, this.config.gencodeDir, this.config.gencodeFilename),
+        // Find first existing gen file
+        const genCandidates = [
+            path.join(projectRoot, this.config.genFilename),
+            path.join(projectRoot, this.config.genDir, this.config.genFilename),
         ];
-        for (const filePath of gencodeCandidates) {
-            const file = await this.loadFile(filePath, 'project', 'gencode');
-            if (file) {
-                files.push(file);
-                break; // Only load one gencode file
+        let genPath = genCandidates[0]; // Default for skipped tracking
+        for (const candidate of genCandidates) {
+            try {
+                await fs.stat(candidate);
+                genPath = candidate;
+                break;
+            }
+            catch {
+                continue;
             }
         }
-        return files;
+        return await this.applyMergeStrategy(claudePath, genPath, 'project', strategy);
     }
     /**
-     * Load project-level rules (both claude and gencode)
+     * Load project-level rules (both claude and gen)
      */
     async loadProjectRules(projectRoot) {
         const rules = [];
@@ -343,41 +424,48 @@ export class MemoryManager {
         const claudeRules = await this.loadRulesFromDir(claudeRulesDir, 'project-rules', 'claude');
         rules.push(...claudeRules);
         // Load GenCode rules second (higher priority)
-        const gencodeRulesDir = path.join(projectRoot, this.config.gencodeDir, this.config.rulesDir);
-        const gencodeRules = await this.loadRulesFromDir(gencodeRulesDir, 'project-rules', 'gencode');
-        rules.push(...gencodeRules);
+        const genRulesDir = path.join(projectRoot, this.config.genDir, this.config.rulesDir);
+        const genRules = await this.loadRulesFromDir(genRulesDir, 'project-rules', 'gen');
+        rules.push(...genRules);
         return rules;
     }
     /**
-     * Load local memory files (both claude and gencode)
+     * Load local memory files (both claude and gen)
      */
-    async loadLocalMemory(projectRoot) {
-        const files = [];
-        // Load Claude local files first
+    async loadLocalMemory(projectRoot, strategy) {
+        // Find first existing claude local file
         const claudeCandidates = [
             path.join(projectRoot, this.config.claudeLocalFilename),
             path.join(projectRoot, this.config.claudeDir, this.config.claudeLocalFilename),
         ];
-        for (const filePath of claudeCandidates) {
-            const file = await this.loadFile(filePath, 'local', 'claude');
-            if (file) {
-                files.push(file);
+        let claudePath = claudeCandidates[0];
+        for (const candidate of claudeCandidates) {
+            try {
+                await fs.stat(candidate);
+                claudePath = candidate;
                 break;
             }
+            catch {
+                continue;
+            }
         }
-        // Load GenCode local files second
-        const gencodeCandidates = [
-            path.join(projectRoot, this.config.gencodeLocalFilename),
-            path.join(projectRoot, this.config.gencodeDir, this.config.gencodeLocalFilename),
+        // Find first existing gen local file
+        const genCandidates = [
+            path.join(projectRoot, this.config.genLocalFilename),
+            path.join(projectRoot, this.config.genDir, this.config.genLocalFilename),
         ];
-        for (const filePath of gencodeCandidates) {
-            const file = await this.loadFile(filePath, 'local', 'gencode');
-            if (file) {
-                files.push(file);
+        let genPath = genCandidates[0];
+        for (const candidate of genCandidates) {
+            try {
+                await fs.stat(candidate);
+                genPath = candidate;
                 break;
             }
+            catch {
+                continue;
+            }
         }
-        return files;
+        return await this.applyMergeStrategy(claudePath, genPath, 'local', strategy);
     }
     /**
      * Load rules from a directory
@@ -464,13 +552,13 @@ export class MemoryManager {
         let filePath;
         const home = os.homedir();
         if (level === 'user') {
-            const dir = path.join(home, this.config.gencodeDir);
+            const dir = path.join(home, this.config.genDir);
             await fs.mkdir(dir, { recursive: true });
-            filePath = path.join(dir, this.config.gencodeFilename);
+            filePath = path.join(dir, this.config.genFilename);
         }
         else {
             const projectRoot = await this.findProjectRoot(cwd);
-            filePath = path.join(projectRoot, this.config.gencodeFilename);
+            filePath = path.join(projectRoot, this.config.genFilename);
         }
         // Read existing content
         let existing = '';
@@ -479,7 +567,7 @@ export class MemoryManager {
         }
         catch {
             // File doesn't exist, create with header
-            existing = `# ${this.config.gencodeFilename.replace('.md', '')}\n\nThis file provides guidance when working with code in this repository.\n\n`;
+            existing = `# ${this.config.genFilename.replace('.md', '')}\n\nThis file provides guidance when working with code in this repository.\n\n`;
         }
         // Append new content
         const newContent = `${existing.trimEnd()}\n\n${content}\n`;
@@ -517,7 +605,7 @@ export class MemoryManager {
      * Get the path where /init would create a file
      */
     getInitFilePath(cwd) {
-        return path.join(cwd, this.config.gencodeFilename);
+        return path.join(cwd, this.config.genFilename);
     }
     /**
      * Check if project memory already exists
@@ -525,8 +613,8 @@ export class MemoryManager {
     async hasProjectMemory(cwd) {
         const projectRoot = await this.findProjectRoot(cwd);
         const candidates = [
-            path.join(projectRoot, this.config.gencodeFilename),
-            path.join(projectRoot, this.config.gencodeDir, this.config.gencodeFilename),
+            path.join(projectRoot, this.config.genFilename),
+            path.join(projectRoot, this.config.genDir, this.config.genFilename),
             path.join(projectRoot, this.config.claudeFilename),
             path.join(projectRoot, this.config.claudeDir, this.config.claudeFilename),
         ];
@@ -547,8 +635,8 @@ export class MemoryManager {
     async getExistingProjectMemoryPath(cwd) {
         const projectRoot = await this.findProjectRoot(cwd);
         const candidates = [
-            path.join(projectRoot, this.config.gencodeFilename),
-            path.join(projectRoot, this.config.gencodeDir, this.config.gencodeFilename),
+            path.join(projectRoot, this.config.genFilename),
+            path.join(projectRoot, this.config.genDir, this.config.genFilename),
             path.join(projectRoot, this.config.claudeFilename),
             path.join(projectRoot, this.config.claudeDir, this.config.claudeFilename),
         ];
@@ -583,5 +671,46 @@ export class MemoryManager {
         }
         return lines.join('\n');
     }
+    /**
+     * Get verbose loading summary with strategy info
+     */
+    getVerboseSummary(strategy) {
+        if (!this.loadedMemory)
+            return 'Memory not loaded';
+        const lines = [];
+        const kbLoaded = (this.loadedMemory.totalSize / 1024).toFixed(1);
+        lines.push(`[Memory] Strategy: ${strategy}`);
+        // Group sources by level
+        const byLevel = new Map();
+        for (const source of this.loadedMemory.sources) {
+            const key = source.level;
+            if (!byLevel.has(key)) {
+                byLevel.set(key, []);
+            }
+            byLevel.get(key).push(source);
+        }
+        // Show what was loaded per level
+        for (const [level, sources] of byLevel) {
+            for (const source of sources) {
+                const sizeKb = (source.size / 1024).toFixed(1);
+                const marker = source.level === 'enterprise' ? ' [enforced]' : '';
+                lines.push(`[Memory] ${level}: ${source.path} (${sizeKb} KB)${marker}`);
+            }
+        }
+        // Show what was skipped
+        if (this.loadedMemory.skippedFiles.length > 0) {
+            for (const skipped of this.loadedMemory.skippedFiles) {
+                lines.push(`[Memory] Skipped: ${skipped}`);
+            }
+        }
+        lines.push(`[Memory] Total: ${kbLoaded} KB (${this.loadedMemory.files.length} files loaded, ${this.loadedMemory.skippedFiles.length} skipped)`);
+        if (this.loadedMemory.errors.length > 0) {
+            lines.push('[Memory] Errors:');
+            for (const error of this.loadedMemory.errors) {
+                lines.push(`  - ${error}`);
+            }
+        }
+        return lines.join('\n');
+    }
 }
 //# sourceMappingURL=memory-manager.js.map