@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/core/ASTWorker.js

@@ -3,17 +3,30 @@
  *
  * Receives: { filePath, moduleId, moduleName }
  * Returns: { collections } - extracted AST data for GraphBuilder
+ *
+ * Uses ScopeTracker for semantic ID generation (REG-133).
+ * IDs are stable and don't change when unrelated code is added/removed.
  */
 import { parentPort } from 'worker_threads';
 import { readFileSync } from 'fs';
+import { basename } from 'path';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
+import { ClassNode } from './nodes/ClassNode.js';
+import { ImportNode } from './nodes/ImportNode.js';
+import { ExportNode } from './nodes/ExportNode.js';
+import { ScopeTracker } from './ScopeTracker.js';
+import { computeSemanticId } from './SemanticId.js';
+import { getLine, getColumn } from '../plugins/analysis/ast/utils/location.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = traverseModule.default || traverseModule;
 // Simplified visitors for extraction (no graph access needed)
 import { ExpressionEvaluator } from '../plugins/analysis/ast/ExpressionEvaluator.js';
 /**
  * Parse a single module and extract all collections
+ *
+ * Uses ScopeTracker for semantic ID generation - IDs are stable
+ * and don't change when unrelated code is added/removed.
  */
 function parseModule(filePath, moduleId, moduleName) {
     const code = readFileSync(filePath, 'utf-8');
@@ -21,6 +34,9 @@ function parseModule(filePath, moduleId, moduleName) {
         sourceType: 'module',
         plugins: ['jsx', 'typescript']
     });
+    // Create ScopeTracker for semantic ID generation
+    // Use basename for shorter, more readable IDs
+    const scopeTracker = new ScopeTracker(basename(filePath));
     // Collections to extract
     const collections = {
         functions: [],
@@ -40,17 +56,7 @@ function parseModule(filePath, moduleId, moduleName) {
         literals: [],
         variableAssignments: []
     };
-    // Counters for unique IDs
-    const counters = {
-        ifScope: 0,
-        scope: 0,
-        varDecl: 0,
-        callSite: 0,
-        function: 0,
-        httpRequest: 0,
-        literal: 0
-    };
-    // Processed nodes tracking
+    // Processed nodes tracking (still needed for deduplication)
     const processed = {
         callSites: new Set(),
         methodCalls: new Set(),
@@ -78,54 +84,35 @@ function parseModule(filePath, moduleId, moduleName) {
                     importedName = spec.imported?.name || spec.local.name;
                     localName = spec.local.name;
                 }
-                collections.imports.push({
-                    id: `IMPORT#${localName}#${filePath}#${node.loc.start.line}`,
-                    type: 'IMPORT',
-                    name: localName,
-                    importedName,
-                    source,
-                    file: filePath,
-                    line: node.loc.start.line
-                });
+                // Babel AST guarantees node.loc exists with locations: true option
+                const importNode = ImportNode.create(localName, // name
+                filePath, // file
+                getLine(node), // line (non-null - Babel guarantees location)
+                0, // column (not available in this worker)
+                source, // source
+                { imported: importedName, local: localName });
+                collections.imports.push(importNode);
             });
         }
     });
-    // Extract exports
+    // Extract exports using semantic IDs (via createWithContext)
     traverse(ast, {
         ExportNamedDeclaration(path) {
             const node = path.node;
             if (node.declaration) {
                 if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
-                    collections.exports.push({
-                        id: `EXPORT#${node.declaration.id.name}#${filePath}#${node.loc.start.line}`,
-                        type: 'EXPORT',
-                        name: node.declaration.id.name,
-                        exportType: 'function',
-                        file: filePath,
-                        line: node.loc.start.line
-                    });
+                    const exportNode = ExportNode.createWithContext(node.declaration.id.name, scopeTracker.getContext(), { line: getLine(node), column: 0 }, { exportType: 'named' });
+                    collections.exports.push(exportNode);
                 }
                 else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
-                    collections.exports.push({
-                        id: `EXPORT#${node.declaration.id.name}#${filePath}#${node.loc.start.line}`,
-                        type: 'EXPORT',
-                        name: node.declaration.id.name,
-                        exportType: 'class',
-                        file: filePath,
-                        line: node.loc.start.line
-                    });
+                    const exportNode = ExportNode.createWithContext(node.declaration.id.name, scopeTracker.getContext(), { line: getLine(node), column: 0 }, { exportType: 'named' });
+                    collections.exports.push(exportNode);
                 }
                 else if (node.declaration.type === 'VariableDeclaration') {
                     node.declaration.declarations.forEach(decl => {
                         if (decl.id.type === 'Identifier') {
-                            collections.exports.push({
-                                id: `EXPORT#${decl.id.name}#${filePath}#${node.loc.start.line}`,
-                                type: 'EXPORT',
-                                name: decl.id.name,
-                                exportType: 'variable',
-                                file: filePath,
-                                line: node.loc.start.line
-                            });
+                            const exportNode = ExportNode.createWithContext(decl.id.name, scopeTracker.getContext(), { line: getLine(node), column: 0 }, { exportType: 'named' });
+                            collections.exports.push(exportNode);
                         }
                     });
                 }
@@ -135,38 +122,32 @@ function parseModule(filePath, moduleId, moduleName) {
                     if (spec.type !== 'ExportSpecifier')
                         return;
                     const exportedName = spec.exported.type === 'Identifier' ? spec.exported.name : spec.exported.value;
-                    collections.exports.push({
-                        id: `EXPORT#${exportedName}#${filePath}#${node.loc.start.line}`,
-                        type: 'EXPORT',
-                        name: exportedName,
-                        localName: spec.local.name,
-                        file: filePath,
-                        line: node.loc.start.line
+                    const exportNode = ExportNode.createWithContext(exportedName, scopeTracker.getContext(), { line: getLine(node), column: 0 }, {
+                        local: spec.local.name,
+                        exportType: 'named'
                     });
+                    collections.exports.push(exportNode);
                 });
             }
         },
         ExportDefaultDeclaration(path) {
             const node = path.node;
-            let name = 'default';
+            let localName = 'default';
             if (node.declaration.type === 'Identifier') {
-                name = node.declaration.name;
+                localName = node.declaration.name;
             }
             else if ('id' in node.declaration && node.declaration.id) {
-                name = node.declaration.id.name;
+                localName = node.declaration.id.name;
             }
-            collections.exports.push({
-                id: `EXPORT#default#${filePath}#${node.loc.start.line}`,
-                type: 'EXPORT',
-                name: 'default',
-                localName: name,
-                isDefault: true,
-                file: filePath,
-                line: node.loc.start.line
+            const exportNode = ExportNode.createWithContext('default', scopeTracker.getContext(), { line: getLine(node), column: 0 }, {
+                local: localName,
+                default: true,
+                exportType: 'default'
             });
+            collections.exports.push(exportNode);
         }
     });
-    // Extract top-level variables
+    // Extract top-level variables using semantic IDs
     traverse(ast, {
         VariableDeclaration(path) {
             if (path.getFunctionParent())
@@ -176,15 +157,14 @@ function parseModule(filePath, moduleId, moduleName) {
             node.declarations.forEach(decl => {
                 if (decl.id.type === 'Identifier') {
                     const varName = decl.id.name;
-                    const line = decl.id.loc.start.line;
-                    const column = decl.id.loc.start.column;
+                    const line = getLine(decl.id);
                     const literalValue = ExpressionEvaluator.extractLiteralValue(decl.init);
                     const isLiteral = literalValue !== null;
                     const isNewExpr = decl.init?.type === 'NewExpression';
                     const shouldBeConstant = isConst && (isLiteral || isNewExpr);
-                    const varId = shouldBeConstant
-                        ? `CONSTANT#${varName}#${filePath}#${line}:${column}:${counters.varDecl++}`
-                        : `VARIABLE#${varName}#${filePath}#${line}:${column}:${counters.varDecl++}`;
+                    // Generate semantic ID using ScopeTracker
+                    const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+                    const varId = computeSemanticId(nodeType, varName, scopeTracker.getContext());
                     collections.variableDeclarations.push({
                         id: varId,
                         type: shouldBeConstant ? 'CONSTANT' : 'VARIABLE',
@@ -207,7 +187,7 @@ function parseModule(filePath, moduleId, moduleName) {
             });
         }
     });
-    // Extract functions and classes
+    // Extract functions and classes using semantic IDs
     traverse(ast, {
         FunctionDeclaration(path) {
             if (path.getFunctionParent())
@@ -216,33 +196,38 @@ function parseModule(filePath, moduleId, moduleName) {
             if (!node.id)
                 return;
             const funcName = node.id.name;
-            const functionId = `FUNCTION#${funcName}#${filePath}#${node.loc.start.line}:${node.loc.start.column}`;
+            // Generate semantic ID using ScopeTracker
+            const functionId = computeSemanticId('FUNCTION', funcName, scopeTracker.getContext());
             collections.functions.push({
                 id: functionId,
-                stableId: functionId,
                 type: 'FUNCTION',
                 name: funcName,
                 file: filePath,
-                line: node.loc.start.line,
-                column: node.loc.start.column,
+                line: getLine(node),
+                column: getColumn(node),
                 async: node.async || false,
                 generator: node.generator || false,
                 exported: path.parent?.type === 'ExportNamedDeclaration' || path.parent?.type === 'ExportDefaultDeclaration'
             });
-            // Extract parameters
+            // Enter function scope for parameter extraction
+            scopeTracker.enterScope(funcName, 'FUNCTION');
+            // Extract parameters with semantic IDs
             node.params.forEach((param, index) => {
                 if (param.type === 'Identifier') {
+                    const paramId = computeSemanticId('PARAMETER', param.name, scopeTracker.getContext(), { discriminator: index });
                     collections.parameters.push({
-                        id: `PARAMETER#${param.name}#${functionId}#${index}`,
+                        id: paramId,
                         type: 'PARAMETER',
                         name: param.name,
                         index,
                         functionId,
                         file: filePath,
-                        line: param.loc.start.line
+                        line: getLine(param)
                     });
                 }
             });
+            // Exit function scope
+            scopeTracker.exitScope();
         },
         ClassDeclaration(path) {
             if (path.getFunctionParent())
@@ -251,30 +236,30 @@ function parseModule(filePath, moduleId, moduleName) {
             if (!node.id)
                 return;
             const className = node.id.name;
-            const classId = `CLASS#${className}#${filePath}#${node.loc.start.line}`;
-            collections.classDeclarations.push({
-                id: classId,
-                type: 'CLASS',
-                name: className,
-                file: filePath,
-                line: node.loc.start.line,
-                superClass: node.superClass?.name || null
-            });
-            // Extract methods
+            // Extract superClass name
+            const superClassName = node.superClass && node.superClass.type === 'Identifier'
+                ? node.superClass.name
+                : null;
+            // Create CLASS node using ClassNode.createWithContext() for semantic IDs
+            const classRecord = ClassNode.createWithContext(className, scopeTracker.getContext(), { line: getLine(node), column: getColumn(node) }, { superClass: superClassName || undefined });
+            collections.classDeclarations.push(classRecord);
+            // Enter class scope for method extraction
+            scopeTracker.enterScope(className, 'CLASS');
+            // Extract methods with semantic IDs (including class scope)
             node.body.body.forEach(member => {
                 if (member.type === 'ClassMethod' && member.key.type === 'Identifier') {
                     const methodName = member.key.name;
-                    const methodId = `METHOD#${className}.${methodName}#${filePath}#${member.loc.start.line}`;
+                    // Method ID includes class scope: file->ClassName->FUNCTION->methodName
+                    const methodId = computeSemanticId('FUNCTION', methodName, scopeTracker.getContext());
                     collections.functions.push({
                         id: methodId,
-                        stableId: methodId,
                         type: 'METHOD',
                         name: methodName,
                         className,
-                        classId,
+                        classId: classRecord.id,
                         file: filePath,
-                        line: member.loc.start.line,
-                        column: member.loc.start.column,
+                        line: getLine(member),
+                        column: getColumn(member),
                         async: member.async || false,
                         isClassMethod: true,
                         isConstructor: member.kind === 'constructor',
@@ -282,9 +267,11 @@ function parseModule(filePath, moduleId, moduleName) {
                     });
                 }
             });
+            // Exit class scope
+            scopeTracker.exitScope();
         }
     });
-    // Extract call expressions at module level
+    // Extract call expressions at module level using semantic IDs with discriminators
     traverse(ast, {
         CallExpression(path) {
             if (path.getFunctionParent())
@@ -295,14 +282,18 @@ function parseModule(filePath, moduleId, moduleName) {
                 if (processed.callSites.has(nodeKey))
                     return;
                 processed.callSites.add(nodeKey);
+                // Get discriminator for same-named calls in current scope
+                const calleeName = node.callee.name;
+                const discriminator = scopeTracker.getItemCounter(`CALL:${calleeName}`);
+                const callId = computeSemanticId('CALL', calleeName, scopeTracker.getContext(), { discriminator });
                 collections.callSites.push({
-                    id: `CALL#${node.callee.name}#${filePath}#${node.loc.start.line}:${node.loc.start.column}:${counters.callSite++}`,
+                    id: callId,
                     type: 'CALL',
-                    name: node.callee.name,
+                    name: calleeName,
                     file: filePath,
-                    line: node.loc.start.line,
+                    line: getLine(node),
                     parentScopeId: moduleId,
-                    targetFunctionName: node.callee.name
+                    targetFunctionName: calleeName
                 });
             }
             else if (node.callee.type === 'MemberExpression') {
@@ -315,14 +306,17 @@ function parseModule(filePath, moduleId, moduleName) {
                     const objectName = obj.type === 'Identifier' ? obj.name : 'this';
                     const methodName = prop.name;
                     const fullName = `${objectName}.${methodName}`;
+                    // Get discriminator for same-named method calls
+                    const discriminator = scopeTracker.getItemCounter(`CALL:${fullName}`);
+                    const callId = computeSemanticId('CALL', fullName, scopeTracker.getContext(), { discriminator });
                     collections.methodCalls.push({
-                        id: `CALL#${fullName}#${filePath}#${node.loc.start.line}:${node.loc.start.column}:${counters.callSite++}`,
+                        id: callId,
                         type: 'CALL',
                         name: fullName,
                         object: objectName,
                         method: methodName,
                         file: filePath,
-                        line: node.loc.start.line,
+                        line: getLine(node),
                         parentScopeId: moduleId
                     });
                 }

package/dist/core/CoverageAnalyzer.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CoverageAnalyzer - Calculates analysis coverage for a project
+ *
+ * Determines which files in a project have been analyzed and categorizes
+ * files into three groups:
+ * - Analyzed: Files that appear as MODULE nodes in the graph
+ * - Unsupported: Files with extensions that no indexer can handle
+ * - Unreachable: Files with supported extensions but not in the graph
+ *
+ * Usage:
+ *   const analyzer = new CoverageAnalyzer(graphBackend, '/path/to/project');
+ *   const result = await analyzer.analyze();
+ */
+import type { GraphBackend } from '@grafema/types';
+/**
+ * Coverage analysis result
+ */
+export interface CoverageResult {
+    projectPath: string;
+    total: number;
+    analyzed: {
+        count: number;
+        files: string[];
+    };
+    unsupported: {
+        count: number;
+        byExtension: Record<string, string[]>;
+    };
+    unreachable: {
+        count: number;
+        files: string[];
+        byExtension: Record<string, string[]>;
+    };
+    percentages: {
+        analyzed: number;
+        unsupported: number;
+        unreachable: number;
+    };
+}
+/**
+ * CoverageAnalyzer calculates what percentage of a codebase has been analyzed.
+ */
+export declare class CoverageAnalyzer {
+    private graph;
+    private projectPath;
+    constructor(graph: GraphBackend, projectPath: string);
+    /**
+     * Analyze the project and return coverage statistics
+     */
+    analyze(): Promise<CoverageResult>;
+    /**
+     * Get list of analyzed files from the graph (MODULE nodes)
+     */
+    private getAnalyzedFiles;
+    /**
+     * Scan project directory for all code files
+     * Respects common ignore patterns (node_modules, .git, etc.)
+     */
+    private scanProjectFiles;
+    /**
+     * Recursively walk directory and collect code files
+     */
+    private walkDirectory;
+}
+//# sourceMappingURL=CoverageAnalyzer.d.ts.map

package/dist/core/CoverageAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageAnalyzer.d.ts","sourceRoot":"","sources":["../../src/core/CoverageAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,gBAAgB,CAAC;AAwC/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KACvC,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KACvC,CAAC;IACF,WAAW,EAAE;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,WAAW,CAAS;gBAEhB,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM;IAKpD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAsExC;;OAEG;YACW,gBAAgB;IAiB9B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;OAEG;IACH,OAAO,CAAC,aAAa;CA0CtB"}

package/dist/core/CoverageAnalyzer.js

@@ -0,0 +1,198 @@
+/**
+ * CoverageAnalyzer - Calculates analysis coverage for a project
+ *
+ * Determines which files in a project have been analyzed and categorizes
+ * files into three groups:
+ * - Analyzed: Files that appear as MODULE nodes in the graph
+ * - Unsupported: Files with extensions that no indexer can handle
+ * - Unreachable: Files with supported extensions but not in the graph
+ *
+ * Usage:
+ *   const analyzer = new CoverageAnalyzer(graphBackend, '/path/to/project');
+ *   const result = await analyzer.analyze();
+ */
+import { readdirSync, existsSync, lstatSync } from 'fs';
+import { join, relative, extname } from 'path';
+/**
+ * Supported file extensions by language
+ */
+const JS_SUPPORTED = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx'];
+const RUST_SUPPORTED = ['.rs'];
+const SUPPORTED_EXTENSIONS = new Set([...JS_SUPPORTED, ...RUST_SUPPORTED]);
+/**
+ * Known code file extensions (for scanning)
+ * Files with these extensions are considered source code
+ */
+const CODE_EXTENSIONS = new Set([
+    // Supported
+    ...JS_SUPPORTED,
+    ...RUST_SUPPORTED,
+    // Unsupported but tracked
+    '.go', '.kt', '.java', '.py', '.rb', '.php', '.c', '.cpp', '.h', '.hpp',
+    '.cs', '.swift', '.scala', '.sql', '.graphql', '.gql',
+]);
+/**
+ * Directories to always skip during scanning
+ */
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.grafema',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '__pycache__',
+    'target', // Rust
+    'vendor',
+]);
+/**
+ * CoverageAnalyzer calculates what percentage of a codebase has been analyzed.
+ */
+export class CoverageAnalyzer {
+    graph;
+    projectPath;
+    constructor(graph, projectPath) {
+        this.graph = graph;
+        this.projectPath = projectPath;
+    }
+    /**
+     * Analyze the project and return coverage statistics
+     */
+    async analyze() {
+        // Step 1: Get all MODULE nodes from the graph
+        const analyzedFiles = await this.getAnalyzedFiles();
+        const analyzedSet = new Set(analyzedFiles);
+        // Step 2: Scan project for all code files
+        const allCodeFiles = this.scanProjectFiles();
+        // Step 3: Categorize files
+        const unsupportedByExt = {};
+        const unreachableByExt = {};
+        const unreachableFiles = [];
+        for (const file of allCodeFiles) {
+            if (analyzedSet.has(file)) {
+                continue; // Already analyzed
+            }
+            const ext = extname(file).toLowerCase();
+            if (SUPPORTED_EXTENSIONS.has(ext)) {
+                // Supported but not in graph = unreachable
+                unreachableFiles.push(file);
+                if (!unreachableByExt[ext]) {
+                    unreachableByExt[ext] = [];
+                }
+                unreachableByExt[ext].push(file);
+            }
+            else {
+                // Not supported = unsupported
+                if (!unsupportedByExt[ext]) {
+                    unsupportedByExt[ext] = [];
+                }
+                unsupportedByExt[ext].push(file);
+            }
+        }
+        // Calculate counts
+        const unsupportedCount = Object.values(unsupportedByExt)
+            .reduce((sum, files) => sum + files.length, 0);
+        const unreachableCount = unreachableFiles.length;
+        const analyzedCount = analyzedFiles.length;
+        const total = analyzedCount + unsupportedCount + unreachableCount;
+        // Calculate percentages (handle division by zero)
+        const percentages = {
+            analyzed: total > 0 ? Math.round((analyzedCount / total) * 100) : 0,
+            unsupported: total > 0 ? Math.round((unsupportedCount / total) * 100) : 0,
+            unreachable: total > 0 ? Math.round((unreachableCount / total) * 100) : 0,
+        };
+        return {
+            projectPath: this.projectPath,
+            total,
+            analyzed: {
+                count: analyzedCount,
+                files: analyzedFiles,
+            },
+            unsupported: {
+                count: unsupportedCount,
+                byExtension: unsupportedByExt,
+            },
+            unreachable: {
+                count: unreachableCount,
+                files: unreachableFiles,
+                byExtension: unreachableByExt,
+            },
+            percentages,
+        };
+    }
+    /**
+     * Get list of analyzed files from the graph (MODULE nodes)
+     */
+    async getAnalyzedFiles() {
+        const files = [];
+        // Use queryNodes with type: 'MODULE'
+        for await (const node of this.graph.queryNodes({ type: 'MODULE' })) {
+            if (node.file) {
+                // Store relative path for consistency
+                const relativePath = node.file.startsWith(this.projectPath)
+                    ? relative(this.projectPath, node.file)
+                    : node.file;
+                files.push(relativePath);
+            }
+        }
+        return files;
+    }
+    /**
+     * Scan project directory for all code files
+     * Respects common ignore patterns (node_modules, .git, etc.)
+     */
+    scanProjectFiles() {
+        const files = [];
+        this.walkDirectory(this.projectPath, files);
+        return files;
+    }
+    /**
+     * Recursively walk directory and collect code files
+     */
+    walkDirectory(dir, files, depth = 0) {
+        // Safety: limit recursion depth
+        if (depth > 20)
+            return;
+        if (!existsSync(dir))
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return; // Skip directories we can't read
+        }
+        for (const entry of entries) {
+            // Skip hidden files and directories
+            if (entry.startsWith('.'))
+                continue;
+            // Skip known non-source directories
+            if (SKIP_DIRS.has(entry))
+                continue;
+            const fullPath = join(dir, entry);
+            // Skip symlinks to avoid infinite loops
+            try {
+                const stat = lstatSync(fullPath);
+                if (stat.isSymbolicLink())
+                    continue;
+                if (stat.isDirectory()) {
+                    this.walkDirectory(fullPath, files, depth + 1);
+                }
+                else if (stat.isFile()) {
+                    const ext = extname(entry).toLowerCase();
+                    if (CODE_EXTENSIONS.has(ext)) {
+                        // Store relative path
+                        files.push(relative(this.projectPath, fullPath));
+                    }
+                }
+            }
+            catch {
+                // Skip files we can't stat
+                continue;
+            }
+        }
+    }
+}