entkapp 5.5.0 → 5.6.0

package/src/EngineContext.mjs

@@ -0,0 +1,428 @@
+import fsSync from 'fs';
+import path from 'path';
+import ansis from 'ansis';
+
+/**
+ * Core In-Memory Graph Node Representation.
+ * Tracks structural metadata, dependencies, and usage metrics for a single file.
+ */
+export class GraphNode {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.incomingEdges = new Set(); // Files that import THIS file
+    this.outgoingEdges = new Set(); // Files that THIS file imports
+    
+    this.explicitImports = new Set(); // Raw import strings
+    this.importedSymbols = new Set(); // "file:symbol" or "file:*"
+    this.internalExports = new Map(); // symbol -> { type, start, end, ... }
+    
+    this.externalPackageUsage = new Set();
+    this.instantiatedIdentifiers = new Set();
+    this.propertyAccessChains = new Set();
+    this.rawStringReferences = new Set();
+    this.jsxComponents = new Set();
+    this.jsxProps = new Set();
+    this.decorators = new Set();
+    this.dynamicImports = new Set();
+    this.calculatedDynamicImports = [];
+    
+    this.isEntry = false;
+    this.isLibraryEntry = false;
+    this.isFrameworkComponent = false;
+    this.symbolSourceLocations = new Map(); // symbol -> { line, column }
+    this.localSuppressedRules = new Set();
+  }
+
+  isSymbolReferencedExternally(symbolName, projectGraph, visited = new Set()) {
+    const visitKey = `${this.filePath}:${symbolName}`;
+    if (visited.has(visitKey)) return false;
+    visited.add(visitKey);
+
+    // Self-reference check
+    if (this.instantiatedIdentifiers.has(symbolName)) return true;
+    for (const accessChain of this.propertyAccessChains) {
+      if (accessChain.endsWith(`.${symbolName}`) || accessChain.includes(`.${symbolName}.`)) return true;
+    }
+    
+    for (const parentPath of this.incomingEdges) {
+      const parentNode = projectGraph.get(parentPath);
+      if (!parentNode) continue;
+
+      // Direct Import Tokens
+      const absoluteImportKey = `${this.filePath}:${symbolName}`;
+      const absoluteStarKey = `${this.filePath}:*`;
+      if (parentNode.importedSymbols.has(absoluteImportKey) || parentNode.importedSymbols.has(absoluteStarKey)) return true;
+      
+      // Advanced Member Usage Detection
+      if (parentNode.propertyAccessChains.has(symbolName)) return true;
+      
+      // If it's a member access like 'Logger.error' or 'app.start', we check for the leaf name usage.
+      if (symbolName.includes('.')) {
+          const parts = symbolName.split('.');
+          const leafName = parts[parts.length - 1];
+          const parentName = parts[0];
+          
+          if ((parentNode.instantiatedIdentifiers.has(parentName) || 
+               parentNode.importedSymbols.has(`${this.filePath}:${parentName}`)) &&
+              parentNode.instantiatedIdentifiers.has(leafName)) {
+              return true;
+          }
+      }
+
+      // Dynamic Import Check
+      if (parentNode.dynamicImports.has(this.filePath) || parentNode.explicitImports.has(this.filePath)) {
+         if (parentNode.dynamicImports.has(this.filePath)) return true;
+      }
+
+      // Recursive Re-export Resolution
+      for (const [exportedName, exportMeta] of parentNode.internalExports.entries()) {
+        const isMatch = (exportMeta.type === 're-export' || exportMeta.type === 're-export-namespace' || exportMeta.type === 're-export-all') && 
+                        (exportMeta.originalName === symbolName || exportMeta.originalName === '*' || exportMeta.type === 're-export-all') && 
+                        (exportMeta.source === this.filePath || (exportMeta.source && path.resolve(path.dirname(parentPath), exportMeta.source) === this.filePath));
+        
+        if (isMatch) {
+          if (parentNode.isSymbolReferencedExternally(exportedName, projectGraph, visited)) return true;
+        }
+      }
+
+      // Fuzzy / Dynamic usage (Identifiers, Strings, JSX, Decorators)
+      // UPGRADE: Only check for fuzzy matches if we have a reason to believe it might be used.
+      // We skip global names like 'toLowerCase' unless they are explicitly imported.
+      const isGlobalName = ['toLowerCase', 'toUpperCase', 'toString', 'valueOf', 'hasOwnProperty', 'constructor'].includes(symbolName);
+      
+      if (!isGlobalName) {
+        if (parentNode.instantiatedIdentifiers.has(symbolName)) return true;
+        if (parentNode.rawStringReferences.has(symbolName)) return true;
+        if (parentNode.jsxComponents.has(symbolName)) return true;
+        if (parentNode.decorators.has(symbolName)) return true;
+      }
+      
+      for (const accessChain of parentNode.propertyAccessChains) {
+        if (accessChain.endsWith(`.${symbolName}`) || accessChain.includes(`.${symbolName}.`)) return true;
+      }
+    }
+
+    return false;
+  }
+}
+
+export class EngineContext {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+    this.projectGraph = new Map(); // Path -> GraphNode
+    this.usedExternalPackages = new Set();
+    this.unimportedUsedPackages = new Set();
+    this.importedUnusedPackages = new Set();
+    this.unusedBinaries = new Set();
+    this.manifestDependencies = new Map();
+    
+    this.isWorkspaceEnabled = false;
+    this.monorepoPackageRoots = new Set();
+    this.verbose = false;
+    this.metrics = { totalFilesScanned: 0, cacheHits: 0, cacheMisses: 0 };
+    this.allSecretFindings = [];
+  }
+
+  getOrCreateNode(filePath) {
+    if (!this.projectGraph.has(filePath)) {
+      this.projectGraph.set(filePath, new GraphNode(filePath));
+      // NEW: Automatically track package.json files in manifestDependencies
+      if (filePath.endsWith('package.json')) {
+        this.manifestDependencies.set(filePath, new Set());
+      }
+    }
+    return this.projectGraph.get(filePath);
+  }
+
+  async generateSummaryReport() {
+    const report = {
+      orphanedFiles: [],
+      deadExports: [],
+      unusedDependencies: [],
+      unimportedUsedPackages: [],
+      importedUnusedPackages: [],
+      unusedBinaries: []
+    };
+
+    // --- DEEP REACHABILITY ANALYSIS (BFS) ---
+    const reachableFiles = new Set();
+    const queue = [];
+
+    // 1. Initialize BFS with Entry Points
+    for (const [filePath, node] of this.projectGraph.entries()) {
+      // FIX: Also check if the file is explicitly mentioned in package.json bin or main
+      if (node.isEntry || node.isLibraryEntry || node.isFrameworkComponent) {
+        reachableFiles.add(filePath);
+        queue.push(filePath);
+      }
+    }
+    
+    // UPGRADE: Ensure package.json main and bin are always entry points
+    // UPGRADE: Comprehensive Entry Point Discovery (Manifests + Tooling)
+    for (const [manifestPath, deps] of this.manifestDependencies.entries()) {
+        try {
+            const data = JSON.parse(fsSync.readFileSync(manifestPath, 'utf8'));
+            const pkgDir = path.dirname(manifestPath);
+            const entries = [];
+            
+            // 1. Standard Manifest Entries
+            if (data.main) entries.push(path.resolve(pkgDir, data.main));
+            if (data.module) entries.push(path.resolve(pkgDir, data.module));
+            if (data.exports) {
+                const unwind = (val) => {
+                    if (typeof val === 'string') entries.push(path.resolve(pkgDir, val));
+                    else if (typeof val === 'object' && val !== null) Object.values(val).forEach(unwind);
+                };
+                unwind(data.exports);
+            }
+            if (data.bin) {
+                if (typeof data.bin === 'string') entries.push(path.resolve(pkgDir, data.bin));
+                else Object.values(data.bin).forEach(b => entries.push(path.resolve(pkgDir, b)));
+            }
+
+            // 2. Protect Documentation & Configs
+            const possibleConfigs = ['vite.config.mjs', 'vite.config.ts', 'vitest.config.ts', 'tsconfig.json'];
+            possibleConfigs.forEach(c => entries.push(path.resolve(pkgDir, c)));
+
+            entries.forEach(e => {
+                const normalized = e.replace(/\\/g, '/');
+                // Check with common extensions if not found
+                const candidates = [normalized, normalized + '.mjs', normalized + '.ts', normalized + '.tsx', normalized + '/index.mjs', normalized + '/index.ts'];
+                for (const cand of candidates) {
+                    if (this.projectGraph.has(cand) && !reachableFiles.has(cand)) {
+                        reachableFiles.add(cand);
+                        queue.push(cand);
+                        this.projectGraph.get(cand).isEntry = true;
+                        break;
+                    }
+                }
+            });
+
+            // --- PLUGIN-BASED ECOSYSTEM DETECTION ---
+            // Plugins will now handle their own reachability and dependency validation.
+            if (this.pluginRegistry) {
+                const activePlugins = await this.pluginRegistry.getActivePlugins(pkgDir);
+                for (const plugin of activePlugins) {
+                    if (typeof plugin.onDiscovery === 'function') {
+                        await plugin.onDiscovery({
+                            pkgDir,
+                            data,
+                            reachableFiles,
+                            queue,
+                            projectGraph: this.projectGraph,
+                            context: this
+                        });
+                    }
+                }
+            }
+        } catch (e) {}
+    }
+
+    // 2. BFS Traversal
+    while (queue.length > 0) {
+      const currentPath = queue.shift();
+      const node = this.projectGraph.get(currentPath);
+      
+      if (!node) continue;
+
+      // Track outgoing edges (static and linked dynamic imports)
+      if (node.outgoingEdges) {
+        for (const outgoingPath of node.outgoingEdges) {
+          const normalizedPath = outgoingPath.replace(/\\/g, '/');
+          if (!reachableFiles.has(normalizedPath)) {
+            reachableFiles.add(normalizedPath);
+            queue.push(normalizedPath);
+          }
+        }
+      }
+
+      // UPGRADE: Handle non-literal dynamic imports (calculatedDynamicImports)
+      if ((node.calculatedDynamicImports && node.calculatedDynamicImports.length > 0) || (node.dynamicImports && node.dynamicImports.has('__DYNAMIC_PATTERN__'))) {
+        const dir = path.dirname(currentPath);
+        // Conservative: If we have a calculated dynamic import, any file in the same or sub directory could be a target
+        for (const [otherPath, _] of this.projectGraph.entries()) {
+          // Fix: Check if otherPath is in the same directory or a subdirectory of 'dir'
+          if (otherPath !== currentPath && otherPath.startsWith(dir) && !reachableFiles.has(otherPath)) {
+            // Additional check: If it's in a 'plugins' or 'modules' folder, it's very likely a dynamic target
+            const isLikelyDynamicTarget = otherPath.includes('/plugins/') || otherPath.includes('/modules/') || otherPath.includes('/dynamic/');
+            if (isLikelyDynamicTarget) {
+              reachableFiles.add(otherPath);
+              queue.push(otherPath);
+            }
+          }
+        }
+      }
+
+      // UPGRADE: Handle Worker/Threads usage (new Worker('path'))
+      for (const chain of node.propertyAccessChains) {
+        if (chain.includes('new Worker(') || chain.includes('Worker(')) {
+          // Check if any file path is mentioned in raw strings
+          for (const str of node.rawStringReferences) {
+            if (str.startsWith('.') || str.startsWith('/')) {
+              try {
+                const resolved = path.resolve(path.dirname(currentPath), str);
+                const extensions = ['.mjs', '.ts', '.mjs', '.cjs'];
+                for (const ext of extensions) {
+                  const p = resolved.endsWith(ext) ? resolved : resolved + ext;
+                  const normalized = p.replace(/\\/g, '/');
+                  if (this.projectGraph.has(normalized) && !reachableFiles.has(normalized)) {
+                    reachableFiles.add(normalized);
+                    queue.push(normalized);
+                  }
+                }
+              } catch (e) {}
+            }
+          }
+        }
+      }
+      
+      // Additional check for unlinked dynamic imports (conservative)
+      if (node.dynamicImports) {
+          for (const dynamicPath of node.dynamicImports) {
+              if (dynamicPath.startsWith('__DYNAMIC_PATTERN__:')) {
+                  const pattern = dynamicPath.split(':')[1];
+                  const dir = path.dirname(currentPath);
+                  for (const [otherPath, _] of this.projectGraph.entries()) {
+                      if (otherPath.startsWith(dir) && !reachableFiles.has(otherPath)) {
+                          reachableFiles.add(otherPath);
+                          queue.push(otherPath);
+                      }
+                  }
+              }
+          }
+      }
+    }
+
+    // --- ANALYSIS PHASE ---
+    if (this.verbose) {
+      console.log(`[Reachability] Total reachable files: ${reachableFiles.size}`);
+      for (const f of reachableFiles) console.log(`  • Reachable: ${path.relative(this.cwd, f)}`);
+    }
+    for (const [filePath, node] of this.projectGraph.entries()) {
+      const isSuppressed = node.localSuppressedRules.has('*') || node.localSuppressedRules.has('unused-file');
+      const isReachable = reachableFiles.has(filePath);
+      
+      // Check for Orphaned Files
+      if (!isReachable && !isSuppressed) {
+        const relPath = path.relative(this.cwd, filePath).replace(/\\/g, '/');
+        report.orphanedFiles.push(relPath);
+      }
+
+      // Check for Dead Exports
+      if (isReachable) {
+        const isPublicAPI = node.isEntry || node.isLibraryEntry;
+        
+        for (const [symbol, meta] of node.internalExports.entries()) {
+          if (symbol === '*' || symbol === 'default' || node.localSuppressedRules.has('unused-export') || node.localSuppressedRules.has(`unused-export:${symbol}`)) {
+            continue;
+          }
+
+          const isSymbolUsed = isPublicAPI || node.isSymbolReferencedExternally(symbol, this.projectGraph);
+
+          if (!isSymbolUsed) {
+            const loc = node.symbolSourceLocations.get(symbol) || { line: 0, column: 0 };
+            report.deadExports.push({
+              symbol,
+              file: path.relative(this.cwd, filePath),
+              line: loc.line
+            });
+          }
+
+          // Member Analysis
+          if (meta.members && meta.members.length > 0 && isSymbolUsed) {
+            for (const member of meta.members) {
+              const fullMemberName = `${symbol}.${member.name}`;
+              
+              if (isPublicAPI && member.isPublic !== false) {
+                  continue; 
+              }
+
+              // UPGRADE: Check for dynamic usage in ANY reachable file, not just direct imports
+              let isMemberUsed = false;
+              for (const [otherPath, otherNode] of this.projectGraph.entries()) {
+                if (reachableFiles.has(otherPath)) {
+                  if (otherNode.instantiatedIdentifiers.has(member.name) || 
+                      otherNode.propertyAccessChains.has(fullMemberName) ||
+                      otherNode.rawStringReferences.has(member.name)) {
+                    isMemberUsed = true;
+                    break;
+                  }
+                }
+              }
+
+              if (!isMemberUsed && !node.isSymbolReferencedExternally(fullMemberName, this.projectGraph)) {
+                const loc = node.symbolSourceLocations.get(fullMemberName) || { line: 0, column: 0 };
+                report.deadExports.push({
+                  symbol: fullMemberName,
+                  file: path.relative(this.cwd, filePath),
+                  line: loc.line
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // --- DEPENDENCY ANALYSIS ---
+    const usedByReachableFiles = new Set();
+    reachableFiles.forEach(filePath => {
+      const node = this.projectGraph.get(filePath);
+      if (node) {
+        node.externalPackageUsage.forEach(pkg => usedByReachableFiles.add(pkg));
+        
+        // Conservative check for dynamic imports in reachable files
+        if (node.calculatedDynamicImports) {
+          node.calculatedDynamicImports.forEach(entry => {
+            const expr = typeof entry === 'string' ? entry : (entry.pattern || entry.text || '');
+            // If it looks like a package name (no dots/slashes), assume it's used
+            if (expr && !expr.includes('.') && !expr.includes('/') && !expr.includes('`') && !expr.includes("'") && !expr.includes('"')) {
+               usedByReachableFiles.add(expr);
+            }
+            // Check raw strings for potential package names
+            node.rawStringReferences.forEach(str => {
+               if (!str.startsWith('.') && !str.startsWith('/')) {
+                  const pkg = str.startsWith('@') ? str.split('/').slice(0, 2).join('/') : str.split('/')[0];
+                  usedByReachableFiles.add(pkg);
+               }
+            });
+          });
+        }
+      }
+    });
+
+    for (const [manifestPath, deps] of this.manifestDependencies.entries()) {
+      const allDeps = [...(deps.dependencies || []), ...(deps.devDependencies || [])];
+      const hasTypeScriptFiles = Array.from(this.projectGraph.keys()).some(f => f.endsWith('.ts') || f.endsWith('.tsx'));
+      
+      for (const dep of allDeps) {
+        if (dep.startsWith('@types/') || dep === 'entkapp' || (dep === 'typescript' && hasTypeScriptFiles)) {
+          continue;
+        }
+        
+        // UPGRADE: Be more aggressive in detecting unused dependencies.
+        // Check both externalPackageUsage and rawStringReferences.
+        const isUsed = usedByReachableFiles.has(dep) || 
+                       Array.from(reachableFiles).some(f => {
+                         const node = this.projectGraph.get(f);
+                         return node && (node.externalPackageUsage.has(dep) || node.rawStringReferences.has(dep));
+                       });
+
+        if (!isUsed) {
+          report.unusedDependencies.push({
+            package: dep,
+            type: deps.dependencies.includes(dep) ? 'dependency' : 'devDependency',
+            manifest: path.relative(this.cwd, manifestPath)
+          });
+          this.importedUnusedPackages.add(dep);
+        }
+      }
+    }
+    
+    report.unimportedUsedPackages = Array.from(this.unimportedUsedPackages);
+    report.importedUnusedPackages = Array.from(this.importedUnusedPackages);
+    report.unusedBinaries = Array.from(this.unusedBinaries);
+
+    return report;
+  }
+}

package/src/Initializer.mjs

@@ -0,0 +1,82 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+
+/**
+ * Entkapp Initializer: Analyzes the codebase to generate a package.json
+ * with correctly categorized dependencies and devDependencies.
+ */
+export class Initializer {
+  constructor(context) {
+    this.context = context;
+  }
+
+  async run() {
+    console.log("🚀 Starting entkapp intelligent initialization...");
+    const cwd = this.context.cwd || process.cwd();
+    
+    // 1. Scan for all JS/TS files
+    const files = await glob('**/*.{js,ts,jsx,tsx,vue,svelte,astro}', { 
+      ignore: ['node_modules/**', 'dist/**', '.git/**'],
+      cwd 
+    });
+
+    const dependencies = new Set();
+    const devDependencies = new Set();
+
+    // Common dev tool indicators
+    const devIndicators = ['test', 'spec', 'config', 'stories', 'mock'];
+
+    console.log(`🔍 Analyzing ${files.length} files for imports...`);
+
+    for (const file of files) {
+      const content = await fs.readFile(path.join(cwd, file), 'utf8');
+      const isDevFile = devIndicators.some(ind => file.toLowerCase().includes(ind));
+
+      // Simple but effective regex for imports
+      const importMatches = content.matchAll(/(?:import|from|require)\s*\(?\s*['"]([^' "./][^'"]*)['"]/g);
+      
+      for (const match of importMatches) {
+        const pkg = this.extractPackageName(match[1]);
+        if (pkg && !this.isBuiltIn(pkg)) {
+          if (isDevFile) devDependencies.add(pkg);
+          else dependencies.add(pkg);
+        }
+      }
+    }
+
+    // 2. Generate package.json
+    const pkgJson = {
+      name: path.basename(cwd),
+      version: "1.0.0",
+      description: "Initialized with entkapp",
+      main: "index.mjs",
+      scripts: {
+        "entkapp:run": "entkapp -r",
+        "entkapp:check": "entkapp -r --verbose"
+      },
+      dependencies: Object.fromEntries([...dependencies].sort().map(d => [d, "latest"])),
+      devDependencies: Object.fromEntries([...devDependencies].sort().map(d => [d, "latest"]))
+    };
+
+    await fs.writeFile(path.join(cwd, 'package.json'), JSON.stringify(pkgJson, null, 2));
+    console.log("✅ package.json generated with analyzed dependencies.");
+    
+    // 3. Create /entkapp folder
+    await fs.mkdir(path.join(cwd, 'entkapp'), { recursive: true });
+    console.log("✅ /entkapp configuration folder created.");
+  }
+
+  extractPackageName(specifier) {
+    if (specifier.startsWith('@')) {
+      const parts = specifier.split('/');
+      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    }
+    return specifier.split('/')[0];
+  }
+
+  isBuiltIn(pkg) {
+    const builtins = ['path', 'fs', 'os', 'crypto', 'http', 'https', 'stream', 'util', 'events', 'module', 'process'];
+    return builtins.includes(pkg) || pkg.startsWith('node:');
+  }
+}

package/src/analyzers/CodeSmellAnalyzer.mjs

@@ -0,0 +1,106 @@
+/**
+ * CodeSmellAnalyzer: Performs deep static analysis to find runtime risks and logic smells.
+ */
+export class CodeSmellAnalyzer {
+  constructor(context) {
+    this.context = context;
+    this.issues = [];
+    this.rules = {
+      'potential-null-pointer': {
+        message: 'Potential Null Pointer Risk: Accessing property on an object that might be undefined.',
+        link: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cant_access_property'
+      },
+      'infinite-loop-risk': {
+        message: 'Potential Infinite Loop: Loop condition does not seem to change within the body.',
+        link: 'https://en.wikipedia.org/wiki/Infinite_loop'
+      },
+      'implicit-type-coercion': {
+        message: 'Implicit Type Coercion: Using loose equality (==) can lead to unexpected runtime behavior.',
+        link: 'https://dorey.github.io/JavaScript-Equality-Table/'
+      }
+    };
+  }
+
+  analyze(fileNode) {
+    if (!fileNode.ast) return;
+    this.walk(fileNode.ast, fileNode);
+  }
+
+  walk(node, fileNode) {
+    if (!node) return;
+
+    // 1. Check for Loose Equality (==)
+    if (node.type === 'BinaryExpression' && (node.operator === '==' || node.operator === '!=')) {
+      this.addIssue('implicit-type-coercion', node, fileNode);
+    }
+
+    // 2. Check for Potential Infinite Loops (While loops with static conditions)
+    if (node.type === 'WhileStatement' && node.test.type === 'Literal' && node.test.value === true) {
+      // Check if there is a break or return inside
+      if (!this.hasExitStatement(node.body)) {
+        this.addIssue('infinite-loop-risk', node, fileNode);
+      }
+    }
+
+    // 3. Check for Null Pointer Risks (Accessing properties on potentially uninitialized vars)
+    if (node.type === 'MemberExpression' && node.object.type === 'Identifier') {
+      const varName = node.object.name;
+      if (this.isPotentiallyNull(varName, fileNode)) {
+        this.addIssue('potential-null-pointer', node, fileNode);
+      }
+    }
+
+    // Recursively walk the AST
+    for (const key in node) {
+      if (node[key] && typeof node[key] === 'object') {
+        if (Array.isArray(node[key])) {
+          node[key].forEach(child => this.walk(child, fileNode));
+        } else {
+          this.walk(node[key], fileNode);
+        }
+      }
+    }
+  }
+
+  addIssue(ruleId, node, fileNode) {
+    const rule = this.rules[ruleId];
+    fileNode.diagnostics = fileNode.diagnostics || [];
+    fileNode.diagnostics.push({
+      ruleId,
+      message: rule.message,
+      link: rule.link,
+      line: node.start ? this.getLineNumber(node.start, fileNode.content) : 0,
+      severity: 'warning'
+    });
+  }
+
+  hasExitStatement(node) {
+    let found = false;
+    const check = (n) => {
+      if (!n || found) return;
+      if (n.type === 'BreakStatement' || n.type === 'ReturnStatement' || n.type === 'ThrowStatement') {
+        found = true;
+        return;
+      }
+      for (const key in n) {
+        if (n[key] && typeof n[key] === 'object') {
+          if (Array.isArray(n[key])) n[key].forEach(check);
+          else check(n[key]);
+        }
+      }
+    };
+    check(node);
+    return found;
+  }
+
+  isPotentiallyNull(name, fileNode) {
+    // Simple heuristic: if it's a variable declared without init or in a try-catch
+    const symbol = fileNode.symbolTable?.get(name);
+    return symbol && symbol.type === 'variable' && !symbol.initialized;
+  }
+
+  getLineNumber(pos, content) {
+    if (!content) return 0;
+    return content.substring(0, pos).split('\n').length;
+  }
+}

package/src/analyzers/OxcAnalyzer.mjs

@@ -0,0 +1,11 @@
+import { OxcAnalyzer as CoreOxcAnalyzer } from '../ast/OxcAnalyzer.mjs';
+
+/**
+ * Proxy for the Core OxcAnalyzer to maintain backward compatibility
+ * while centralizing the implementation.
+ */
+export class OxcAnalyzer extends CoreOxcAnalyzer {
+    constructor(context) {
+        super(context);
+    }
+}