@gotza02/sequential-thinking 2026.2.30 → 2026.2.32

package/dist/graph.js

@@ -1,21 +1,208 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { existsSync, readFileSync } from 'fs';
+import * as crypto from 'crypto';
 import ts from 'typescript';
+/**
+ * ConfigResolver - Handles TypeScript paths, package.json imports, and alias resolution
+ */
+class ConfigResolver {
+    rootDir;
+    tsConfig = null;
+    packageJson = null;
+    baseUrl;
+    paths = new Map();
+    imports = new Map();
+    constructor(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.baseUrl = this.rootDir;
+    }
+    async load() {
+        await this.loadTSConfig();
+        await this.loadPackageJson();
+    }
+    async loadTSConfig() {
+        const tsConfigPaths = [
+            path.join(this.rootDir, 'tsconfig.json'),
+            path.join(this.rootDir, 'tsconfig.base.json'),
+            path.join(this.rootDir, 'tsconfig.app.json'),
+        ];
+        for (const tsConfigPath of tsConfigPaths) {
+            if (existsSync(tsConfigPath)) {
+                try {
+                    const content = readFileSync(tsConfigPath, 'utf-8');
+                    this.tsConfig = JSON.parse(content);
+                    // Handle extends
+                    if (this.tsConfig?.extends) {
+                        const extendedPath = this.tsConfig.extends.startsWith('./')
+                            ? path.join(this.rootDir, this.tsConfig.extends)
+                            : path.join(this.rootDir, 'node_modules', this.tsConfig.extends);
+                        if (existsSync(extendedPath)) {
+                            const extendedContent = readFileSync(extendedPath, 'utf-8');
+                            const extendedConfig = JSON.parse(extendedContent);
+                            this.tsConfig = {
+                                ...extendedConfig,
+                                ...this.tsConfig,
+                                compilerOptions: {
+                                    ...extendedConfig?.compilerOptions,
+                                    ...this.tsConfig.compilerOptions
+                                }
+                            };
+                        }
+                    }
+                    // Parse baseUrl
+                    if (this.tsConfig?.compilerOptions?.baseUrl) {
+                        this.baseUrl = path.resolve(this.rootDir, this.tsConfig.compilerOptions.baseUrl);
+                    }
+                    // Parse paths (e.g., "@/*": ["src/*"])
+                    if (this.tsConfig?.compilerOptions?.paths) {
+                        for (const [pattern, targets] of Object.entries(this.tsConfig.compilerOptions.paths)) {
+                            const resolvedTargets = targets.map(t => path.resolve(this.baseUrl, t));
+                            this.paths.set(pattern, resolvedTargets);
+                        }
+                    }
+                    return;
+                }
+                catch (error) {
+                    console.warn(`Failed to load tsconfig from ${tsConfigPath}:`, error);
+                }
+            }
+        }
+    }
+    async loadPackageJson() {
+        const packageJsonPath = path.join(this.rootDir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            try {
+                const content = readFileSync(packageJsonPath, 'utf-8');
+                this.packageJson = JSON.parse(content);
+                // Parse ESM imports (e.g., "#internal/*": "./src/internal/*.js")
+                if (this.packageJson?.imports) {
+                    for (const [key, value] of Object.entries(this.packageJson.imports)) {
+                        if (typeof value === 'string') {
+                            this.imports.set(key, value);
+                        }
+                        else if (typeof value === 'object') {
+                            for (const [subKey, subValue] of Object.entries(value)) {
+                                this.imports.set(`${key}${subKey}`, subValue);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to load package.json:`, error);
+            }
+        }
+    }
+    /**
+     * Resolve an alias path to its actual filesystem path
+     * Examples:
+     * - "@/components/Button" -> "/project/src/components/Button"
+     * - "#/lib/utils" -> "/project/src/lib/utils"
+     */
+    resolveAlias(importPath) {
+        // Try TypeScript paths first
+        for (const [pattern, targets] of this.paths.entries()) {
+            // Convert pattern to regex (e.g., "@/*" -> "^@/(.*)$")
+            const patternRegex = new RegExp('^' + pattern.replace(/\*/g, '(.*)') + '$');
+            const match = importPath.match(patternRegex);
+            if (match) {
+                const wildcard = match[1];
+                for (const target of targets) {
+                    const resolved = target.replace(/\*/g, wildcard || '');
+                    if (existsSync(resolved) || existsSync(resolved + '.ts') ||
+                        existsSync(resolved + '.tsx') || existsSync(resolved + '.js')) {
+                        return path.resolve(resolved);
+                    }
+                    // Try with index
+                    const indexResolved = path.join(resolved, 'index');
+                    if (existsSync(indexResolved + '.ts') || existsSync(indexResolved + '.js')) {
+                        return path.resolve(indexResolved + '.ts');
+                    }
+                }
+                // Return first target even if not exists (for linking later)
+                return path.resolve(targets[0].replace(/\*/g, wildcard || ''));
+            }
+        }
+        // Try package.json imports
+        for (const [pattern, target] of this.imports.entries()) {
+            const patternRegex = new RegExp('^' + pattern.replace(/\*/g, '(.*)') + '$');
+            const match = importPath.match(patternRegex);
+            if (match) {
+                const wildcard = match[1];
+                const resolved = target.replace(/\*/g, wildcard || '');
+                const absPath = path.resolve(this.rootDir, resolved);
+                if (existsSync(absPath))
+                    return absPath;
+                return absPath;
+            }
+        }
+        // Common aliases without config
+        const commonAliases = {
+            '@': this.rootDir,
+            '~': this.rootDir,
+            '@src': path.join(this.rootDir, 'src'),
+            '@lib': path.join(this.rootDir, 'src', 'lib'),
+            '@components': path.join(this.rootDir, 'src', 'components'),
+            '@utils': path.join(this.rootDir, 'src', 'utils'),
+            '#': path.join(this.rootDir, 'src'),
+        };
+        for (const [alias, aliasPath] of Object.entries(commonAliases)) {
+            if (importPath.startsWith(alias + '/')) {
+                const suffix = importPath.substring(alias.length + 1);
+                const resolved = path.join(aliasPath, suffix);
+                if (existsSync(resolved) || existsSync(resolved + '.ts') ||
+                    existsSync(resolved + '.tsx') || existsSync(resolved + '.js')) {
+                    return path.resolve(resolved);
+                }
+                return path.resolve(resolved);
+            }
+        }
+        return null;
+    }
+    /**
+     * Get hash of config for cache invalidation
+     */
+    getConfigHash() {
+        const configData = JSON.stringify({
+            tsConfig: this.tsConfig,
+            packageImports: this.packageJson?.imports
+        });
+        return crypto.createHash('md5').update(configData).digest('hex');
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    getPaths() {
+        return this.paths;
+    }
+}
 export class ProjectKnowledgeGraph {
     nodes = new Map();
     rootDir = '';
-    cache = { version: '1.0', files: {} };
+    cache = { version: '2.0', files: {} };
     cachePath = '';
+    configResolver = null;
+    configHash = '';
+    // Dynamic concurrency based on file count
+    getConcurrencyLimit(fileCount) {
+        if (fileCount < 100)
+            return 20;
+        if (fileCount < 500)
+            return 50;
+        if (fileCount < 2000)
+            return 100;
+        return 150; // Cap at 150 for very large projects
+    }
     constructor() { }
     /**
      * Force rebuild the graph by clearing cache first.
-     * Use this when cache seems stale or files are not detected properly.
      */
     async forceRebuild(rootDir) {
         this.rootDir = path.resolve(rootDir);
         this.cachePath = path.join(this.rootDir, '.gemini_graph_cache.json');
         // Clear in-memory cache
-        this.cache = { version: '1.0', files: {} };
+        this.cache = { version: '2.0', files: {} };
         // Delete cache file if exists
         try {
             await fs.unlink(this.cachePath);
@@ -23,7 +210,8 @@ export class ProjectKnowledgeGraph {
         catch (e) {
             // File doesn't exist, that's fine
         }
-        // Now build fresh
+        // Clear config resolver cache
+        this.configResolver = null;
         return await this.build(rootDir);
     }
     async build(rootDir) {
@@ -36,6 +224,12 @@ export class ProjectKnowledgeGraph {
                 throw new Error(`Path '${rootDir}' is not a directory.`);
             }
             this.nodes.clear();
+            // Initialize and load config resolver
+            if (!this.configResolver) {
+                this.configResolver = new ConfigResolver(this.rootDir);
+                await this.configResolver.load();
+            }
+            this.configHash = this.configResolver.getConfigHash();
             await this.loadCache();
             const files = await this.getAllFiles(this.rootDir);
             // Step 1: Initialize nodes
@@ -54,7 +248,8 @@ export class ProjectKnowledgeGraph {
                 try {
                     const stats = await fs.stat(file);
                     const cached = this.cache.files[file];
-                    if (cached && cached.mtime === stats.mtimeMs) {
+                    if (cached && cached.mtime === stats.mtimeMs &&
+                        this.cache.configHash === this.configHash) {
                         extractionMap.set(file, { imports: cached.imports, symbols: cached.symbols });
                     }
                     else {
@@ -65,8 +260,8 @@ export class ProjectKnowledgeGraph {
                     filesToParse.push(file);
                 }
             }
-            // Step 3: Parse new/modified files concurrently
-            const CONCURRENCY_LIMIT = 20;
+            // Step 3: Parse new/modified files concurrently with dynamic limit
+            const CONCURRENCY_LIMIT = this.getConcurrencyLimit(filesToParse.length);
             for (let i = 0; i < filesToParse.length; i += CONCURRENCY_LIMIT) {
                 const chunk = filesToParse.slice(i, i + CONCURRENCY_LIMIT);
                 await Promise.all(chunk.map(async (file) => {
@@ -81,6 +276,8 @@ export class ProjectKnowledgeGraph {
                     };
                 }));
             }
+            // Update config hash in cache
+            this.cache.configHash = this.configHash;
             // Prune deleted files from cache
             for (const cachedFile of Object.keys(this.cache.files)) {
                 if (!this.nodes.has(cachedFile)) {
@@ -108,18 +305,21 @@ export class ProjectKnowledgeGraph {
         try {
             const content = await fs.readFile(this.cachePath, 'utf-8');
             const data = JSON.parse(content);
-            if (data.version === '1.0') {
+            // Support both version 1.0 and 2.0
+            if (data.version === '1.0' || data.version === '2.0') {
                 this.cache = data;
             }
         }
         catch (e) {
             // Ignore cache errors (start fresh)
-            this.cache = { version: '1.0', files: {} };
+            this.cache = { version: '2.0', files: {} };
         }
     }
     async saveCache() {
         try {
-            await fs.writeFile(this.cachePath, JSON.stringify(this.cache, null, 2), 'utf-8');
+            const tmpPath = this.cachePath + '.tmp';
+            await fs.writeFile(tmpPath, JSON.stringify(this.cache, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.cachePath);
         }
         catch (e) {
             console.error('Failed to save graph cache:', e);
@@ -132,8 +332,19 @@ export class ProjectKnowledgeGraph {
             for (const entry of entries) {
                 const res = path.resolve(dir, entry.name);
                 if (entry.isDirectory()) {
-                    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist' || entry.name === '.gemini' || entry.name === 'coverage' || entry.name === '.npm')
+                    // Skip common directories
+                    const skipDirs = [
+                        'node_modules', '.git', 'dist', 'build', 'out',
+                        '.gemini', 'coverage', '.npm', '.next', '.nuxt',
+                        'target', 'bin', 'obj', '.venv', 'venv', '__pycache__',
+                        '.cache', '.turbo', '.parcel'
+                    ];
+                    if (skipDirs.includes(entry.name))
                         continue;
+                    // Check for workspace package boundaries (optional optimization)
+                    if (entry.name === 'packages' && this.isMonorepoRoot(dir)) {
+                        // Include all packages in monorepo
+                    }
                     try {
                         files.push(...await this.getAllFiles(res));
                     }
@@ -142,8 +353,10 @@ export class ProjectKnowledgeGraph {
                     }
                 }
                 else {
-                    if (/\.(ts|js|tsx|jsx|json|py|go|rs|java|c|cpp|h)$/.test(entry.name)) {
-                        // Ignore cache file itself
+                    // Supported file extensions
+                    const extPattern = /\.(ts|js|tsx|jsx|mjs|cjs|json|py|go|rs|java|kt|kts|scala|clj|cljc|rb|php|sh|bash|zsh|fish|c|cpp|h|hpp|cc|cxx)$/;
+                    if (extPattern.test(entry.name)) {
+                        // Ignore cache file
                         if (entry.name === '.gemini_graph_cache.json')
                             continue;
                         files.push(res);
@@ -157,11 +370,39 @@ export class ProjectKnowledgeGraph {
             return [];
         }
     }
+    isMonorepoRoot(dir) {
+        // Check for pnpm workspace.yaml
+        if (existsSync(path.join(dir, 'pnpm-workspace.yaml')))
+            return true;
+        // Check for yarn workspace
+        const packageJsonPath = path.join(dir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+                if (pkg.workspaces)
+                    return true;
+            }
+            catch { }
+        }
+        return false;
+    }
     async parseFile(filePath) {
         const ext = path.extname(filePath);
-        if (['.ts', '.js', '.tsx', '.jsx'].includes(ext)) {
+        if (['.ts', '.js', '.tsx', '.jsx', '.mjs', '.cjs'].includes(ext)) {
             return await this.parseTypeScript(filePath);
         }
+        else if (ext === '.py') {
+            return await this.parsePython(filePath);
+        }
+        else if (ext === '.go') {
+            return await this.parseGo(filePath);
+        }
+        else if (ext === '.rs') {
+            return await this.parseRust(filePath);
+        }
+        else if (['.java', '.kt', '.kts'].includes(ext)) {
+            return await this.parseJavaLike(filePath);
+        }
         else {
             return await this.parseGeneric(filePath);
         }
@@ -184,6 +425,21 @@ export class ProjectKnowledgeGraph {
                     if (isExported)
                         symbols.push(`class:${node.name.text}`);
                 }
+                else if (ts.isInterfaceDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`interface:${node.name.text}`);
+                }
+                else if (ts.isTypeAliasDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`type:${node.name.text}`);
+                }
+                else if (ts.isEnumDeclaration(node) && node.name) {
+                    const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+                    if (isExported)
+                        symbols.push(`enum:${node.name.text}`);
+                }
                 else if (ts.isVariableStatement(node)) {
                     const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
                     if (isExported) {
@@ -199,7 +455,6 @@ export class ProjectKnowledgeGraph {
                         imports.push(node.moduleSpecifier.text);
                     }
                 }
-                // 2. Dynamic imports: import('...')
                 else if (ts.isCallExpression(node)) {
                     if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
                         const arg = node.arguments[0];
@@ -207,7 +462,6 @@ export class ProjectKnowledgeGraph {
                             imports.push(arg.text);
                         }
                     }
-                    // 3. CommonJS: require('...')
                     else if (ts.isIdentifier(node.expression) && node.expression.text === 'require' && node.arguments.length > 0) {
                         const arg = node.arguments[0];
                         if (ts.isStringLiteral(arg)) {
@@ -215,7 +469,6 @@ export class ProjectKnowledgeGraph {
                         }
                     }
                 }
-                // 4. Import Equals: import x = require('...')
                 else if (ts.isImportEqualsDeclaration(node)) {
                     if (ts.isExternalModuleReference(node.moduleReference)) {
                         if (ts.isStringLiteral(node.moduleReference.expression)) {
@@ -233,74 +486,175 @@ export class ProjectKnowledgeGraph {
             return { imports: [], symbols: [] };
         }
     }
-    async parseGeneric(filePath) {
+    async parsePython(filePath) {
         try {
             const content = await fs.readFile(filePath, 'utf-8');
             const imports = [];
             const symbols = [];
-            const ext = path.extname(filePath);
-            if (ext === '.py') {
-                // 1. Python Imports
-                // Handle: import os, sys
-                const simpleImportMatches = content.matchAll(/^\s*import\s+([^#\n]+)/gm);
-                for (const match of simpleImportMatches) {
-                    match[1].split(',').forEach(s => {
-                        const clean = s.trim().split(/\s+/)[0]; // Handle 'import x as y'
-                        if (clean)
-                            imports.push(clean);
-                    });
-                }
-                // Handle: from .module import func OR from package.module import func
-                const fromImportMatches = content.matchAll(/^\s*from\s+([.a-zA-Z0-9_]+)\s+import/gm);
-                for (const match of fromImportMatches) {
-                    let imp = match[1];
-                    // Convert Python relative import to path (e.g. .module -> ./module)
-                    if (imp.startsWith('.')) {
-                        const matchDots = imp.match(/^(\.+)(.*)/);
-                        if (matchDots) {
-                            const dots = matchDots[1].length;
-                            const name = matchDots[2];
-                            if (dots === 1) {
-                                imp = `./${name}`;
-                            }
-                            else {
-                                imp = `${'../'.repeat(dots - 1)}${name}`;
-                            }
-                        }
+            // Python imports with better regex
+            const simpleImportMatches = content.matchAll(/^\s*import\s+([^#\n]+)/gm);
+            for (const match of simpleImportMatches) {
+                match[1].split(',').forEach(s => {
+                    const clean = s.trim().split(/\s+/)[0];
+                    if (clean && !clean.startsWith('.'))
+                        imports.push(clean);
+                });
+            }
+            // from . import x, from ..package import y
+            const fromImportMatches = content.matchAll(/^\s*from\s+([.\w]+)\s+import/gm);
+            for (const match of fromImportMatches) {
+                let imp = match[1];
+                if (imp.startsWith('.')) {
+                    const matchDots = imp.match(/^(\.+)(.*)/);
+                    if (matchDots) {
+                        const dots = matchDots[1].length;
+                        const name = matchDots[2];
+                        if (dots === 1)
+                            imp = `./${name}`;
+                        else
+                            imp = `${'../'.repeat(dots - 1)}${name}`;
                     }
-                    imports.push(imp);
                 }
-                // 2. Python Symbols (Only top-level defs/classes to avoid nested methods)
-                const topLevelFuncMatches = content.matchAll(/^def\s+([a-zA-Z0-9_]+)/gm);
-                for (const match of topLevelFuncMatches)
+                imports.push(imp);
+            }
+            // Python symbols (skip underscored/private)
+            const funcMatches = content.matchAll(/^def\s+([a-zA-Z_][a-zA-Z0-9_]*)/gm);
+            for (const match of funcMatches)
+                symbols.push(`def:${match[1]}`);
+            const classMatches = content.matchAll(/^class\s+([a-zA-Z_][a-zA-Z0-9_]*)/gm);
+            for (const match of classMatches)
+                symbols.push(`class:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            console.error(`Error parsing Python file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
+        }
+    }
+    async parseGo(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            // Single line: import "fmt"
+            const singleImportMatches = content.matchAll(/import\s+"([^"]+)"/g);
+            for (const match of singleImportMatches)
+                imports.push(match[1]);
+            // Block: import ( "fmt"; "os" )
+            const blockImportMatches = content.matchAll(/import\s+\(([\s\S]*?)\)/g);
+            for (const match of blockImportMatches) {
+                const block = match[1];
+                const innerMatches = block.matchAll(/"([^"]+)"/g);
+                for (const im of innerMatches)
+                    imports.push(im[1]);
+            }
+            // Go symbols
+            const funcMatches = content.matchAll(/^func\s+(?:\([^\)]*\)\s+)?([A-Z][a-zA-Z0-9_]*)/gm);
+            for (const match of funcMatches)
+                symbols.push(`func:${match[1]}`);
+            const typeMatches = content.matchAll(/^type\s+([A-Z][a-zA-Z0-9_]*)\s+(?:struct|interface)/gm);
+            for (const match of typeMatches)
+                symbols.push(`type:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            console.error(`Error parsing Go file ${filePath}:`, error);
+            return { imports: [], symbols: [] };
+        }
+    }
+    async parseRust(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            // use crate::module::item;
+            const useMatches = content.matchAll(/^use\s+([^;]+);/gm);
+            for (const match of useMatches) {
+                imports.push(match[1].trim());
+            }
+            // mod statement
+            const modMatches = content.matchAll(/^mod\s+([a-z][a-z0-9_]*)/gm);
+            for (const match of modMatches)
+                symbols.push(`mod:${match[1]}`);
+            // pub fn / pub struct / pub enum / pub trait
+            const pubMatches = content.matchAll(/^pub\s+(fn|struct|enum|trait)\s+([A-Za-z][A-Za-z0-9_]*)/gm);
+            for (const match of pubMatches)
+                symbols.push(`${match[1]}:${match[2]}`);
+            // impl blocks
+            const implMatches = content.matchAll(/^impl\s+([A-Z][A-Za-z0-9_]*)/gm);
+            for (const match of implMatches)
+                symbols.push(`impl:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            return { imports: [], symbols: [] };
+        }
+    }
+    async parseJavaLike(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            // import package.Class;
+            const importMatches = content.matchAll(/^import\s+([^;]+);/gm);
+            for (const match of importMatches)
+                imports.push(match[1].trim());
+            // package declaration
+            const pkgMatch = content.match(/^package\s+([^;]+);/m);
+            if (pkgMatch)
+                symbols.push(`package:${pkgMatch[1]}`);
+            // public class/interface/enum
+            const classMatches = content.matchAll(/^public\s+(?:static\s+)?(?:final\s+)?(?:abstract\s+)?(class|interface|enum|record)\s+([A-Z][A-Za-z0-9_]*)/gm);
+            for (const match of classMatches)
+                symbols.push(`${match[1]}:${match[2]}`);
+            // public methods
+            const methodMatches = content.matchAll(/^public\s+(?:static\s+)?(?:synchronized\s+)?(?:final\s+)?(?:\w+(?:<[^>]+>)?)\s+([a-z][a-zA-Z0-9_]*)\s*\(/gm);
+            for (const match of methodMatches)
+                symbols.push(`method:${match[1]}`);
+            return { imports, symbols };
+        }
+        catch (error) {
+            return { imports: [], symbols: [] };
+        }
+    }
+    async parseGeneric(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const imports = [];
+            const symbols = [];
+            const ext = path.extname(filePath);
+            // C/C++
+            if (['.c', '.cpp', '.h', '.hpp', '.cc', '.cxx'].includes(ext)) {
+                const includeMatches = content.matchAll(/#include\s*[<"]([^>"]+)[>"]/g);
+                for (const match of includeMatches)
+                    imports.push(match[1]);
+                const funcMatches = content.matchAll(/^\w[\w\s*]+\s+(\w+)\s*\([^)]*\)\s*{/gm);
+                for (const match of funcMatches)
+                    symbols.push(`function:${match[1]}`);
+            }
+            // Ruby
+            else if (ext === '.rb') {
+                const requireMatches = content.matchAll(/require\s+['"]([^'"]+)['"]/g);
+                for (const match of requireMatches)
+                    imports.push(match[1]);
+                const defMatches = content.matchAll(/^def\s+([a-z_][a-z0-9_!?]*)/gm);
+                for (const match of defMatches)
                     symbols.push(`def:${match[1]}`);
-                const topLevelClassMatches = content.matchAll(/^class\s+([a-zA-Z0-9_]+)/gm);
-                for (const match of topLevelClassMatches)
+                const classMatches = content.matchAll(/^class\s+([A-Z][A-Za-z0-9_]*)/gm);
+                for (const match of classMatches)
                     symbols.push(`class:${match[1]}`);
             }
-            else if (ext === '.go') {
-                // 1. Go Imports
-                // Single line: import "fmt"
-                const singleImportMatches = content.matchAll(/import\s+\"([^\"]+)\"/g);
-                for (const match of singleImportMatches)
-                    imports.push(match[1]);
-                // Block: import ( "fmt"; "os" )
-                const blockImportMatches = content.matchAll(/import\s+\(([\s\S]*?)\)/g);
-                for (const match of blockImportMatches) {
-                    const block = match[1];
-                    const innerMatches = block.matchAll(/"([^\"]+)"/g);
-                    for (const im of innerMatches)
-                        imports.push(im[1]);
-                }
-                // 2. Go Symbols
-                // Functions: func Name(...)
-                const funcMatches = content.matchAll(/^func\s+([a-zA-Z0-9_]+)/gm);
+            // PHP
+            else if (ext === '.php') {
+                const useMatches = content.matchAll(/^use\s+([^;]+);/gm);
+                for (const match of useMatches)
+                    imports.push(match[1].trim());
+                const funcMatches = content.matchAll(/^function\s+([a-z_][a-z0-9_]*)/gm);
                 for (const match of funcMatches)
-                    symbols.push(`func:${match[1]}`);
-                // Types: type Name struct/interface
-                const typeMatches = content.matchAll(/^type\s+([a-zA-Z0-9_]+)\s+(?:struct|interface)/gm);
-                for (const match of typeMatches)
-                    symbols.push(`type:${match[1]}`);
+                    symbols.push(`function:${match[1]}`);
+                const classMatches = content.matchAll(/^class\s+([A-Z][A-Za-z0-9_]*)/gm);
+                for (const match of classMatches)
+                    symbols.push(`class:${match[1]}`);
             }
             return { imports, symbols };
         }
@@ -316,12 +670,24 @@ export class ProjectKnowledgeGraph {
         currentNode.symbols = symbols;
         for (const importPath of rawImports) {
             let resolvedPath = null;
-            if (importPath.startsWith('.')) {
-                resolvedPath = await this.resolvePath(path.dirname(filePath), importPath);
+            // Step 1: Try alias resolution
+            if (this.configResolver && !importPath.startsWith('.')) {
+                resolvedPath = this.configResolver.resolveAlias(importPath);
+                if (resolvedPath && !this.nodes.has(resolvedPath)) {
+                    // Try with extensions
+                    resolvedPath = await this.resolvePath(path.dirname(resolvedPath), path.basename(resolvedPath));
+                }
             }
-            else {
-                resolvedPath = await this.resolvePath(this.rootDir, importPath);
+            // Step 2: Try relative/regular path resolution
+            if (!resolvedPath) {
+                if (importPath.startsWith('.')) {
+                    resolvedPath = await this.resolvePath(path.dirname(filePath), importPath);
+                }
+                else {
+                    resolvedPath = await this.resolvePath(this.configResolver?.getBaseUrl() || this.rootDir, importPath);
+                }
             }
+            // Step 3: Link nodes
             if (resolvedPath && this.nodes.has(resolvedPath)) {
                 if (!currentNode.imports.includes(resolvedPath)) {
                     currentNode.imports.push(resolvedPath);
@@ -331,8 +697,7 @@ export class ProjectKnowledgeGraph {
                 }
             }
             else {
-                // If we can't resolve to a local file, keep the original import string ONLY if it looks like an external package
-                // Ignore relative paths that failed to resolve (broken links)
+                // Keep external package references
                 if (!importPath.startsWith('.') && !path.isAbsolute(importPath)) {
                     if (!currentNode.imports.includes(importPath)) {
                         currentNode.imports.push(importPath);
@@ -347,15 +712,33 @@ export class ProjectKnowledgeGraph {
         if (this.nodes.has(absolutePath)) {
             return absolutePath;
         }
-        // 2. Try appending extensions
-        const extensions = ['.ts', '.js', '.tsx', '.jsx', '.json', '.py', '.go', '.rs', '.java', '.c', '.cpp', '.h', '/index.ts', '/index.js'];
+        // 2. Try appending extensions (expanded list)
+        const extensions = [
+            '.ts', '.tsx', '.jsx', '.js', '.mjs', '.cjs',
+            '.json', '.py', '.go', '.rs',
+            '/index.ts', '/index.tsx', '/index.jsx', '/index.js', '/index.mjs',
+        ];
         for (const ext of extensions) {
             const p = absolutePath + ext;
             if (this.nodes.has(p)) {
                 return p;
             }
         }
-        // 3. Try handling .js -> .ts mapping (ESM style imports)
+        // 3. Try directory -> index file
+        if (!path.extname(absolutePath)) {
+            const indexPaths = [
+                absolutePath + '/index.ts',
+                absolutePath + '/index.js',
+                absolutePath + '/index.tsx',
+                absolutePath + '/index.jsx',
+            ];
+            for (const p of indexPaths) {
+                if (this.nodes.has(p)) {
+                    return p;
+                }
+            }
+        }
+        // 4. Try .js -> .ts mapping (ESM style imports)
         if (absolutePath.endsWith('.js')) {
             const tsPath = absolutePath.replace(/\.js$/, '.ts');
             if (this.nodes.has(tsPath))
@@ -371,10 +754,8 @@ export class ProjectKnowledgeGraph {
     }
     getRelationships(filePath) {
         const absolutePath = path.resolve(this.rootDir, filePath);
-        // Try to match exact or with extensions
         let node = this.nodes.get(absolutePath);
         if (!node) {
-            // Fallback search
             for (const [key, value] of this.nodes.entries()) {
                 if (key.endsWith(filePath)) {
                     node = value;
@@ -390,7 +771,7 @@ export class ProjectKnowledgeGraph {
                 if (path.isAbsolute(p)) {
                     return path.relative(this.rootDir, p);
                 }
-                return p; // Return as is for external libraries
+                return p;
             }),
             importedBy: node.importedBy.map(p => path.relative(this.rootDir, p)),
             symbols: node.symbols
@@ -417,7 +798,6 @@ export class ProjectKnowledgeGraph {
             dependencies: [],
             dependents: []
         };
-        // Get symbols and paths for what this file imports
         for (const imp of node.imports) {
             const impNode = this.nodes.get(imp);
             if (impNode) {
@@ -427,7 +807,6 @@ export class ProjectKnowledgeGraph {
                 });
             }
         }
-        // Get symbols and paths for what imports this file
         for (const dep of node.importedBy) {
             const depNode = this.nodes.get(dep);
             if (depNode) {
@@ -443,6 +822,8 @@ export class ProjectKnowledgeGraph {
         return {
             root: this.rootDir,
             fileCount: this.nodes.size,
+            configHash: this.configHash,
+            aliasCount: this.configResolver?.getPaths().size || 0,
             mostReferencedFiles: [...this.nodes.values()]
                 .sort((a, b) => b.importedBy.length - a.importedBy.length)
                 .slice(0, 5)
@@ -456,16 +837,13 @@ export class ProjectKnowledgeGraph {
         const lines = ['graph TD'];
         const fileToId = new Map();
         let idCounter = 0;
-        // Assign IDs
         for (const [filePath, _] of this.nodes) {
             const relative = path.relative(this.rootDir, filePath);
             const id = `N${idCounter++}`;
             fileToId.set(filePath, id);
-            // Escape quotes in label
             const label = relative.replace(/"/g, "'");
             lines.push(`  ${id}["${label}"]`);
         }
-        // Add Edges
         for (const [filePath, node] of this.nodes) {
             const sourceId = fileToId.get(filePath);
             for (const importPath of node.imports) {
@@ -475,6 +853,6 @@ export class ProjectKnowledgeGraph {
                 }
             }
         }
-        return lines.join('\\n');
+        return lines.join('\n');
     }
 }