code-graph-llm 1.6.0 → 2.1.0

package/AGENT_RULES.md

@@ -0,0 +1,20 @@
+# AGENT OPERATIONAL PROTOCOL (STRICT)
+> This protocol is MANDATORY for all LLM agents. Failure to update memory is a failure of the task.
+## 🧠 THE REFLECTION CYCLE
+Every execution SHOULD follow this cycle:
+1. **PRE-TASK:** Read \`PROJECT_REFLECTIONS.md\` to identify existing pitfalls.
+2. **EXECUTION:** Monitor for "Learned Moments" (failures, unexpected behaviors, or non-obvious fixes).
+3. **POST-TASK:** If a significant lesson was learned, run \`code-graph reflect <CAT> <LESSON>\`. 
+   - **NOTE:** Routine, expected changes do not require reflections. Focus on high-signal context.
+
+
+## ⚠️ CRITICAL MANDATES
+- **OS [win32]:** Always prefix npm commands with `cmd /c`. 
+- **FILE [index.js]:** This is the core engine. Any change here requires immediate `npm test` validation.
+- **DOCS:** `llm-code-graph.md` is the "Source of Truth" for your context. Keep it accurate.
+
+## 📝 REFLECTION CATEGORIES
+- `LOGIC`: Code bugs, better patterns, or complex regex pitfalls.
+- `ENV`: OS compatibility, shell behaviors, or CI/CD issues.
+- `DEP`: Library bugs, version incompatibilities, or deprecations.
+- `STYLE`: Naming conventions or project-specific architectural rules.

package/PROJECT_REFLECTIONS.md

@@ -0,0 +1,14 @@
+# PROJECT_REFLECTIONS & LESSONS LEARNED
+> LLM AGENT MEMORY: READ BEFORE STARTING TASKS. UPDATE ON FAILURES.
+
+## ⚠️ CRITICAL PITFALLS
+- [OS: win32] PowerShell script execution is disabled by default; use `cmd /c npm` for all npm commands to ensure compatibility.
+- [LOGIC: index.js] `extractSymbolsAndInheritance` regex matches itself if TODO/FIXME strings are present in the code; ensure filters are in place.
+
+## 📦 DEPENDENCIES & ENVIRONMENT
+- [DEP: chokidar] Watcher should be debounced by at least 500ms to avoid race conditions during rapid file saves.
+
+## ✅ BEST PRACTICES
+- [STYLE] Always include dependency counts (↑N ↓M) in `llm-code-graph.md` to help prioritize architectural understanding.
+
+- [TOOLING: 2026-04-15] Added reflect command to simplify LLM memory updates.

package/README.md

@@ -1,11 +1,15 @@
-# CODE-GRAPH
+# CODE-GRAPH (v2.0.0)
 
-A language-agnostic, ultra-compact codebase mapper designed specifically for LLM agents to optimize context and token usage. It doesn't just list files; it provides a high-signal "map" of your project's architecture, including descriptions and signatures.
+A language-agnostic, ultra-compact codebase mapper and **agent memory system** designed specifically for LLM agents. It optimizes context and token usage while enabling agents to learn from their own mistakes across sessions.
+
+## 🚀 New in v2.0: Self-Learning Memory
+- **Reflection System:** Agents can now persist "Lessons Learned" via `code-graph reflect`.
+- **Operational Protocol:** Standardized `AGENT_RULES.md` ensures agents follow strict "Reflect-Act-Verify" cycles.
+- **Architectural Weight:** Project maps now include dependency counts (↑N ↓M) and CORE entry-point markers.
+- **Production Refactor:** Class-based service architecture with full `fs/promises` async support.
 
 ## Features
-- **Structural Knowledge Graph:** Captures relationships between files and classes:
-  - **Dependencies:** Tracks `imports`, `requires`, and `includes` across files.
-  - **Inheritance:** Maps `extends`, `implements`, and class hierarchies.
+- **Structural Knowledge Graph:** Captures `imports`, `requires`, `extends`, and `implements`.
 - **Smart Context Extraction:** Captures JSDoc, Python docstrings, and preceding comments.
 - **Signature Fallback:** Extracts function signatures (parameters/types) if documentation is missing.
 - **Recursive .gitignore Support:** Deeply respects both root and nested `.gitignore` files.
@@ -16,33 +20,44 @@ A language-agnostic, ultra-compact codebase mapper designed specifically for LLM
 
 ### 1. Install via NPM
 ```bash
-# Global installation for CLI use
 npm install -g code-graph-llm
-
-# Local project dependency
+# OR
 npm install --save-dev code-graph-llm
 ```
 
-### 2. Basic Usage
+### 2. Core Commands
 ```bash
+# Initialize Agent Rules and Reflection files (Scaffolding)
+code-graph init
+
 # Generate the llm-code-graph.md map
 code-graph generate
 
+# Record a project reflection (Memory)
+code-graph reflect <CATEGORY> "Lesson learned"
+# Example: code-graph reflect ENV "Always use 'cmd /c npm' on Windows."
+
 # Start the live watcher for real-time updates
 code-graph watch
 
-# Install the Git pre-commit hook
+# Install the Git pre-commit hook (Enforces Map & Memory sync)
 code-graph install-hook
 ```
 
-## LLM Usage & Token Efficiency
+## 🧠 LLM Agent Strategy
+
+### 1. The Mandatory Protocol
+Instruct your agent to follow the **STRICT AGENT PROTOCOL** in `AGENT_RULES.md`. This ensures the agent:
+1. Reads `PROJECT_REFLECTIONS.md` before starting any task.
+2. Updates reflections after any failure or "learned moment."
+3. Regenerates the project map (`llm-code-graph.md`) after structural changes.
 
-### The "Read First" Strategy
-Instruct your LLM agent to read `llm-code-graph.md` as its first step. The file provides a high-level map and a structural graph for relational reasoning:
+### 2. The "Read First" Strategy
+The `llm-code-graph.md` file provides a high-level map and structural graph for relational reasoning:
 
 **Example Map Entry:**
 ```markdown
-- src/auth.js | desc: Handles user authentication.
+- [CORE] src/auth.js (↑3 ↓5) [TODO: Add JWT rotation] | desc: Handles user authentication.
   - syms: [login [ (username, password) ], validateToken [ (token: string) ]]
 
 ## GRAPH EDGES
@@ -50,41 +65,12 @@ Instruct your LLM agent to read `llm-code-graph.md` as its first step. The file
 [AdminUser] -> [inherits] -> [BaseUser]
 ```
 
-**Example System Prompt:**
-> "Before acting, read `llm-code-graph.md`. It contains the project map, file descriptions, and function signatures. Use this to locate relevant logic instead of scanning the full codebase."
-
-## Build Phase Integration
-
-### 1. Java/Kotlin (Maven/Gradle)
-**Gradle (Groovy):**
-```groovy
-task generateCodeGraph(type: Exec) {
-    commandLine 'code-graph', 'generate'
-}
-compileJava.dependsOn generateCodeGraph
-```
-
-### 2. Python
-**Makefile:**
-```makefile
-map:
-	code-graph generate
-test: map
-	pytest
-```
-
-### 3. Rust (build.rs)
-```rust
-use std::process::Command;
-fn main() {
-    Command::new("code-graph").arg("generate").status().unwrap();
-}
-```
+### 3. Example System Prompt
+> "Before acting, read `llm-code-graph.md`. Follow the protocol in `AGENT_RULES.md`. If you encounter a bug or an environment quirk, use the `code-graph reflect` tool to record the lesson in `PROJECT_REFLECTIONS.md`."
 
 ## How it works
-1. **File Scanning:** Recursively walks the directory, ignoring patterns in `.gitignore` (recursive).
+1. **File Scanning:** Recursively walks the directory, ignoring patterns in `.gitignore`.
 2. **Context Extraction:** Scans for classes, functions, and variables while ignoring matches in comments.
-3. **Graph Extraction:** Identifies `imports`, `requires`, `extends`, and `implements` to build a structural skeleton.
-4. **Docstring Capture:** Captures preceding comments as descriptions.
-5. **Signature Capture:** Fallback to declaration signatures (parameters) if docs are missing.
-6. **Compilation:** Writes a single, minified `llm-code-graph.md` file with a dedicated `## GRAPH EDGES` section.
+3. **Graph Extraction:** Identifies `imports`, `requires`, `extends`, and `implements`.
+4. **Reflection Management:** Deduplicates and persists agent learning into a standardized Markdown format.
+5. **Compilation:** Writes a single, minified `llm-code-graph.md` file with a dedicated `## GRAPH EDGES` section.

package/index.js

@@ -1,334 +1,393 @@
 #!/usr/bin/env node
 
+/**
+ * @file index.js
+ * @description Compact, language-agnostic codebase mapper for LLM token efficiency.
+ * Features: Symbol extraction, dependency mapping, reflection logging, and git hooks.
+ */
+
 import fs from 'fs';
+import { promises as fsp } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import chokidar from 'chokidar';
 import ignore from 'ignore';
 
+// --- Constants & Configuration ---
+
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const IGNORE_FILE = '.gitignore';
-const DEFAULT_MAP_FILE = 'llm-code-graph.md';
-const SYMBOL_REGEXES = [
-  // Types, Classes, Interfaces (Universal) with Inheritance support
-  /\b(?:class|interface|type|struct|enum|protocol|extension|trait|module|namespace|object)\s+([a-zA-Z_]\w*)(?:[^\n\S]*(?:extends|implements|:|(?:\())[^\n\S]*([a-zA-Z_]\w*(?:[^\n\S]*,\s*[a-zA-Z_]\w*)*)\)?)?/g,
-
-  // Explicit Function Keywords
-  /\b(?:function|def|fn|func|fun|method|procedure|sub|routine)\s+([a-zA-Z_]\w*)/g,
-
-  // Method/Var Declarations (Java, Spring Boot, C-style)
-  // Captures: public String askAi(String question), void realFunction()
-  /\b(?:void|async|public|private|protected|static|final|native|synchronized|abstract|transient|volatile)\s+(?:[\w<>[\]]+\s+)?([a-zA-Z_]\w*)(?=\s*\([^)]*\)\s*(?:\{|=>|;|=))/g,
-
-  // Spring/Java/Dart Annotations (Captures the annotation name as a prefix)
-  /(@[a-zA-Z_]\w*(?:\([^)]*\))?)\s*(?:(?:public|private|protected|static|final|abstract|class|interface|enum|void|[\w<>[\]]+)\s+)+([a-zA-Z_]\w*)/g,
-
-  // Exported symbols
-  /\bexport\s+(?:default\s+)?(?:const|let|var|function|class|type|interface|enum|async|val)\s+([a-zA-Z_]\w*)/g
-];
-
-
-const EDGE_REGEXES = [
-  // Imports/Includes (JS, TS, Python, Go, Rust, C++, Java, Dart)
-  /\b(?:import|from|include|require|using)\s*(?:[\(\s])\s*['"]?([@\w\.\/\-]+)['"]?/g,
-  // C-style includes
-  /#include\s+[<"]([\w\.\/\-]+)[>"]/g
-];
-
-export const SUPPORTED_EXTENSIONS = [
-  '.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.java', 
-  '.cpp', '.c', '.h', '.hpp', '.cc', '.rb', '.php', '.swift', 
-  '.kt', '.cs', '.dart', '.scala', '.m', '.mm'
-];
-
-export function getIgnores(cwd, additionalLines = []) {
-  const ig = ignore().add([
-    '.git/', 'node_modules/', DEFAULT_MAP_FILE, 'package-lock.json', 
-    '.idea/', 'build/', 'dist/', 'bin/', 'obj/', '.dart_tool/', '.pub-cache/', '.pub/'
-  ]);
-  const ignorePath = path.join(cwd, IGNORE_FILE);
-  if (fs.existsSync(ignorePath)) {
-    ig.add(fs.readFileSync(ignorePath, 'utf8'));
+export const CONFIG = {
+  IGNORE_FILE: '.gitignore',
+  MAP_FILE: 'llm-code-graph.md',
+  REFLECTIONS_FILE: 'PROJECT_REFLECTIONS.md',
+  RULES_FILE: 'AGENT_RULES.md',
+  SUPPORTED_EXTENSIONS: [
+    '.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.java', 
+    '.cpp', '.c', '.h', '.hpp', '.cc', '.rb', '.php', '.swift', 
+    '.kt', '.cs', '.dart', '.scala', '.m', '.mm'
+  ],
+  DEFAULT_IGNORES: [
+    '.git/', 'node_modules/', 'package-lock.json', '.idea/', 
+    'build/', 'dist/', 'bin/', 'obj/', '.dart_tool/', '.pub-cache/', '.pub/'
+  ]
+};
+
+export const SUPPORTED_EXTENSIONS = CONFIG.SUPPORTED_EXTENSIONS;
+
+const REGEX = {
+  SYMBOLS: [
+    // Types, Classes, Interfaces with Inheritance
+    /\b(?:class|interface|type|struct|enum|protocol|extension|trait|module|namespace|object)\s+([a-zA-Z_]\w*)(?:[^\n\S]*(?:extends|implements|:|(?:\())[^\n\S]*([a-zA-Z_]\w*(?:[^\n\S]*,\s*[a-zA-Z_]\w*)*)\)?)?/g,
+    // Functions
+    /\b(?:function|def|fn|func|fun|method|procedure|sub|routine)\s+([a-zA-Z_]\w*)/g,
+    // Method/Var Declarations (C-style, Java)
+    /\b(?:void|async|public|private|protected|static|final|native|synchronized|abstract|transient|volatile)\s+(?:[\w<>[\]]+\s+)?([a-zA-Z_]\w*)(?=\s*\([^)]*\)\s*(?:\{|=>|;|=))/g,
+    // Annotations
+    /(@[a-zA-Z_]\w*(?:\([^)]*\))?)\s*(?:(?:public|private|protected|static|final|abstract|class|interface|enum|void|[\w<>[\]]+)\s+)+([a-zA-Z_]\w*)/g,
+    // Exports
+    /\bexport\s+(?:default\s+)?(?:const|let|var|function|class|type|interface|enum|async|val)\s+([a-zA-Z_]\w*)/g
+  ],
+  EDGES: [
+    /\b(?:import|from|include|require|using)\s*(?:[\(\s])\s*['"]?([@\w\.\/\-]+)['"]?/g,
+    /#include\s+[<"]([\w\.\/\-]+)[>"]/g
+  ],
+  TAGS: /\b(TODO|FIXME|BUG|DEPRECATED):?\s*(.*)/i,
+  KEYWORDS: new Set(['if', 'for', 'while', 'switch', 'return', 'await', 'yield', 'const', 'new', 'let', 'var', 'class', 'void', 'public', 'private', 'protected'])
+};
+
+// --- Core Services ---
+
+/**
+ * Handles extraction of symbols, edges, and metadata from source code.
+ */
+class CodeParser {
+  static extract(content) {
+    const noComments = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
+    const cleanContent = noComments.replace(/['"`](?:\\.|[^'"`])*['"`]/g, ''); // Remove strings for symbol extraction
+
+    const { symbols, inheritance } = this.extractSymbols(content, cleanContent);
+    const edges = this.extractEdges(noComments); // Edges need strings (import paths)
+    const tags = this.extractTags(content);
+
+    return { symbols, inheritance, edges, tags };
   }
-  if (additionalLines.length > 0) {
-    ig.add(additionalLines);
-  }
-  return ig;
-}
 
-export function extractSymbolsAndInheritance(content) {
-  const symbols = [];
-  const inheritance = [];
-  
-  // Create a version of content without comments AND strings to find symbols accurately
-  const cleanContent = content
-    .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '')
-    .replace(/['"`](?:\\.|[^'"`])*['"`]/g, '');
-
-  for (const regex of SYMBOL_REGEXES) {
-    let match;
-    regex.lastIndex = 0;
-    while ((match = regex.exec(cleanContent)) !== null) {
-      if (match[1]) {
-        // Handle the Annotation regex separately (it has 2 groups)
-        let symbolName = match[1];
-        let annotation = '';
+  static extractSymbols(original, clean) {
+    const symbols = new Set();
+    const inheritance = [];
+
+    for (const regex of REGEX.SYMBOLS) {
+      let match;
+      regex.lastIndex = 0;
+      while ((match = regex.exec(clean)) !== null) {
+        let name = match[1];
+        let annotation = name.startsWith('@') ? name : '';
+        if (annotation) name = match[2] || '';
         
-        if (symbolName.startsWith('@')) {
-          annotation = symbolName;
-          symbolName = match[2] || '';
-          if (!symbolName) continue;
-        }
-
-        if (['if', 'for', 'while', 'switch', 'return', 'await', 'yield', 'const', 'new', 'let', 'var', 'class', 'void', 'public', 'private', 'protected'].includes(symbolName)) continue;
+        if (!name || REGEX.KEYWORDS.has(name)) continue;
 
-        // Capture inheritance if present (match[2] only for non-annotation regex)
         if (!annotation && match[2]) {
-          const parents = match[2].split(',').map(p => p.trim());
-          parents.forEach(parent => {
-            inheritance.push({ child: symbolName, parent });
-          });
-        }
-
-        // To find the comment, we need to find the position in the ORIGINAL content
-        const escapedName = symbolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const posRegex = new RegExp(`\\b${escapedName}\\b`, 'g');
-        let posMatch = posRegex.exec(content);
-        if (!posMatch) continue;
-
-        const linesBefore = content.substring(0, posMatch.index).split('\n');
-        let comment = '';
-        // Skip the current line where the symbol is defined
-        for (let i = linesBefore.length - 2; i >= 0; i--) {
-          const line = linesBefore[i].trim();
-          if (line.startsWith('//') || line.startsWith('*') || line.startsWith('"""') || line.startsWith('#') || line.startsWith('/*')) {
-            const clean = line.replace(/[\/*#"]/g, '').trim();
-            if (clean) comment = clean + (comment ? ' ' + comment : '');
-            if (comment.length > 100) break; 
-          } else if (line === '' && comment === '') continue;
-          else if (line.startsWith('@')) continue; // Skip annotations in comment search
-          else break;
+          match[2].split(',').forEach(p => inheritance.push({ child: name, parent: p.trim() }));
         }
 
-        let context = comment;
-        if (!context) {
-          const remainingLine = content.substring(posMatch.index + symbolName.length);
-          const sigMatch = remainingLine.match(/^\s*(\([^)]*\)|[^\n{;]*)/);
-          if (sigMatch && sigMatch[1].trim()) {
-            context = sigMatch[1].trim();
-          }
-        }
-        
-        const displaySymbol = annotation ? `${annotation} ${symbolName}` : symbolName;
-        symbols.push(context ? `${displaySymbol} [${context}]` : displaySymbol);
+        const context = this.findSymbolContext(original, name);
+        const display = annotation ? `${annotation} ${name}` : name;
+        symbols.add(context ? `${display} [${context}]` : display);
       }
     }
+    return { symbols: Array.from(symbols).sort(), inheritance };
   }
-  return { 
-    symbols: Array.from(new Set(symbols)).sort(),
-    inheritance: Array.from(new Set(inheritance.map(JSON.stringify))).map(JSON.parse)
-  };
-}
 
-export function extractEdges(content) {
-  const dependencies = new Set();
-  const noComments = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-  for (const regex of EDGE_REGEXES) {
-    let match;
-    regex.lastIndex = 0;
-    while ((match = regex.exec(noComments)) !== null) {
-      if (match[1]) {
-        const dep = match[1];
-        // Filter out obvious noise, common library names, or keywords
-        if (dep.length > 1 && !['style', 'react', 'vue', 'flutter', 'new', 'const', 'let', 'var', 'dependencies', 'from', 'import'].includes(dep.toLowerCase())) {
-          dependencies.add(dep);
-        }
+  static findSymbolContext(content, name) {
+    const pos = content.search(new RegExp(`\\b${name}\\b`));
+    if (pos === -1) return '';
+
+    const linesBefore = content.substring(0, pos).split('\n');
+    let comment = '';
+    for (let i = linesBefore.length - 2; i >= 0; i--) {
+      const line = linesBefore[i].trim();
+      if (/^(\/\/|\*|"""|#|\/\*)/.test(line)) {
+        const clean = line.replace(/[\/*#"]/g, '').trim();
+        if (clean) comment = clean + (comment ? ' ' + comment : '');
+        if (comment.length > 100) break;
+      } else if (line !== '' && !line.startsWith('@')) break;
+    }
+
+    if (!comment) {
+      const remaining = content.substring(pos + name.length);
+      const sigMatch = remaining.match(/^\s*(\([^)]*\)|[^\n{;]*)/);
+      return sigMatch?.[1].trim() || '';
+    }
+    return comment;
+  }
+
+  static extractEdges(clean) {
+    const deps = new Set();
+    for (const regex of REGEX.EDGES) {
+      let match;
+      regex.lastIndex = 0;
+      while ((match = regex.exec(clean)) !== null) {
+        if (match[1] && match[1].length > 1) deps.add(match[1]);
       }
     }
+    return Array.from(deps).sort();
+  }
+
+  static extractTags(content) {
+    const tags = new Set();
+    content.split('\n').forEach(line => {
+      const match = line.match(REGEX.TAGS);
+      if (match) tags.add(`${match[1]}: ${match[2].substring(0, 50).trim()}`);
+    });
+    return Array.from(tags);
   }
-  return Array.from(dependencies).sort();
 }
 
-async function generate(cwd = process.cwd()) {
-  const files = [];
-  const allEdges = [];
-  const incomingEdges = {}; // Map of projectPath -> count of incoming edges
-
-  function walk(dir, ig) {
-    let localIg = ig;
-    const localIgnorePath = path.join(dir, IGNORE_FILE);
-    if (fs.existsSync(localIgnorePath) && dir !== cwd) {
-      const content = fs.readFileSync(localIgnorePath, 'utf8');
-      const lines = content.split('\n').map(line => {
-          line = line.trim();
-          if (!line || line.startsWith('#')) return null;
-          const relDir = path.relative(cwd, dir).replace(/\\/g, '/');
-          return relDir ? `${relDir}/${line}` : line;
-      }).filter(Boolean);
-      localIg = ignore().add(ig).add(lines);
+/**
+ * Manages the project mapping and file generation.
+ */
+class ProjectMapper {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.files = [];
+    this.allEdges = [];
+    this.incomingEdges = {};
+  }
+
+  getIgnores(dir, baseIg) {
+    const ig = ignore().add(baseIg);
+    const ignorePath = path.join(dir, CONFIG.IGNORE_FILE);
+    if (fs.existsSync(ignorePath)) {
+      ig.add(fs.readFileSync(ignorePath, 'utf8'));
     }
+    return ig;
+  }
 
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+  async walk(dir, ig) {
+    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      const relativePath = path.relative(cwd, fullPath);
-      const normalizedPath = relativePath.replace(/\\/g, '/');
-      const isDirectory = entry.isDirectory();
-      const checkPath = isDirectory ? `${normalizedPath}/` : normalizedPath;
-
-      if (localIg.ignores(checkPath)) continue;
-
-      if (isDirectory) {
-        walk(fullPath, localIg);
-      } else if (entry.isFile()) {
-        const ext = path.extname(entry.name);
-        if (SUPPORTED_EXTENSIONS.includes(ext)) {
-          const content = fs.readFileSync(fullPath, 'utf8');
-          
-          // Extract file-level description and tags
-          const lines = content.split('\n');
-          let fileDesc = '';
-          const tags = [];
-          for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            // Surface actionable tags
-            const tagMatch = line.match(/\b(TODO|FIXME|BUG|DEPRECATED):?\s*(.*)/i);
-            if (tagMatch) {
-              tags.push(`${tagMatch[1]}: ${tagMatch[2].substring(0, 50).trim()}`);
-            }
-            
-            if (i < 10) {
-              if (line.startsWith('#!') || line === '') continue;
-              if (line.startsWith('//') || line.startsWith('#') || line.startsWith('/*')) {
-                fileDesc += line.replace(/[\/*#]/g, '').trim() + ' ';
-              } else if (fileDesc) {
-                // Stop if we hit non-comment code
-                break;
-              }
-            }
-          }
-
-          const { symbols, inheritance } = extractSymbolsAndInheritance(content);
-          const dependencies = extractEdges(content);
-          
-          if (!fileDesc.trim() && symbols.length > 0) fileDesc = `Contains ${symbols.length} symbols.`;
-          
-          // Identify core entry points
-          const isCore = /^(index|main|app|server|cli)\.(js|ts|py|go|rs|java|cpp)$/i.test(entry.name);
-          
-          const fileObj = { 
-            path: normalizedPath, 
-            desc: fileDesc.trim(), 
-            symbols, 
-            tags: Array.from(new Set(tags)),
-            isCore,
-            outCount: dependencies.length
-          };
-          files.push(fileObj);
-          
-          // Collect Edges and track incoming
-          dependencies.forEach(dep => {
-            let target = dep;
-            if (dep.startsWith('.')) {
-              // Resolve relative path to project-relative
-              const resolved = path.normalize(path.join(path.dirname(normalizedPath), dep));
-              target = resolved.replace(/\\/g, '/');
-              // Basic extension guesser
-              if (!path.extname(target)) {
-                for (const ex of SUPPORTED_EXTENSIONS) {
-                  if (fs.existsSync(path.join(cwd, target + ex))) {
-                    target += ex;
-                    break;
-                  }
-                }
-              }
-            }
-            allEdges.push(`[${normalizedPath}] -> [imports] -> [${target}]`);
-            incomingEdges[target] = (incomingEdges[target] || 0) + 1;
-          });
-          inheritance.forEach(inh => {
-            allEdges.push(`[${inh.child}] -> [inherits] -> [${inh.parent}]`);
-          });
-        }
+      const relPath = path.relative(this.cwd, fullPath).replace(/\\/g, '/');
+      const checkPath = entry.isDirectory() ? `${relPath}/` : relPath;
+
+      if (ig.ignores(checkPath)) continue;
+
+      if (entry.isDirectory()) {
+        await this.walk(fullPath, this.getIgnores(fullPath, ig));
+      } else if (CONFIG.SUPPORTED_EXTENSIONS.includes(path.extname(entry.name))) {
+        await this.processFile(fullPath, relPath);
+      }
+    }
+  }
+
+  async processFile(fullPath, relPath) {
+    const content = await fsp.readFile(fullPath, 'utf8');
+    const { symbols, inheritance, edges, tags } = CodeParser.extract(content);
+
+    const isCore = /^(index|main|app|server|cli)\./i.test(path.basename(relPath));
+    const fileObj = { path: relPath, symbols, tags, isCore, outCount: edges.length, desc: this.extractFileDesc(content, symbols.length) };
+    
+    this.files.push(fileObj);
+    this.processEdges(relPath, edges, inheritance);
+  }
+
+  extractFileDesc(content, symCount) {
+    const lines = content.split('\n').slice(0, 10);
+    let desc = '';
+    for (const line of lines) {
+      if (/^(\/\/|#|\/\*)/.test(line.trim())) desc += line.replace(/[\/*#]/g, '').trim() + ' ';
+      else if (desc) break;
+    }
+    return desc.trim() || (symCount > 0 ? `Contains ${symCount} symbols.` : '');
+  }
+
+  processEdges(relPath, edges, inheritance) {
+    edges.forEach(dep => {
+      let target = dep;
+      if (dep.startsWith('.')) {
+        const resolved = path.normalize(path.join(path.dirname(relPath), dep)).replace(/\\/g, '/');
+        target = this.resolveExtension(resolved);
       }
+      this.allEdges.push(`[${relPath}] -> [imports] -> [${target}]`);
+      this.incomingEdges[target] = (this.incomingEdges[target] || 0) + 1;
+    });
+    inheritance.forEach(inh => this.allEdges.push(`[${inh.child}] -> [inherits] -> [${inh.parent}]`));
+  }
+
+  resolveExtension(target) {
+    if (path.extname(target)) return target;
+    for (const ext of CONFIG.SUPPORTED_EXTENSIONS) {
+      if (fs.existsSync(path.join(this.cwd, target + ext))) return target + ext;
     }
+    return target;
   }
 
-  walk(cwd, getIgnores(cwd));
-
-  // Sort: Core files first, then by incoming edges (importance)
-  files.sort((a, b) => {
-    if (a.isCore && !b.isCore) return -1;
-    if (!a.isCore && b.isCore) return 1;
-    const inA = incomingEdges[a.path] || 0;
-    const inB = incomingEdges[b.path] || 0;
-    return inB - inA;
-  });
-
-  const nodesOutput = files.map(f => {
-    const inCount = incomingEdges[f.path] || 0;
-    const coreMark = f.isCore ? '[CORE] ' : '';
-    const stats = `(↑${f.outCount} ↓${inCount})`;
-    const tagStr = f.tags.length > 0 ? ` [${f.tags.join(', ')}]` : '';
-    const descStr = f.desc ? ` | desc: ${f.desc.substring(0, 100)}` : '';
-    const symStr = f.symbols.length > 0 ? `\n  - syms: [${f.symbols.join(', ')}]` : '';
-    return `- ${coreMark}${f.path} ${stats}${tagStr}${descStr}${symStr}`;
-  }).join('\n');
-
-  const edgesOutput = allEdges.length > 0 
-    ? `\n\n## GRAPH EDGES\n${Array.from(new Set(allEdges)).sort().join('\n')}` 
-    : '';
-
-  const header = `# CODE_GRAPH_MAP\n> LLM_ONLY: DO NOT EDIT. COMPACT PROJECT MAP.\n> Legend: [CORE] Entry Point, (↑N) Outgoing Deps, (↓M) Incoming Dependents\n> Notation: syms: [Name [Signature/Context]], desc: File Summary, [TAG: Context] Actionable items\n\n`;
-  fs.writeFileSync(path.join(cwd, DEFAULT_MAP_FILE), header + nodesOutput + edgesOutput);
-  console.log(`[Code-Graph] Updated ${DEFAULT_MAP_FILE}`);
+  async generate() {
+    console.log(`[Code-Graph] Mapping ${this.cwd}...`);
+    await this.walk(this.cwd, this.getIgnores(this.cwd, CONFIG.DEFAULT_IGNORES));
+
+    this.files.sort((a, b) => (b.isCore - a.isCore) || ((this.incomingEdges[b.path] || 0) - (this.incomingEdges[a.path] || 0)));
+
+    const output = this.formatOutput();
+    await fsp.writeFile(path.join(this.cwd, CONFIG.MAP_FILE), output);
+    console.log(`[Code-Graph] Updated ${CONFIG.MAP_FILE}`);
+  }
+
+  formatOutput() {
+    const header = `# CODE_GRAPH_MAP\n> MISSION: COMPACT PROJECT MAP FOR LLM AGENTS.\n> PROTOCOL: Follow AGENT_RULES.md | MEMORY: See PROJECT_REFLECTIONS.md\n> Legend: [CORE] Entry Point, (↑N) Outgoing Deps, (↓M) Incoming Dependents\n> Notation: syms: [Name [Signature/Context]], desc: File Summary, [TAG: Context]\n\n`;
+    const nodes = this.files.map(f => {
+      const inCount = this.incomingEdges[f.path] || 0;
+      const tags = f.tags.length ? ` [${f.tags.join(', ')}]` : '';
+      return `- ${f.isCore ? '[CORE] ' : ''}${f.path} (↑${f.outCount} ↓${inCount})${tags} | desc: ${f.desc.substring(0, 100)}\n  - syms: [${f.symbols.join(', ')}]`;
+    }).join('\n');
+    const edges = this.allEdges.length ? `\n\n## GRAPH EDGES\n${Array.from(new Set(this.allEdges)).sort().join('\n')}` : '';
+    return header + nodes + edges;
+  }
 }
 
-export { generate };
-
-export function watch(cwd = process.cwd()) {
-  console.log(`[Code-Graph] Watching for changes in ${cwd}...`);
-  let timeout;
-  const debouncedGenerate = () => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => generate(cwd), 500);
-  };
-
-  const watcher = chokidar.watch(cwd, {
-    ignored: (p) => {
-        if (p === cwd) return false;
-        // Watcher ignore is harder for recursive .gitignore without complexity
-        // We rely on the generate() call to skip them during walk
-        return false; 
-    },
-    persistent: true,
-    ignoreInitial: true
-  });
-
-  watcher.on('all', (event, path) => {
-    debouncedGenerate();
-  });
+/**
+ * Manages project reflections and lessons learned.
+ */
+class ReflectionManager {
+  static async add(category, lesson) {
+    if (!lesson) return console.error('[Code-Graph] Usage: reflect <cat> <lesson>');
+    
+    const filePath = path.join(process.cwd(), CONFIG.REFLECTIONS_FILE);
+    const header = `# PROJECT_REFLECTIONS & LESSONS LEARNED\n> LLM AGENT MEMORY: READ BEFORE STARTING TASKS. UPDATE ON FAILURES.\n`;
+    const entry = `- [${category.toUpperCase()}: ${new Date().toISOString().split('T')[0]}] ${lesson}`;
+
+    try {
+      let content = fs.existsSync(filePath) ? await fsp.readFile(filePath, 'utf8') : header;
+      if (!fs.existsSync(filePath)) await fsp.writeFile(filePath, header);
+
+      if (content.toLowerCase().includes(lesson.toLowerCase().trim())) {
+        return console.log('[Code-Graph] Reflection already exists.');
+      }
+
+      await fsp.appendFile(filePath, `\n${entry}`);
+      console.log(`[Code-Graph] Recorded reflection: ${lesson}`);
+    } catch (err) {
+      console.error(`[Code-Graph] Reflection failed: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Scaffolds the initial agent-agnostic rule and reflection files.
+ */
+class ProjectInitializer {
+  static async init(cwd) {
+    const rulesPath = path.join(cwd, CONFIG.RULES_FILE);
+    const reflectPath = path.join(cwd, CONFIG.REFLECTIONS_FILE);
+
+    const rulesContent = `# AGENT OPERATIONAL PROTOCOL (STRICT)
+> This protocol is MANDATORY for all LLM agents. Failure to update memory is a failure of the task.
+
+## 🧠 THE REFLECTION CYCLE
+1. **PRE-TASK:** Read \`${CONFIG.REFLECTIONS_FILE}\` to identify existing pitfalls.
+2. **EXECUTION:** Monitor for "Learned Moments" (failures, corrections, or discoveries).
+3. **POST-TASK:** Immediately run \`code-graph reflect <CAT> <LESSON>\` for any discovery. 
+
+## 📝 REFLECTION CATEGORIES
+- \`LOGIC\`: Code bugs or complex regex pitfalls.
+- \`ENV\`: OS compatibility or shell behaviors.
+- \`DEP\`: Library bugs or version deprecations.
+- \`STYLE\`: Project-specific architectural rules.
+`;
+
+    const reflectContent = `# PROJECT_REFLECTIONS & LESSONS LEARNED\n> LLM AGENT MEMORY: READ BEFORE STARTING TASKS. UPDATE ON FAILURES.\n`;
+
+    try {
+      if (!fs.existsSync(rulesPath)) {
+        await fsp.writeFile(rulesPath, rulesContent);
+        console.log(`[Code-Graph] Initialized ${CONFIG.RULES_FILE}`);
+      }
+      if (!fs.existsSync(reflectPath)) {
+        await fsp.writeFile(reflectPath, reflectContent);
+        console.log(`[Code-Graph] Initialized ${CONFIG.REFLECTIONS_FILE}`);
+      }
+    } catch (err) {
+      console.error(`[Code-Graph] Initialization failed: ${err.message}`);
+    }
+  }
 }
 
-export function installHook(cwd = process.cwd()) {
-  const hooksDir = path.join(cwd, '.git', 'hooks');
-  if (!fs.existsSync(hooksDir)) {
-    console.error('[Code-Graph] No .git directory found. Cannot install hook.');
-    return;
+// --- CLI Entry Point ---
+
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+  const cwd = process.cwd();
+
+  try {
+    switch (command || 'generate') {
+      case 'generate':
+        await new ProjectMapper(cwd).generate();
+        break;
+      case 'init':
+        await ProjectInitializer.init(cwd);
+        break;
+      case 'reflect':
+        await ReflectionManager.add(args[0], args.slice(1).join(' '));
+        break;
+      case 'install-hook':
+        await ProjectInitializer.init(cwd);
+        await installGitHook(cwd);
+        break;
+      case 'watch':
+        startWatcher(cwd);
+        break;
+      default:
+        console.log('Usage: code-graph [generate|init|reflect|install-hook|watch]');
+    }
+  } catch (err) {
+    console.error(`[Code-Graph] Critical Error: ${err.message}`);
+    process.exit(1);
   }
-  const hookPath = path.join(hooksDir, 'pre-commit');
-  const hookContent = `#!/bin/sh\n# Code-Graph pre-commit hook\nnode "${__filename}" generate\ngit add "${DEFAULT_MAP_FILE}"\n`;
-  fs.writeFileSync(hookPath, hookContent, { mode: 0o755 });
-  console.log('[Code-Graph] Installed pre-commit hook.');
 }
 
-if (process.argv[1] && (process.argv[1] === fileURLToPath(import.meta.url) || process.argv[1].endsWith('index.js'))) {
-  const args = process.argv.slice(2);
-  const command = args[0] || 'generate';
-  if (command === 'generate') generate();
-  else if (command === 'watch') watch();
-  else if (command === 'install-hook') installHook();
-  else console.log('Usage: code-graph [generate|watch|install-hook]');
+async function installGitHook(cwd) {
+  const hookPath = path.join(cwd, '.git', 'hooks', 'pre-commit');
+  if (!fs.existsSync(path.dirname(hookPath))) return console.error('[Code-Graph] No .git directory found.');
+
+  const content = `#!/bin/sh
+# Code-Graph Advisory: Map Sync & Reflection Reminder
+echo "[Code-Graph] Validating commit..."
+
+# 1. Regenerate Map
+node "${__filename}" generate
+git add "${CONFIG.MAP_FILE}"
+
+# 2. Reflection Advisory
+# Notify if code changed but reflections didn't (Soft Nudge)
+CODE_CHANGES=$(git diff --cached --name-only | grep -E "\\.(${CONFIG.SUPPORTED_EXTENSIONS.map(e => e.slice(1)).join('|')})$")
+REFLECT_CHANGES=$(git diff --cached --name-only | grep "${CONFIG.REFLECTIONS_FILE}")
+
+if [ ! -z "$CODE_CHANGES" ] && [ -z "$REFLECT_CHANGES" ]; then
+  echo "--------------------------------------------------------"
+  echo "ℹ️  [Code-Graph] ADVISORY: Reflection Check"
+  echo "Significant code changes detected without a reflection."
+  echo "If you learned something new or fixed a non-obvious bug,"
+  echo "run 'code-graph reflect LOGIC <lesson>' before committing."
+  echo "--------------------------------------------------------"
+fi
+`;
+  await fsp.writeFile(hookPath, content, { mode: 0o755 });
+  console.log('[Code-Graph] Pre-commit Advisory installed (Soft Enforcement).');
+}
+
+function startWatcher(cwd) {
+  console.log(`[Code-Graph] Watching ${cwd}...`);
+  let timer;
+  chokidar.watch(cwd, { ignoreInitial: true, ignored: [/node_modules/, /\.git/, new RegExp(CONFIG.MAP_FILE)] })
+    .on('all', () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => new ProjectMapper(cwd).generate(), 1000);
+    });
 }
+
+if (process.argv[1] && (process.argv[1] === __filename || process.argv[1].endsWith('index.js'))) {
+  main();
+}
+
+export { CodeParser, ProjectMapper, ReflectionManager };

package/llm-code-graph.md

@@ -1,17 +1,20 @@
 # CODE_GRAPH_MAP
-> LLM_ONLY: DO NOT EDIT. COMPACT PROJECT MAP.
+> MISSION: COMPACT PROJECT MAP FOR LLM AGENTS.
+> PROTOCOL: Follow AGENT_RULES.md | MEMORY: See PROJECT_REFLECTIONS.md
 > Legend: [CORE] Entry Point, (↑N) Outgoing Deps, (↓M) Incoming Dependents
-> Notation: syms: [Name [Signature/Context]], desc: File Summary, [TAG: Context] Actionable items
+> Notation: syms: [Name [Signature/Context]], desc: File Summary, [TAG: Context]
 
-- [CORE] index.js (↑5 ↓1) [TODO: |FIXME|BUG|DEPRECATED):?\s*(.*)/i);] | desc: Contains 5 symbols.
-  - syms: [SUPPORTED_EXTENSIONS [= [], extractSymbolsAndInheritance [(content)], generate [(cwd = process.cwd()], getIgnores [(cwd, additionalLines = [])], walk [(dir, ig)]]
-- test/index.test.js (↑10 ↓0)
+- [CORE] index.js (↑6 ↓1) [TODO: |FIXME|BUG|DEPRECATED):?\s*(.*)/i,, bug: s or complex regex pitfalls., bug: s or version deprecations., bug: ,"] | desc: !usrbinenv node
+  - syms: [CONFIG [=], CodeParser [--- Core Services --- Handles extraction of symbols, edges, and metadata from source code.], ProjectInitializer [Scaffolds the initial agent-agnostic rule and reflection files.], ProjectMapper [Manages the project mapping and file generation.], ReflectionManager [Manages project reflections and lessons learned.], SUPPORTED_EXTENSIONS [: [], add [(context ? `${display} [${context}]` : display)], extract [(content)], init [(cwd)], installGitHook [(cwd)], main [|app|server|cli)\./i.test(path.basename(relPath))], processFile [(fullPath, relPath)], walk [(dir, ig)]]
+- [CORE] test/index.test.js (↑10 ↓0) | desc: 
+  - syms: []
 
 ## GRAPH EDGES
 [index.js] -> [imports] -> [chokidar]
 [index.js] -> [imports] -> [fs]
 [index.js] -> [imports] -> [ignore]
 [index.js] -> [imports] -> [path]
+[index.js] -> [imports] -> [symbols]
 [index.js] -> [imports] -> [url]
 [test/index.test.js] -> [imports] -> [assert]
 [test/index.test.js] -> [imports] -> [fs]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-llm",
-  "version": "1.6.0",
+  "version": "2.1.0",
   "description": "Compact, language-agnostic codebase mapper for LLM token efficiency.",
   "main": "index.js",
   "bin": {

package/test/index.test.js

@@ -4,11 +4,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'url';
 import { 
-  extractSymbolsAndInheritance,
-  extractEdges,
-  getIgnores, 
+  CodeParser,
+  ProjectMapper,
+  ReflectionManager,
   SUPPORTED_EXTENSIONS,
-  generate
+  CONFIG
 } from '../index.js';
 
 test('extractSymbols - JS/TS Docstrings', () => {
@@ -18,7 +18,7 @@ test('extractSymbols - JS/TS Docstrings', () => {
      */
     function testFunc(a, b) {}
   `;
-  const { symbols } = extractSymbolsAndInheritance(code);
+  const { symbols } = CodeParser.extract(code);
   assert.ok(symbols.some(s => s.includes('testFunc') && s.includes('This is a test function')));
 });
 
@@ -28,8 +28,7 @@ test('extractSymbols - Signature Fallback', () => {
       return true;
     }
   `;
-  const { symbols } = extractSymbolsAndInheritance(code);
-  // Matches "noDocFunc [ (arg1: string, arg2: number)]"
+  const { symbols } = CodeParser.extract(code);
   assert.ok(symbols.some(s => s.includes('noDocFunc') && s.includes('arg1: string, arg2: number')));
 });
 
@@ -38,7 +37,7 @@ test('extractSymbols - Flutter/Dart Noise Reduction', () => {
     const SizedBox(height: 10);
     void realFunction() {}
   `;
-  const { symbols } = extractSymbolsAndInheritance(code);
+  const { symbols } = CodeParser.extract(code);
   assert.ok(symbols.some(s => s.includes('realFunction')));
   assert.ok(!symbols.some(s => s.includes('SizedBox')));
 });
@@ -49,7 +48,7 @@ test('extractInheritance - Class relationships', () => {
     interface IRepository implements IBase {}
     class MyWidget : StatelessWidget {}
   `;
-  const { inheritance } = extractSymbolsAndInheritance(code);
+  const { inheritance } = CodeParser.extract(code);
   assert.ok(inheritance.some(i => i.child === 'AdminUser' && i.parent === 'BaseUser'));
   assert.ok(inheritance.some(i => i.child === 'IRepository' && i.parent === 'IBase'));
   assert.ok(inheritance.some(i => i.child === 'MyWidget' && i.parent === 'StatelessWidget'));
@@ -61,7 +60,7 @@ test('extractEdges - Imports and includes', () => {
     const other = require('other-module');
     #include "header.h"
   `;
-  const edges = extractEdges(code);
+  const { edges } = CodeParser.extract(code);
   assert.ok(edges.includes('./local-file'));
   assert.ok(edges.includes('other-module'));
   assert.ok(edges.includes('header.h'));
@@ -75,20 +74,57 @@ test('extractSymbols - Java/Spring Annotations', () => {
         public String hello() { return "hi"; }
     }
   `;
-  const { symbols } = extractSymbolsAndInheritance(code);
+  const { symbols } = CodeParser.extract(code);
   assert.ok(symbols.some(s => s.includes('@RestController MyController')));
-  // Note: Strings are stripped during extraction to avoid false positives
   assert.ok(symbols.some(s => s.includes('@GetMapping() hello')));
 });
 
 test('getIgnores - Default Patterns', () => {
-  const ig = getIgnores(process.cwd());
+  const mapper = new ProjectMapper(process.cwd());
+  const ig = mapper.getIgnores(process.cwd(), CONFIG.DEFAULT_IGNORES);
   assert.strictEqual(ig.ignores('.git/'), true);
   assert.strictEqual(ig.ignores('node_modules/'), true);
   assert.strictEqual(ig.ignores('.idea/'), true);
   assert.strictEqual(ig.ignores('.dart_tool/'), true);
 });
 
+test('ReflectionManager - Add and Deduplicate', async () => {
+  const tempReflectFile = path.join(process.cwd(), CONFIG.REFLECTIONS_FILE);
+  const backupExists = fs.existsSync(tempReflectFile);
+  let backupContent = '';
+  if (backupExists) backupContent = fs.readFileSync(tempReflectFile, 'utf8');
+
+  // Test Initial Add
+  const lesson = "Unique test lesson for reflection";
+  await ReflectionManager.add('TEST', lesson);
+  const content = fs.readFileSync(tempReflectFile, 'utf8');
+  assert.ok(content.includes(lesson));
+
+  // Test Deduplication
+  const logSpy = [];
+  const originalLog = console.log;
+  console.log = (msg) => logSpy.push(msg);
+  
+  await ReflectionManager.add('TEST', lesson);
+  
+  console.log = originalLog;
+  assert.ok(logSpy.includes('[Code-Graph] Reflection already exists.'));
+
+  // Restore
+  if (backupExists) fs.writeFileSync(tempReflectFile, backupContent);
+  else fs.unlinkSync(tempReflectFile);
+});
+
+test('ProjectMapper - Format Output Header', () => {
+  const mapper = new ProjectMapper(process.cwd());
+  mapper.files = [{ path: 'test.js', symbols: [], tags: [], isCore: true, outCount: 0, desc: 'test' }];
+  const output = mapper.formatOutput();
+  
+  assert.ok(output.includes('MISSION: COMPACT PROJECT MAP FOR LLM AGENTS.'));
+  assert.ok(output.includes('PROTOCOL: Follow AGENT_RULES.md'));
+  assert.ok(output.includes('MEMORY: See PROJECT_REFLECTIONS.md'));
+});
+
 test('Recursive Ignore Simulation (Logic Check)', async () => {
   const tempDir = path.join(process.cwd(), 'temp_test_dir');
   if (fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true });
@@ -97,14 +133,13 @@ test('Recursive Ignore Simulation (Logic Check)', async () => {
   const subDir = path.join(tempDir, 'subdir');
   fs.mkdirSync(subDir);
   
-  // Create a file that should be ignored by subdir/.gitignore
   fs.writeFileSync(path.join(subDir, 'ignored.js'), 'function ignored() {}');
   fs.writeFileSync(path.join(subDir, 'included.js'), 'function included() {}');
   fs.writeFileSync(path.join(subDir, '.gitignore'), 'ignored.js');
   
-  await generate(tempDir);
+  await new ProjectMapper(tempDir).generate();
   
-  const mapPath = path.join(tempDir, 'llm-code-graph.md');
+  const mapPath = path.join(tempDir, CONFIG.MAP_FILE);
   const mapContent = fs.readFileSync(mapPath, 'utf8');
   
   assert.ok(mapContent.includes('included.js'));