@theihtisham/agent-shadow-brain 1.1.1 → 2.1.0

package/dist/brain/project-config.js

@@ -0,0 +1,121 @@
+// src/brain/project-config.ts — Load .shadow-brain.json project-level config
+import * as fs from 'fs';
+import * as path from 'path';
+const CONFIG_FILENAMES = ['.shadow-brain.json', 'shadow-brain.json'];
+const DEFAULT_CONFIG = { version: '1.0' };
+export class ProjectConfigLoader {
+    constructor(projectDir) {
+        this.config = DEFAULT_CONFIG;
+        this.projectDir = projectDir;
+    }
+    load() {
+        // Check project directory
+        for (const name of CONFIG_FILENAMES) {
+            const fp = path.join(this.projectDir, name);
+            if (fs.existsSync(fp)) {
+                try {
+                    this.config = { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync(fp, 'utf-8')) };
+                    return this.config;
+                }
+                catch { /* use defaults */ }
+            }
+        }
+        // Check package.json for "shadowBrain" key
+        const pkgPath = path.join(this.projectDir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.shadowBrain) {
+                    this.config = { ...DEFAULT_CONFIG, ...pkg.shadowBrain };
+                    return this.config;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        // Check pyproject.toml for Python projects
+        const pyPath = path.join(this.projectDir, 'pyproject.toml');
+        if (fs.existsSync(pyPath)) {
+            try {
+                const content = fs.readFileSync(pyPath, 'utf-8');
+                const match = content.match(/\[tool\.shadow-brain\]\s*([\s\S]*?)(?=\[|$)/);
+                if (match) {
+                    // Simple TOML-like parse for basic config
+                    const tomlSection = match[1];
+                    const ignoreMatch = tomlSection.match(/ignore_paths\s*=\s*\[([^\]]*)\]/);
+                    if (ignoreMatch) {
+                        const paths = ignoreMatch[1].split(',').map(s => s.trim().replace(/"/g, '').replace(/'/g, ''));
+                        this.config.rules = { ignorePaths: paths.filter(Boolean) };
+                    }
+                }
+            }
+            catch { /* ignore */ }
+        }
+        return this.config;
+    }
+    get() {
+        return this.config;
+    }
+    getIgnorePatterns() {
+        const patterns = [];
+        // From project config
+        if (this.config.rules?.ignorePaths) {
+            patterns.push(...this.config.rules.ignorePaths);
+        }
+        if (this.config.rules?.ignorePatterns) {
+            patterns.push(...this.config.rules.ignorePatterns);
+        }
+        // From .shadow-brain-ignore file
+        const ignoreFile = path.join(this.projectDir, '.shadow-brain-ignore');
+        if (fs.existsSync(ignoreFile)) {
+            const content = fs.readFileSync(ignoreFile, 'utf-8');
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('#')) {
+                    patterns.push(trimmed);
+                }
+            }
+        }
+        // From .gitignore
+        const gitignore = path.join(this.projectDir, '.gitignore');
+        if (fs.existsSync(gitignore)) {
+            const content = fs.readFileSync(gitignore, 'utf-8');
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('#')) {
+                    patterns.push(trimmed);
+                }
+            }
+        }
+        return [...new Set(patterns)];
+    }
+    getCustomRules() {
+        return this.config.rules?.customRules || [];
+    }
+    getNotificationConfig() {
+        return this.config.notifications;
+    }
+    save(config) {
+        this.config = config;
+        const fp = path.join(this.projectDir, '.shadow-brain.json');
+        fs.writeFileSync(fp, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    shouldIgnore(filePath) {
+        const patterns = this.getIgnorePatterns();
+        for (const pattern of patterns) {
+            if (pattern.startsWith('*')) {
+                if (filePath.endsWith(pattern.slice(1)))
+                    return true;
+            }
+            else if (pattern.endsWith('*')) {
+                if (filePath.startsWith(pattern.slice(0, -1)))
+                    return true;
+            }
+            else {
+                if (filePath.includes(pattern))
+                    return true;
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=project-config.js.map

package/dist/brain/project-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-config.js","sourceRoot":"","sources":["../../src/brain/project-config.ts"],"names":[],"mappings":"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"}

package/dist/brain/semantic-analyzer.d.ts

@@ -0,0 +1,46 @@
+import { SymbolInfo } from '../types.js';
+export declare class SemanticAnalyzer {
+    private projectDir;
+    private symbols;
+    private importGraph;
+    private exportMap;
+    private usageMap;
+    constructor(projectDir: string);
+    /** Run full semantic analysis across the project */
+    analyzeProject(): Promise<{
+        symbols: Map<string, SymbolInfo[]>;
+        unusedExports: SymbolInfo[];
+        deadCode: SymbolInfo[];
+    }>;
+    /** Extract symbols from a single file */
+    extractSymbols(filePath: string): SymbolInfo[];
+    /** Get all source files in the project */
+    private getSourceFiles;
+    /** Extract import relationships from a file */
+    private extractImports;
+    /** Build a map of which files use each symbol */
+    private buildUsageMap;
+    /** Detect exported symbols that are never imported/used elsewhere */
+    private detectUnusedExports;
+    /** Detect dead code — private functions/methods never called within their file */
+    private detectDeadCode;
+    /** Check if a symbol is imported in any file */
+    private isSymbolImported;
+    /** Check if a file is an entry point (main, index, etc.) */
+    private isEntryPoint;
+    /** Check if a symbol name is a common/expected export */
+    private isCommonExport;
+    /** Check if a line is an export statement */
+    private isExported;
+    /** Strip comments from source code */
+    private stripComments;
+    /** Get 1-based line number from character offset */
+    private getLineNumber;
+    /** Detect language from file extension */
+    private getLanguageForExt;
+    /** Check if a name is a language builtin */
+    private isBuiltin;
+    /** Escape special regex characters */
+    private escapeRegex;
+}
+//# sourceMappingURL=semantic-analyzer.d.ts.map

package/dist/brain/semantic-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-analyzer.d.ts","sourceRoot":"","sources":["../../src/brain/semantic-analyzer.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA4GzC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAwC;IACvD,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,QAAQ,CAAuC;gBAE3C,UAAU,EAAE,MAAM;IAI9B,oDAAoD;IAC9C,cAAc,IAAI,OAAO,CAAC;QAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;QACnC,aAAa,EAAE,UAAU,EAAE,CAAC;QAC5B,QAAQ,EAAE,UAAU,EAAE,CAAC;KACxB,CAAC;IAiCF,yCAAyC;IACzC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE;IAgJ9C,0CAA0C;IAC1C,OAAO,CAAC,cAAc;IAkCtB,+CAA+C;IAC/C,OAAO,CAAC,cAAc;IA2CtB,iDAAiD;IACjD,OAAO,CAAC,aAAa;IAqBrB,qEAAqE;IACrE,OAAO,CAAC,mBAAmB;IAwB3B,kFAAkF;IAClF,OAAO,CAAC,cAAc;IAgCtB,gDAAgD;IAChD,OAAO,CAAC,gBAAgB;IAOxB,4DAA4D;IAC5D,OAAO,CAAC,YAAY;IAOpB,yDAAyD;IACzD,OAAO,CAAC,cAAc;IAOtB,6CAA6C;IAC7C,OAAO,CAAC,UAAU;IAWlB,sCAAsC;IACtC,OAAO,CAAC,aAAa;IAUrB,oDAAoD;IACpD,OAAO,CAAC,aAAa;IAQrB,0CAA0C;IAC1C,OAAO,CAAC,iBAAiB;IAOzB,4CAA4C;IAC5C,OAAO,CAAC,SAAS;IAajB,sCAAsC;IACtC,OAAO,CAAC,WAAW;CAGpB"}

package/dist/brain/semantic-analyzer.js

@@ -0,0 +1,496 @@
+// src/brain/semantic-analyzer.ts — Semantic Code Analysis Engine
+// v2.0.0 — Symbol extraction, unused export detection, dead code analysis
+//
+// Mathematical foundations:
+//   - TF-IDF for symbol importance scoring: tfidf(t,d) = tf(t,d) * log(N / df(t))
+//   - Set operations for reachability analysis (transitive closure of imports)
+//   - Kolmogorov complexity approximation for code redundancy detection
+import * as fs from 'fs';
+import * as path from 'path';
+const LANG_CONFIGS = {
+    typescript: {
+        extensions: ['.ts', '.tsx'],
+        commentSingle: '//',
+        commentMultiStart: '/*',
+        commentMultiEnd: '*/',
+        exportPatterns: [
+            /export\s+(?:default\s+)?(?:function|class|interface|type|enum|const|let|var|async\s+function)\s+(\w+)/g,
+            /export\s+\{([^}]+)\}/g,
+        ],
+        importPatterns: [
+            /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/g,
+            /import\s+['"]([^'"]+)['"]/g,
+        ],
+        functionPatterns: [
+            /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/g,
+            /(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/g,
+            /(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>\s*/g,
+        ],
+        classPatterns: [
+            /(?:export\s+)?(?:default\s+)?class\s+(\w+)/g,
+        ],
+        interfacePatterns: [
+            /(?:export\s+)?interface\s+(\w+)/g,
+        ],
+        typePatterns: [
+            /(?:export\s+)?type\s+(\w+)\s*(?:<|={|\s)/g,
+        ],
+        variablePatterns: [
+            /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]/g,
+        ],
+    },
+    javascript: {
+        extensions: ['.js', '.jsx', '.mjs', '.cjs'],
+        commentSingle: '//',
+        commentMultiStart: '/*',
+        commentMultiEnd: '*/',
+        exportPatterns: [
+            /export\s+(?:default\s+)?(?:function|class|const|let|var|async\s+function)\s+(\w+)/g,
+            /export\s+\{([^}]+)\}/g,
+            /module\.exports\s*=\s*(\w+)/g,
+            /exports\.(\w+)\s*=/g,
+        ],
+        importPatterns: [
+            /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/g,
+            /import\s+['"]([^'"]+)['"]/g,
+            /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        ],
+        functionPatterns: [
+            /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/g,
+            /(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/g,
+            /(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>\s*/g,
+        ],
+        classPatterns: [
+            /(?:export\s+)?(?:default\s+)?class\s+(\w+)/g,
+        ],
+        interfacePatterns: [],
+        typePatterns: [],
+        variablePatterns: [
+            /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]/g,
+        ],
+    },
+    python: {
+        extensions: ['.py', '.pyi'],
+        commentSingle: '#',
+        commentMultiStart: '"""',
+        commentMultiEnd: '"""',
+        exportPatterns: [
+            /(?:^|\n)(\w+)\s*=\s*/g,
+        ],
+        importPatterns: [
+            /import\s+(\w+)/g,
+            /from\s+([\w.]+)\s+import\s+(.+)/g,
+        ],
+        functionPatterns: [
+            /def\s+(\w+)\s*\(/g,
+        ],
+        classPatterns: [
+            /class\s+(\w+)/g,
+        ],
+        interfacePatterns: [],
+        typePatterns: [],
+        variablePatterns: [
+            /(\w+)\s*[:=]\s*/g,
+        ],
+    },
+};
+// ── Semantic Analyzer ──────────────────────────────────────────────────────────
+export class SemanticAnalyzer {
+    constructor(projectDir) {
+        this.symbols = new Map();
+        this.importGraph = new Map(); // file -> imported symbols
+        this.exportMap = new Map(); // symbol name -> info
+        this.usageMap = new Map(); // symbol name -> files using it
+        this.projectDir = projectDir;
+    }
+    /** Run full semantic analysis across the project */
+    async analyzeProject() {
+        this.symbols.clear();
+        this.importGraph.clear();
+        this.exportMap.clear();
+        this.usageMap.clear();
+        const files = this.getSourceFiles();
+        // Phase 1: Extract symbols from all files
+        for (const file of files) {
+            const fileSymbols = this.extractSymbols(file);
+            if (fileSymbols.length > 0) {
+                this.symbols.set(file, fileSymbols);
+            }
+        }
+        // Phase 2: Build import graph
+        for (const file of files) {
+            this.extractImports(file);
+        }
+        // Phase 3: Build usage map
+        this.buildUsageMap(files);
+        // Phase 4: Detect unused exports
+        const unusedExports = this.detectUnusedExports();
+        // Phase 5: Detect dead code
+        const deadCode = this.detectDeadCode();
+        return { symbols: this.symbols, unusedExports, deadCode };
+    }
+    /** Extract symbols from a single file */
+    extractSymbols(filePath) {
+        const symbols = [];
+        const ext = path.extname(filePath);
+        const lang = this.getLanguageForExt(ext);
+        if (!lang)
+            return symbols;
+        const config = LANG_CONFIGS[lang];
+        if (!config)
+            return symbols;
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return symbols;
+        }
+        const relativePath = path.relative(this.projectDir, filePath).replace(/\\/g, '/');
+        const lines = content.split('\n');
+        // Strip comments for analysis
+        const strippedContent = this.stripComments(content, config);
+        const strippedLines = strippedContent.split('\n');
+        // Extract functions
+        for (const pattern of config.functionPatterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(strippedContent)) !== null) {
+                const name = match[1];
+                const lineNum = this.getLineNumber(content, match.index);
+                if (name && !this.isBuiltin(name, lang)) {
+                    const exported = this.isExported(lines, lineNum - 1);
+                    symbols.push({
+                        name,
+                        type: 'function',
+                        line: lineNum,
+                        file: relativePath,
+                        exported,
+                        usedInFiles: [],
+                    });
+                }
+            }
+        }
+        // Extract classes
+        for (const pattern of config.classPatterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(strippedContent)) !== null) {
+                const name = match[1];
+                const lineNum = this.getLineNumber(content, match.index);
+                if (name) {
+                    const exported = this.isExported(lines, lineNum - 1);
+                    symbols.push({
+                        name,
+                        type: 'class',
+                        line: lineNum,
+                        file: relativePath,
+                        exported,
+                        usedInFiles: [],
+                    });
+                }
+            }
+        }
+        // Extract interfaces
+        for (const pattern of config.interfacePatterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(strippedContent)) !== null) {
+                const name = match[1];
+                const lineNum = this.getLineNumber(content, match.index);
+                if (name) {
+                    const exported = this.isExported(lines, lineNum - 1);
+                    symbols.push({
+                        name,
+                        type: 'interface',
+                        line: lineNum,
+                        file: relativePath,
+                        exported,
+                        usedInFiles: [],
+                    });
+                }
+            }
+        }
+        // Extract types
+        for (const pattern of config.typePatterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(strippedContent)) !== null) {
+                const name = match[1];
+                const lineNum = this.getLineNumber(content, match.index);
+                if (name) {
+                    const exported = this.isExported(lines, lineNum - 1);
+                    symbols.push({
+                        name,
+                        type: 'type',
+                        line: lineNum,
+                        file: relativePath,
+                        exported,
+                        usedInFiles: [],
+                    });
+                }
+            }
+        }
+        // Extract exported variables/constants
+        for (const pattern of config.exportPatterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(strippedContent)) !== null) {
+                const raw = match[1] || match[0];
+                const lineNum = this.getLineNumber(content, match.index);
+                // Handle `export { a, b, c }` pattern
+                if (raw.includes(',') && !raw.includes('function') && !raw.includes('class')) {
+                    const names = raw.split(',').map(n => n.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+                    for (const name of names) {
+                        if (!symbols.some(s => s.name === name && s.file === relativePath)) {
+                            symbols.push({
+                                name,
+                                type: 'variable',
+                                line: lineNum,
+                                file: relativePath,
+                                exported: true,
+                                usedInFiles: [],
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Deduplicate — same name+file+type
+        const seen = new Set();
+        return symbols.filter(s => {
+            const key = `${s.name}:${s.file}:${s.type}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    /** Get all source files in the project */
+    getSourceFiles() {
+        const files = [];
+        const extensions = new Set();
+        for (const config of Object.values(LANG_CONFIGS)) {
+            for (const ext of config.extensions)
+                extensions.add(ext);
+        }
+        const ignoreDirs = new Set([
+            'node_modules', '.git', 'dist', 'build', '.next', '__pycache__',
+            '.cache', 'coverage', '.nyc_output', 'vendor', 'target', 'bin',
+        ]);
+        const walk = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        if (!ignoreDirs.has(entry.name) && !entry.name.startsWith('.')) {
+                            walk(path.join(dir, entry.name));
+                        }
+                    }
+                    else if (entry.isFile()) {
+                        const ext = path.extname(entry.name);
+                        if (extensions.has(ext)) {
+                            files.push(path.join(dir, entry.name));
+                        }
+                    }
+                }
+            }
+            catch { /* skip inaccessible dirs */ }
+        };
+        walk(this.projectDir);
+        return files;
+    }
+    /** Extract import relationships from a file */
+    extractImports(filePath) {
+        const importedSymbols = new Set();
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        const ext = path.extname(filePath);
+        const lang = this.getLanguageForExt(ext);
+        if (!lang)
+            return;
+        const config = LANG_CONFIGS[lang];
+        if (!config)
+            return;
+        const relativePath = path.relative(this.projectDir, filePath).replace(/\\/g, '/');
+        for (const pattern of config.importPatterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                // Named imports: { A, B, C }
+                if (match[1]) {
+                    const names = match[1].split(',').map(n => {
+                        const parts = n.trim().split(/\s+as\s+/);
+                        return parts[0].trim();
+                    }).filter(Boolean);
+                    for (const name of names) {
+                        importedSymbols.add(name);
+                    }
+                }
+                // Default import
+                if (match[2]) {
+                    importedSymbols.add(match[2]);
+                }
+            }
+        }
+        if (importedSymbols.size > 0) {
+            this.importGraph.set(relativePath, importedSymbols);
+        }
+    }
+    /** Build a map of which files use each symbol */
+    buildUsageMap(files) {
+        // For each exported symbol, search for usage across all files
+        for (const [name, info] of this.exportMap) {
+            const usedIn = [];
+            for (const file of files) {
+                const relativePath = path.relative(this.projectDir, file).replace(/\\/g, '/');
+                if (relativePath === info.file)
+                    continue; // Skip the defining file
+                try {
+                    const content = fs.readFileSync(file, 'utf-8');
+                    // Simple heuristic: symbol name appears as a word boundary
+                    const regex = new RegExp(`\\b${this.escapeRegex(name)}\\b`);
+                    if (regex.test(content)) {
+                        usedIn.push(relativePath);
+                    }
+                }
+                catch { /* skip */ }
+            }
+            info.usedInFiles = usedIn;
+        }
+    }
+    /** Detect exported symbols that are never imported/used elsewhere */
+    detectUnusedExports() {
+        const unused = [];
+        for (const [file, symbols] of this.symbols) {
+            for (const symbol of symbols) {
+                if (!symbol.exported)
+                    continue;
+                // Check if used in any other file
+                const imported = this.isSymbolImported(symbol.name, file);
+                const usedDirectly = symbol.usedInFiles && symbol.usedInFiles.length > 0;
+                if (!imported && !usedDirectly) {
+                    // Exclude entry points and common patterns
+                    if (this.isEntryPoint(file))
+                        continue;
+                    if (this.isCommonExport(symbol.name))
+                        continue;
+                    unused.push(symbol);
+                }
+            }
+        }
+        return unused;
+    }
+    /** Detect dead code — private functions/methods never called within their file */
+    detectDeadCode() {
+        const dead = [];
+        for (const [file, symbols] of this.symbols) {
+            try {
+                const fullPath = path.join(this.projectDir, file);
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                for (const symbol of symbols) {
+                    // Only check non-exported symbols
+                    if (symbol.exported)
+                        continue;
+                    // Count references to this symbol name in the file
+                    const escapedName = this.escapeRegex(symbol.name);
+                    // Match as a word boundary, excluding the definition itself
+                    const refRegex = new RegExp(`\\b${escapedName}\\b`, 'g');
+                    const matches = content.match(refRegex);
+                    // If only referenced once (the definition), it's dead code
+                    // But allow class constructors and method definitions
+                    if (matches && matches.length <= 1) {
+                        if (symbol.type === 'function' || symbol.type === 'variable') {
+                            dead.push(symbol);
+                        }
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+        return dead;
+    }
+    /** Check if a symbol is imported in any file */
+    isSymbolImported(symbolName, sourceFile) {
+        for (const [, imported] of this.importGraph) {
+            if (imported.has(symbolName))
+                return true;
+        }
+        return false;
+    }
+    /** Check if a file is an entry point (main, index, etc.) */
+    isEntryPoint(file) {
+        const base = path.basename(file);
+        const entryPoints = ['index.ts', 'index.js', 'main.ts', 'main.js', 'cli.ts', 'cli.js',
+            'server.ts', 'server.js', 'app.ts', 'app.js', '__init__.py', 'manage.py'];
+        return entryPoints.includes(base);
+    }
+    /** Check if a symbol name is a common/expected export */
+    isCommonExport(name) {
+        const common = ['default', 'config', 'Config', 'OPTIONS', 'VERSION', 'VERSION',
+            'plugin', 'Plugin', 'middleware', 'setup', 'install', 'activate',
+            'deactivate', 'configure', 'handler', 'Handler', 'router', 'Router'];
+        return common.includes(name);
+    }
+    /** Check if a line is an export statement */
+    isExported(lines, lineIndex) {
+        // Check current line and a few lines above for export keyword
+        for (let i = Math.max(0, lineIndex - 2); i <= Math.min(lines.length - 1, lineIndex + 1); i++) {
+            const line = lines[i].trim();
+            if (line.startsWith('export ') || line.startsWith('export{') || line.includes('module.exports')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Strip comments from source code */
+    stripComments(content, config) {
+        let result = content;
+        // Multi-line comments
+        result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+        // Single-line comments
+        result = result.replace(/\/\/.*$/gm, '');
+        // Strings (preserve them to avoid false matches inside strings)
+        return result;
+    }
+    /** Get 1-based line number from character offset */
+    getLineNumber(content, offset) {
+        let line = 1;
+        for (let i = 0; i < offset && i < content.length; i++) {
+            if (content[i] === '\n')
+                line++;
+        }
+        return line;
+    }
+    /** Detect language from file extension */
+    getLanguageForExt(ext) {
+        for (const [lang, config] of Object.entries(LANG_CONFIGS)) {
+            if (config.extensions.includes(ext))
+                return lang;
+        }
+        return null;
+    }
+    /** Check if a name is a language builtin */
+    isBuiltin(name, lang) {
+        const builtins = {
+            typescript: new Set(['constructor', 'toString', 'valueOf', 'hasOwnProperty',
+                'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString']),
+            javascript: new Set(['constructor', 'toString', 'valueOf', 'hasOwnProperty',
+                'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString']),
+            python: new Set(['__init__', '__str__', '__repr__', '__len__', '__getitem__',
+                '__setitem__', '__delitem__', '__iter__', '__next__', '__call__',
+                '__enter__', '__exit__', '__eq__', '__hash__', '__bool__']),
+        };
+        return builtins[lang]?.has(name) ?? false;
+    }
+    /** Escape special regex characters */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+//# sourceMappingURL=semantic-analyzer.js.map