code-graph-llm 1.2.0 → 1.4.1

package/README.md

@@ -3,12 +3,14 @@
 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.
 
 ## Features
-- **Smart Context Extraction:** Captures JSDoc, Python docstrings, and preceding comments for files and symbols.
-- **Signature Fallback:** Automatically extracts function signatures (parameters/types) if documentation is missing.
-- **Compact & Dense:** Optimized for LLM token efficiency, replacing expensive recursive file scans.
-- **Language-Agnostic:** Optimized regex support for JS/TS, Python, Go, Rust, Java, C#, C/C++, Swift, PHP, Ruby, Dart, and more.
-- **Recursive Ignore Logic:** Deeply respects `.gitignore` and standard excludes (`node_modules`, `.git`).
-- **Live Sync:** Continuous background updates or Git pre-commit hooks.
+- **Structural Knowledge Graph:** Captures relationships between files and classes:
+  - **Dependencies:** Tracks `imports`, `requires`, and `includes` across files.
+  - **Inheritance:** Maps `extends`, `implements`, and class hierarchies.
+- **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.
+- **Compact & Dense:** Optimized for LLM token efficiency with a dedicated `## GRAPH EDGES` section.
+- **Language-Agnostic:** Support for JS/TS, Python, Go, Rust, Java, C#, C/C++, Swift, PHP, Ruby, Dart, and more.
 
 ## Installation
 
@@ -36,12 +38,16 @@ code-graph install-hook
 ## LLM Usage & Token Efficiency
 
 ### The "Read First" Strategy
-Instruct your LLM agent to read `llm-code-graph.md` as its first step. The file uses a dense format that provides immediate architectural context:
+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:
 
 **Example Map Entry:**
 ```markdown
-- src/auth.js | desc: Handles user authentication and JWT validation.
+- src/auth.js | desc: Handles user authentication.
   - syms: [login [ (username, password) ], validateToken [ (token: string) ]]
+
+## GRAPH EDGES
+[src/auth.js] -> [imports] -> [jwt-library]
+[AdminUser] -> [inherits] -> [BaseUser]
 ```
 
 **Example System Prompt:**
@@ -76,13 +82,9 @@ fn main() {
 ```
 
 ## How it works
-1. **File Scanning:** Recursively walks the directory, ignoring patterns in `.gitignore`.
-2. **Context Extraction:** Scans for classes, functions, and variables.
-3. **Docstring Capture:** If a symbol has a preceding comment (`//`, `/**`, `#`, `"""`), it's captured as a description.
-4. **Signature Capture:** If no comment is found, it captures the declaration signature (parameters) as a fallback.
-5. **Compilation:** Writes a single, minified `llm-code-graph.md` file designed for machine consumption.
-
-## Publishing as a Package
-To share your own version:
-1. `npm login`
-2. `npm publish --access public`
+1. **File Scanning:** Recursively walks the directory, ignoring patterns in `.gitignore` (recursive).
+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.

package/index.js

@@ -13,76 +13,93 @@ const IGNORE_FILE = '.gitignore';
 const DEFAULT_MAP_FILE = 'llm-code-graph.md';
 
 const SYMBOL_REGEXES = [
-  // Types, Classes, Interfaces, and Containers (Universal)
-  /\b(?:class|interface|type|struct|enum|protocol|extension|trait|module|namespace|object)\s+([a-zA-Z_]\w*)/g,
+  // Types, Classes, Interfaces (Universal) with Inheritance support
+  // Captures: class Name extends Parent, interface Name implements Base
+  /\b(?:class|interface|type|struct|enum|protocol|extension|trait|module|namespace|object)\s+([a-zA-Z_]\w*)(?:\s+(?:extends|implements|:)\s+([a-zA-Z_]\w*(?:\s*,\s*[a-zA-Z_]\w*)*))?/g,
   
-  // Explicit Function Keywords (JS, Python, Go, Rust, Ruby, PHP, Swift, Kotlin, Dart)
+  // Explicit Function Keywords
   /\b(?:function|def|fn|func|fun|method|procedure|sub|routine)\s+([a-zA-Z_]\w*)/g,
   
-  // C-style / Java / C# / TypeScript Method Patterns
-  // Matches: ReturnType Name(...) or AccessModifier Name(...)
-  /\b(?:void|async|public|private|protected|static|virtual|override|readonly|int|float|double|char|bool|string|val|var|let|const|final)\s+([a-zA-Z_]\w*)(?=\s*\(|(?:\s*:\s*\w+)?\s*=>)/g,
+  // Method/Var Declarations (C-style, Java, C#, TS, Dart)
+  /\b(?:void|async|public|private|protected|static|virtual|override|readonly|int|float|double|char|bool|string|val|var|let|final)\s+([a-zA-Z_]\w*)(?=\s*(?:\([^)]*\)|[a-zA-Z_]\w*)\s*(?:\{|=>|;|=))/g,
   
-  // Exported symbols (JS/TS specific but captures named exports)
-  /\bexport\s+(?:default\s+)?(?:const|let|var|function|class|type|interface|enum|async|val)\s+([a-zA-Z_]\w*)/g,
-  
-  // Ruby: def name, class Name, module Name (defs covered by Explicit Function Keywords)
-  
-  // PHP: class Name, interface Name, trait Name, function Name
-  
-  // Swift: func name, class Name, struct Name, protocol Name, extension Name
-  
-  // Dart: class Name, void name, var name (void/var covered by C-style pattern)
+  // 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'
+  '.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) {
-  const ig = ignore().add(['.git/', 'node_modules/', DEFAULT_MAP_FILE, 'package-lock.json', '.idea/', 'build/', 'dist/', 'bin/', 'obj/']);
+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'));
   }
+  if (additionalLines.length > 0) {
+    ig.add(additionalLines);
+  }
   return ig;
 }
 
-export function extractSymbols(content) {
+export function extractSymbolsAndInheritance(content) {
   const symbols = [];
+  const inheritance = [];
+  
+  // Create a version of content without comments to find symbols accurately
+  const noComments = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
+
   for (const regex of SYMBOL_REGEXES) {
     let match;
     regex.lastIndex = 0;
-    while ((match = regex.exec(content)) !== null) {
+    while ((match = regex.exec(noComments)) !== null) {
       if (match[1]) {
         const symbolName = match[1];
-        if (['if', 'for', 'while', 'switch', 'return', 'await', 'yield'].includes(symbolName)) continue;
+        if (['if', 'for', 'while', 'switch', 'return', 'await', 'yield', 'const', 'new', 'let', 'var'].includes(symbolName)) continue;
+
+        // Capture inheritance if present (match[2])
+        if (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;
 
-        // 1. Extract preceding comment/docstring
-        const linesBefore = content.substring(0, match.index).split('\n');
+        const linesBefore = content.substring(0, posMatch.index).split('\n');
         let comment = '';
-        for (let i = linesBefore.length - 1; i >= 0; i--) {
+        // 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('#')) {
+          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 > 80) break; 
-          } else if (line === '' && comment === '') {
-            continue;
-          } else {
-            break;
-          }
+            if (comment.length > 100) break; 
+          } else if (line === '' && comment === '') continue;
+          else break;
         }
 
-        // 2. Backup: Extract Signature (Parameters/Type) if no comment
         let context = comment;
         if (!context) {
-          const remainingLine = content.substring(match.index + match[0].length);
-          // Match until the first opening brace or colon or end of line, but include balanced parentheses
+          const remainingLine = content.substring(posMatch.index + symbolName.length);
           const sigMatch = remainingLine.match(/^\s*(\([^)]*\)|[^\n{;]*)/);
           if (sigMatch && sigMatch[1].trim()) {
             context = sigMatch[1].trim();
@@ -93,99 +110,136 @@ export function extractSymbols(content) {
       }
     }
   }
-  return Array.from(new Set(symbols)).sort();
+  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];
+        if (dep.length > 1 && !['style', 'react', 'vue', 'flutter'].includes(dep.toLowerCase())) {
+          dependencies.add(dep);
+        }
+      }
+    }
+  }
+  return Array.from(dependencies).sort();
 }
 
-export async function generate(cwd = process.cwd()) {
-  const ig = getIgnores(cwd);
+async function generate(cwd = process.cwd()) {
   const files = [];
+  const allEdges = [];
+
+  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);
+    }
 
-  function walk(dir) {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      let relativePath = path.relative(cwd, fullPath);
+      const relativePath = path.relative(cwd, fullPath);
       const normalizedPath = relativePath.replace(/\\/g, '/');
       const isDirectory = entry.isDirectory();
       const checkPath = isDirectory ? `${normalizedPath}/` : normalizedPath;
 
-      if (ig.ignores(checkPath)) continue;
+      if (localIg.ignores(checkPath)) continue;
 
       if (isDirectory) {
-        walk(fullPath);
+        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
-          const firstLines = content.split('\n').slice(0, 5);
+          const lines = content.split('\n');
           let fileDesc = '';
-          for (const line of firstLines) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith('//') || trimmed.startsWith('#') || trimmed.startsWith('/*')) {
-              fileDesc += trimmed.replace(/[\/*#]/g, '').trim() + ' ';
+          for (let i = 0; i < Math.min(10, lines.length); i++) {
+            const line = lines[i].trim();
+            if (line.startsWith('#!') || line === '') continue;
+            if (line.startsWith('//') || line.startsWith('#') || line.startsWith('/*')) {
+              fileDesc += line.replace(/[\/*#]/g, '').trim() + ' ';
+            } else {
+              break; 
             }
           }
 
-          const symbols = extractSymbols(content);
+          const { symbols, inheritance } = extractSymbolsAndInheritance(content);
+          const dependencies = extractEdges(content);
+          
+          if (!fileDesc.trim() && symbols.length > 0) fileDesc = `Contains ${symbols.length} symbols.`;
           
-          // Backup: If no file description, provide a summary
-          if (!fileDesc.trim() && symbols.length > 0) {
-            fileDesc = `Contains ${symbols.length} symbols.`;
-          }
-
           files.push({ path: normalizedPath, desc: fileDesc.trim(), symbols });
-        } else {
-           files.push({ path: normalizedPath, desc: '', symbols: [] });
+          
+          // Collect Edges
+          dependencies.forEach(dep => {
+            allEdges.push(`[${normalizedPath}] -> [imports] -> [${dep}]`);
+          });
+          inheritance.forEach(inh => {
+            allEdges.push(`[${inh.child}] -> [inherits] -> [${inh.parent}]`);
+          });
         }
       }
     }
   }
 
-  walk(cwd);
+  walk(cwd, getIgnores(cwd));
 
-  const output = files.map(f => {
+  const nodesOutput = files.map(f => {
     const descStr = f.desc ? ` | desc: ${f.desc.substring(0, 100)}` : '';
     const symStr = f.symbols.length > 0 ? `\n  - syms: [${f.symbols.join(', ')}]` : '';
     return `- ${f.path}${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\n`;
-  fs.writeFileSync(path.join(cwd, DEFAULT_MAP_FILE), header + output);
+  fs.writeFileSync(path.join(cwd, DEFAULT_MAP_FILE), header + nodesOutput + edgesOutput);
   console.log(`[Code-Graph] Updated ${DEFAULT_MAP_FILE}`);
 }
 
+export { generate };
+
 export function watch(cwd = process.cwd()) {
   console.log(`[Code-Graph] Watching for changes in ${cwd}...`);
-  const ig = getIgnores(cwd);
-  
+  let timeout;
+  const debouncedGenerate = () => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => generate(cwd), 500);
+  };
+
   const watcher = chokidar.watch(cwd, {
     ignored: (p) => {
         if (p === cwd) return false;
-        const rel = path.relative(cwd, p).replace(/\\/g, '/');
-        // We must check if p is a directory to append the trailing slash
-        // Since chokidar's ignore function is synchronous, we use fs.statSync
-        try {
-            const stats = fs.statSync(p);
-            const checkPath = stats.isDirectory() ? `${rel}/` : rel;
-            return ig.ignores(checkPath);
-        } catch (e) {
-            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
   });
 
-  let timeout;
-  const debouncedGenerate = () => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => generate(cwd), 500);
-  };
-
   watcher.on('all', (event, path) => {
-    console.log(`[Code-Graph] Change detected: ${event} on ${path}`);
     debouncedGenerate();
   });
 }
@@ -196,10 +250,8 @@ export function installHook(cwd = process.cwd()) {
     console.error('[Code-Graph] No .git directory found. Cannot install hook.');
     return;
   }
-
   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.');
 }
@@ -207,14 +259,8 @@ export function installHook(cwd = process.cwd()) {
 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]');
-  }
+  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]');
 }

package/llm-code-graph.md

@@ -1,10 +1,29 @@
 # CODE_GRAPH_MAP
 > LLM_ONLY: DO NOT EDIT. COMPACT PROJECT MAP.
 
-- .gitignore
-- index.js | desc: !usrbinenv node
-  - syms: [Name [Dart:], Name [PHP: class Name, interface Name, trait Name,], Name [PHP: class Name, interface Name,], Name [PHP: class Name,], Name [PHP:], Name [Ruby: def name, class Name,], Name [Ruby: def name,], Name [Swift: func name, class Name, struct Name, protocol Name,], Name [Swift: func name, class Name, struct Name,], Name [Swift: func name, class Name,], Name [Swift: func name,], SUPPORTED_EXTENSIONS [= [], extractSymbols [(content)], function [generate(cwd = process.cwd())], generate [(cwd = process.cwd()], getIgnores [(cwd)], installHook [(cwd = process.cwd()], is [We must check if p is a directory to append the trailing slash Since chokidar's ignore], name [Dart: class Name, void name,], name [Ruby:], name [Swift:], walk [(dir)], watch [(cwd = process.cwd()]]
-- package.json
-- README.md
-- test/index.test.js | desc: Contains 5 symbols.
-  - syms: [noDocFunc [(arg1: string, arg2: number)], py_func [(x)], py_func [Note: Current regex captures '], py_func_2 [This is a python comment], testFunc [This is a test function]]
+- index.js | desc: Contains 7 symbols.
+  - syms: [SUPPORTED_EXTENSIONS [= [], extractSymbolsAndInheritance [(content)], generate [(cwd = process.cwd()], getIgnores [(cwd, additionalLines = [])], installHook [(cwd = process.cwd()], walk [(dir, ig)], watch [(cwd = process.cwd()]]
+- test/index.test.js | desc: Contains 8 symbols.
+  - syms: [AdminUser [extends BaseUser], IRepository [implements IBase], MyWidget [: StatelessWidget], ignored [by subdir/.gitignore], included [.js'), 'function included()], noDocFunc [(arg1: string, arg2: number)], realFunction [()], testFunc [This is a test function]]
+
+## GRAPH EDGES
+[AdminUser] -> [inherits] -> [BaseUser]
+[IRepository] -> [inherits] -> [IBase]
+[MyWidget] -> [inherits] -> [StatelessWidget]
+[index.js] -> [imports] -> [chokidar]
+[index.js] -> [imports] -> [dependencies]
+[index.js] -> [imports] -> [fs]
+[index.js] -> [imports] -> [ignore]
+[index.js] -> [imports] -> [new]
+[index.js] -> [imports] -> [path]
+[index.js] -> [imports] -> [url]
+[test/index.test.js] -> [imports] -> [../index.js]
+[test/index.test.js] -> [imports] -> [./local-file]
+[test/index.test.js] -> [imports] -> [assert]
+[test/index.test.js] -> [imports] -> [fs]
+[test/index.test.js] -> [imports] -> [header.h]
+[test/index.test.js] -> [imports] -> [node]
+[test/index.test.js] -> [imports] -> [other-module]
+[test/index.test.js] -> [imports] -> [path]
+[test/index.test.js] -> [imports] -> [test]
+[test/index.test.js] -> [imports] -> [url]

package/package.json

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

package/test/index.test.js

@@ -3,16 +3,12 @@ import test from 'node:test';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'url';
-
-// Import the core functions by reading the file and eval-ing or refactoring.
-// For simplicity in this environment, I will redefine the core logic in the test 
-// or point to the index.js if it was exported. 
-// Since index.js is a CLI, I'll extract the logic into a testable state.
-
 import { 
-  extractSymbols, 
+  extractSymbolsAndInheritance,
+  extractEdges,
   getIgnores, 
-  SUPPORTED_EXTENSIONS 
+  SUPPORTED_EXTENSIONS,
+  generate
 } from '../index.js';
 
 test('extractSymbols - JS/TS Docstrings', () => {
@@ -22,7 +18,7 @@ test('extractSymbols - JS/TS Docstrings', () => {
      */
     function testFunc(a, b) {}
   `;
-  const symbols = extractSymbols(code);
+  const { symbols } = extractSymbolsAndInheritance(code);
   assert.ok(symbols.some(s => s.includes('testFunc') && s.includes('This is a test function')));
 });
 
@@ -32,28 +28,43 @@ test('extractSymbols - Signature Fallback', () => {
       return true;
     }
   `;
-  const symbols = extractSymbols(code);
+  const { symbols } = extractSymbolsAndInheritance(code);
+  // Matches "noDocFunc [ (arg1: string, arg2: number)]"
   assert.ok(symbols.some(s => s.includes('noDocFunc') && s.includes('arg1: string, arg2: number')));
 });
 
-test('extractSymbols - Python Docstrings', () => {
+test('extractSymbols - Flutter/Dart Noise Reduction', () => {
   const code = `
-    def py_func(x):
-        """
-        Python docstring test
-        """
-        pass
+    const SizedBox(height: 10);
+    void realFunction() {}
   `;
-  const symbols = extractSymbols(code);
-  // Note: Current regex captures 'def py_func'. Docstring is captured if it's ABOVE the def.
-  // Let's test the comment above pattern which is common for our current extractor.
-  const codeWithComment = `
-    # This is a python comment
-    def py_func_2(x):
-        pass
+  const { symbols } = extractSymbolsAndInheritance(code);
+  assert.ok(symbols.some(s => s.includes('realFunction')));
+  assert.ok(!symbols.some(s => s.includes('SizedBox')));
+});
+
+test('extractInheritance - Class relationships', () => {
+  const code = `
+    class AdminUser extends BaseUser {}
+    interface IRepository implements IBase {}
+    class MyWidget : StatelessWidget {}
+  `;
+  const { inheritance } = extractSymbolsAndInheritance(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'));
+});
+
+test('extractEdges - Imports and includes', () => {
+  const code = `
+    import { something } from './local-file';
+    const other = require('other-module');
+    #include "header.h"
   `;
-  const symbols2 = extractSymbols(codeWithComment);
-  assert.ok(symbols2.some(s => s.includes('py_func_2') && s.includes('This is a python comment')));
+  const edges = extractEdges(code);
+  assert.ok(edges.includes('./local-file'));
+  assert.ok(edges.includes('other-module'));
+  assert.ok(edges.includes('header.h'));
 });
 
 test('getIgnores - Default Patterns', () => {
@@ -61,12 +72,29 @@ test('getIgnores - Default Patterns', () => {
   assert.strictEqual(ig.ignores('.git/'), true);
   assert.strictEqual(ig.ignores('node_modules/'), true);
   assert.strictEqual(ig.ignores('.idea/'), true);
-  assert.strictEqual(ig.ignores('src/main.js'), false);
+  assert.strictEqual(ig.ignores('.dart_tool/'), true);
 });
 
-test('Supported Extensions', () => {
-  assert.ok(SUPPORTED_EXTENSIONS.includes('.js'));
-  assert.ok(SUPPORTED_EXTENSIONS.includes('.py'));
-  assert.ok(SUPPORTED_EXTENSIONS.includes('.go'));
-  assert.ok(SUPPORTED_EXTENSIONS.includes('.rs'));
+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 });
+  fs.mkdirSync(tempDir);
+  
+  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);
+  
+  const mapPath = path.join(tempDir, 'llm-code-graph.md');
+  const mapContent = fs.readFileSync(mapPath, 'utf8');
+  
+  assert.ok(mapContent.includes('included.js'));
+  assert.ok(!mapContent.includes('ignored.js'));
+  
+  fs.rmSync(tempDir, { recursive: true });
 });