pkg-scaffold 3.3.3 → 3.3.4

package/src/ast/ASTAnalyzer.js

@@ -1,138 +1,123 @@
 import ts from 'typescript';
-import fs from 'fs/promises';
-import path from 'path';
-
-/**
- * Enterprise AST Syntax Walker & Feature Extractor
- * Upgraded to use full TypeScript Compiler API (ts.createProgram + TypeChecker)
- * for type-aware cross-file analysis.
- */
-import { OxcAnalyzer } from './OxcAnalyzer.js';
 
 export class ASTAnalyzer {
   constructor(context) {
     this.context = context;
-    this.program = null;
-    this.checker = null;
-    this.oxc = new OxcAnalyzer(context);
-  }
-
-  /**
-   * Initializes the TypeScript program for the entire project.
-   * This is crucial for cross-file type resolution.
-   */
-  initProgram(filePaths, options = {}) {
-    const defaultOptions = {
-      target: ts.ScriptTarget.Latest,
-      module: ts.ModuleKind.CommonJS,
-      allowJs: true,
-      checkJs: true,
-      esModuleInterop: true,
-      skipLibCheck: true
-    };
-    
-    this.program = ts.createProgram(filePaths, { ...defaultOptions, ...options });
-    this.checker = this.program.getTypeChecker();
+    this.scopeStack = [];
   }
 
-  /**
-   * Processes a file using the initialized program and type checker.
-   */
-  async processFile(filePath, fileNode) {
-    // Fast Path: Use OXC for rapid scanning if type checking is not strictly required for this file
-    if (this.context.fastMode && this.oxc.isAvailable) {
-      const success = await this.oxc.processFile(filePath, fileNode);
-      if (success) return true;
+  parseFile(filePath, content, fileNode) {
+    if (this.context.verbose) {
+      console.log(`[AST] Parsing: ${filePath}`);
     }
 
-    if (!this.program) {
-      throw new Error('ASTAnalyzer must be initialized with initProgram() before processing files.');
-    }
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      filePath.endsWith('.tsx') || filePath.endsWith('.jsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+    );
 
-    const sourceFile = this.program.getSourceFile(filePath);
-    if (!sourceFile) {
-      if (this.context.verbose) {
-        console.error(`[AST Error] Source file not found in program: ${filePath}`);
-      }
-      return false;
-    }
+    this.currentScope = { symbols: new Map(), parent: null };
+    this.scopeStack.push(this.currentScope);
 
     this.extractTopLevelJSDocSuppreessions(sourceFile, fileNode);
-    this.walkNode(sourceFile, sourceFile, fileNode);
-    
-    return true;
+    this.walkAST(sourceFile, fileNode, sourceFile);
+
+    this.scopeStack.pop(); // Pop the global scope
+    this.currentScope = null;
   }
 
-  walkNode(sourceFile, node, fileNode) {
-    if (!node) return;
+  pushScope() {
+    const newScope = { symbols: new Map(), parent: this.currentScope };
+    this.scopeStack.push(newScope);
+    this.currentScope = newScope;
+  }
 
-    // Use type checker to resolve symbols if needed
-    if (ts.isIdentifier(node) && !this.isNodeDeclarationName(node)) {
-      const symbol = this.checker.getSymbolAtLocation(node);
-      if (symbol) {
-        const declarations = symbol.getDeclarations();
-        if (declarations && declarations.length > 0) {
-          const declFile = declarations[0].getSourceFile().fileName;
-          const symbolName = symbol.getName();
-          
-          // Track sub-symbol usage (Property Access)
-          if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-             const parentType = this.checker.getTypeAtLocation(node.parent.expression);
-             const parentSymbol = parentType.getSymbol() || parentType.aliasSymbol;
-             if (parentSymbol) {
-               const parentDecl = parentSymbol.getDeclarations()?.[0];
-               if (parentDecl) {
-                 const parentFile = parentDecl.getSourceFile().fileName;
-                 fileNode.memberUsage = fileNode.memberUsage || new Set();
-                 fileNode.memberUsage.add(`${parentFile}:${parentSymbol.getName()}.${symbolName}`);
-               }
-             }
-          }
+  popScope() {
+    if (this.scopeStack.length > 1) {
+      this.scopeStack.pop();
+      this.currentScope = this.scopeStack[this.scopeStack.length - 1];
+    }
+  }
 
-          if (declFile !== sourceFile.fileName) {
-            fileNode.resolvedReferences = fileNode.resolvedReferences || new Set();
-            fileNode.resolvedReferences.add(`${declFile}:${symbolName}`);
-          }
-        }
+  addDeclaredSymbol(name, node, sourceFile) {
+    if (this.currentScope) {
+      const loc = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+      this.currentScope.symbols.set(name, { node, line: loc.line + 1, column: loc.character + 1 });
+    }
+  }
+
+  resolveSymbol(name) {
+    for (let i = this.scopeStack.length - 1; i >= 0; i--) {
+      const scope = this.scopeStack[i];
+      if (scope.symbols.has(name)) {
+        return scope.symbols.get(name);
       }
     }
+    return null;
+  }
+
+  walkAST(node, fileNode, sourceFile) {
+    // Handle scope entry for blocks, functions, classes, etc.
+    const isScopeNode = ts.isBlock(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node);
+    if (isScopeNode) {
+      this.pushScope();
+    }
 
     switch (node.kind) {
-      case ts.SyntaxKind.ImportDeclaration: {
-        this.handleImportDeclaration(node, fileNode);
+      case ts.SyntaxKind.ImportDeclaration:
+        this.handleImportDeclaration(node, fileNode, sourceFile);
         break;
-      }
-      case ts.SyntaxKind.ExportDeclaration: {
+      case ts.SyntaxKind.ExportDeclaration:
         this.handleExportDeclaration(node, fileNode, sourceFile);
         break;
-      }
+      case ts.SyntaxKind.ExportAssignment:
+        fileNode.internalExports.set('default', { type: 'default', start: node.getStart(sourceFile), end: node.getEnd() });
+        break;
+      case ts.SyntaxKind.VariableStatement:
+        this.handleVariableStatement(node, fileNode, sourceFile);
+        break;
       case ts.SyntaxKind.FunctionDeclaration:
       case ts.SyntaxKind.ClassDeclaration:
       case ts.SyntaxKind.InterfaceDeclaration:
       case ts.SyntaxKind.TypeAliasDeclaration:
       case ts.SyntaxKind.EnumDeclaration:
-      case ts.SyntaxKind.ModuleDeclaration: {
+      case ts.SyntaxKind.ModuleDeclaration:
         this.handleNamedDeclaration(node, fileNode, sourceFile);
         break;
-      }
-      case ts.SyntaxKind.VariableStatement: {
-        this.handleVariableStatement(node, fileNode, sourceFile);
-        break;
-      }
-      case ts.SyntaxKind.CallExpression: {
+      case ts.SyntaxKind.CallExpression:
         this.handleCallExpression(node, fileNode, sourceFile);
         break;
-      }
+      case ts.SyntaxKind.JsxElement:
+      case ts.SyntaxKind.JsxSelfClosingElement:
+        this.handleJsxElement(node, fileNode, sourceFile);
+        break;
+      case ts.SyntaxKind.Decorator:
+        this.handleDecorator(node, fileNode, sourceFile);
+        break;
+      case ts.SyntaxKind.Identifier:
+        // Track usage of identifiers
+        const symbol = this.resolveSymbol(node.text);
+        if (symbol) {
+          // fileNode.usedSymbols.add(`${symbol.node.parent.kind}:${node.text}`); // More granular tracking needed
+        }
+        break;
     }
 
-    ts.forEachChild(node, child => this.walkNode(sourceFile, child, fileNode));
+    ts.forEachChild(node, child => this.walkAST(child, fileNode, sourceFile));
+
+    if (isScopeNode) {
+      this.popScope();
+    }
   }
 
-  handleImportDeclaration(node, fileNode) {
+  handleImportDeclaration(node, fileNode, sourceFile) {
     if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
       const specifier = node.moduleSpecifier.text;
       fileNode.explicitImports.add(specifier);
-      
+
       if (node.importClause) {
         if (node.importClause.namedBindings) {
           if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -140,36 +125,80 @@ export class ASTAnalyzer {
               const importedName = element.name.text;
               const propertyName = element.propertyName ? element.propertyName.text : importedName;
               fileNode.importedSymbols.add(`${specifier}:${propertyName}`);
+              this.addDeclaredSymbol(element.name.text, element, sourceFile); // Add local import name to scope
             });
           } else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
             fileNode.importedSymbols.add(`${specifier}:*`);
+            this.addDeclaredSymbol(node.importClause.namedBindings.name.text, node.importClause.namedBindings, sourceFile); // Add namespace import to scope
           }
         }
         if (node.importClause.name) {
           fileNode.importedSymbols.add(`${specifier}:default`);
+          this.addDeclaredSymbol(node.importClause.name.text, node.importClause.name, sourceFile); // Add default import to scope
         }
       }
     }
   }
 
   handleExportDeclaration(node, fileNode, sourceFile) {
-    // Handle re-exports: export { x } from './y'
     if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
       const specifier = node.moduleSpecifier.text;
       if (node.exportClause && ts.isNamedExports(node.exportClause)) {
         node.exportClause.elements.forEach(element => {
           const name = element.name.text;
+          const propertyName = element.propertyName ? element.propertyName.text : name;
           fileNode.internalExports.set(name, { 
             type: 're-export', 
             source: specifier,
+            originalName: propertyName,
             start: node.getStart(sourceFile), 
             end: node.getEnd() 
           });
         });
+      } else if (node.exportClause && ts.isNamespaceExport(node.exportClause)) {
+        // export * as name from 'module'
+        const name = node.exportClause.name.text;
+        fileNode.internalExports.set(name, { type: 're-export-namespace', source: specifier, originalName: '*', start: node.getStart(sourceFile), end: node.getEnd() });
       } else {
-        // export * from './y'
+        // export * from 'module'
         fileNode.internalExports.set('*', { type: 're-export-all', source: specifier });
       }
+    } else if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+        node.exportClause.elements.forEach(element => {
+          const name = element.name.text;
+          const propertyName = element.propertyName ? element.propertyName.text : name;
+          fileNode.internalExports.set(name, { 
+            type: 'export', 
+            originalName: propertyName,
+            start: node.getStart(sourceFile), 
+            end: node.getEnd() 
+          });
+        });
+    } else if (node.declaration) {
+      // Direct export of a declaration (e.g., export const x = 1;)
+      if (ts.isVariableStatement(node.declaration)) {
+        node.declaration.declarationList.declarations.forEach(decl => {
+          if (decl.name && ts.isIdentifier(decl.name)) {
+            const name = decl.name.text;
+            fileNode.internalExports.set(name, { 
+              type: 'variable', 
+              start: decl.getStart(sourceFile), 
+              end: decl.getEnd() 
+            });
+            this.addDeclaredSymbol(name, decl, sourceFile);
+          }
+        });
+      } else if (ts.isFunctionDeclaration(node.declaration) || ts.isClassDeclaration(node.declaration)) {
+        const name = node.declaration.name?.text;
+        if (name) {
+          fileNode.internalExports.set(name, { 
+            type: ts.SyntaxKind[node.declaration.kind].toLowerCase().replace('declaration', ''), 
+            start: node.declaration.getStart(sourceFile), 
+            end: node.declaration.getEnd() 
+          });
+          this.addDeclaredSymbol(name, node.declaration, sourceFile);
+        }
+      }
     }
   }
 
@@ -183,35 +212,56 @@ export class ASTAnalyzer {
         start: node.getStart(sourceFile),
         end: node.getEnd()
       };
-
-      fileNode.internalExports.set(name, exportInfo);
       
-      // Phase 4: Drill down into members
+      fileNode.internalExports.set(name, exportInfo);
+
       if (ts.isEnumDeclaration(node)) {
-        exportInfo.members = node.members.map(m => m.name.getText(sourceFile));
+        exportInfo.members = node.members.map(m => ({
+          name: m.name.getText(sourceFile),
+          type: 'enumMember',
+          start: m.getStart(sourceFile),
+          end: m.getEnd()
+        }));
       } else if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
         exportInfo.members = node.members
           .filter(m => m.name)
-          .map(m => m.name.getText(sourceFile));
+          .map(m => ({
+            name: m.name.getText(sourceFile),
+            type: ts.SyntaxKind[m.kind].toLowerCase(),
+            start: m.getStart(sourceFile),
+            end: m.getEnd()
+          }));
       } else if (ts.isModuleDeclaration(node)) {
-        // Handle Namespaces
         const members = [];
         if (node.body && ts.isModuleBlock(node.body)) {
           node.body.statements.forEach(stmt => {
             if (this.hasExportModifier(stmt) && (ts.isVariableStatement(stmt) || ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt))) {
               if (ts.isVariableStatement(stmt)) {
-                stmt.declarationList.declarations.forEach(d => members.push(d.name.getText(sourceFile)));
+                stmt.declarationList.declarations.forEach(d => members.push({
+                  name: d.name.getText(sourceFile),
+                  type: 'variable',
+                  start: d.getStart(sourceFile),
+                  end: d.getEnd()
+                }));
               } else if (stmt.name) {
-                members.push(stmt.name.getText(sourceFile));
+                members.push({
+                  name: stmt.name.getText(sourceFile),
+                  type: ts.SyntaxKind[stmt.kind].toLowerCase().replace('declaration', ''),
+                  start: stmt.getStart(sourceFile),
+                  end: stmt.getEnd()
+                });
               }
             }
           });
         }
         exportInfo.members = members;
       }
-
+      
       const loc = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
       fileNode.symbolSourceLocations.set(name, { line: loc.line + 1, column: loc.character + 1 });
+      this.addDeclaredSymbol(name, node, sourceFile);
+    } else if (node.name && ts.isIdentifier(node.name)) {
+      this.addDeclaredSymbol(node.name.text, node, sourceFile);
     }
   }
 
@@ -225,32 +275,109 @@ export class ASTAnalyzer {
             start: decl.getStart(sourceFile), 
             end: decl.getEnd() 
           });
+          this.addDeclaredSymbol(name, decl, sourceFile);
+        } else if (decl.name && ts.isObjectBindingPattern(decl.name)) {
+           decl.name.elements.forEach(element => {
+               if(element.name && ts.isIdentifier(element.name)) {
+                   const name = element.name.text;
+                   fileNode.internalExports.set(name, {
+                       type: 'variable',
+                       start: element.getStart(sourceFile),
+                       end: element.getEnd()
+                   });
+                   this.addDeclaredSymbol(name, element, sourceFile);
+               }
+           });
+        } else if (decl.name && ts.isArrayBindingPattern(decl.name)) {
+            decl.name.elements.forEach(element => {
+               if(ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+                   const name = element.name.text;
+                   fileNode.internalExports.set(name, {
+                       type: 'variable',
+                       start: element.getStart(sourceFile),
+                       end: element.getEnd()
+                   });
+                   this.addDeclaredSymbol(name, element, sourceFile);
+               }
+           });
+        }
+      });
+    } else {
+      // Non-exported variable declarations also need to be added to scope
+      node.declarationList.declarations.forEach(decl => {
+        if (decl.name && ts.isIdentifier(decl.name)) {
+          this.addDeclaredSymbol(decl.name.text, decl, sourceFile);
+        } else if (decl.name && ts.isObjectBindingPattern(decl.name)) {
+          decl.name.elements.forEach(element => {
+            if (element.name && ts.isIdentifier(element.name)) {
+              this.addDeclaredSymbol(element.name.text, element, sourceFile);
+            }
+          });
+        } else if (decl.name && ts.isArrayBindingPattern(decl.name)) {
+          decl.name.elements.forEach(element => {
+            if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+              this.addDeclaredSymbol(element.name.text, element, sourceFile);
+            }
+          });
         }
       });
     }
   }
 
   handleCallExpression(node, fileNode, sourceFile) {
-    // Trace dynamic imports
     if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
       const arg = node.arguments[0];
       if (arg && ts.isStringLiteral(arg)) {
         fileNode.explicitImports.add(arg.text);
         fileNode.dynamicImports.add(arg.text);
       }
+    } else if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+      const arg = node.arguments[0];
+      if (arg && ts.isStringLiteral(arg)) {
+        fileNode.explicitImports.add(arg.text);
+      }
     }
   }
 
-  hasExportModifier(node) {
-    return node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+  handleJsxElement(node, fileNode, sourceFile) {
+    const getElementName = (name) => {
+      if (ts.isIdentifier(name)) return name.text;
+      if (ts.isPropertyAccessExpression(name)) return name.name.text;
+      return 'unknown';
+    };
+
+    const tagName = getElementName(node.openingElement.tagName);
+    fileNode.jsxComponents.add(tagName);
+
+    node.openingElement.attributes.properties.forEach(attr => {
+      if (ts.isJsxAttribute(attr) && ts.isIdentifier(attr.name)) {
+        fileNode.jsxProps.add(`${tagName}:${attr.name.text}`);
+      }
+    });
   }
 
-  isNodeDeclarationName(node) {
-    const parent = node.parent;
-    if (!parent) return false;
-    return (ts.isVariableDeclaration(parent) || ts.isFunctionDeclaration(parent) || 
-            ts.isClassDeclaration(parent) || ts.isInterfaceDeclaration(parent) || 
-            ts.isEnumDeclaration(parent) || ts.isModuleDeclaration(parent)) && parent.name === node;
+  handleDecorator(node, fileNode, sourceFile) {
+    const getDecoratorName = (expr) => {
+      if (ts.isIdentifier(expr)) return expr.text;
+      if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) return expr.expression.text;
+      if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) return expr.expression.name.text;
+      return 'unknown';
+    };
+
+    const decoratorName = getDecoratorName(node.expression);
+    fileNode.decorators.add(decoratorName);
+
+    // Optionally, extract decorator arguments
+    if (ts.isCallExpression(node.expression)) {
+      node.expression.arguments.forEach(arg => {
+        // Further analysis of arguments can be done here if needed
+        // e.g., if (ts.isStringLiteral(arg)) fileNode.decoratorArgs.add(`${decoratorName}:${arg.text}`);
+      });
+    }
+  }
+
+  hasExportModifier(node) {
+    return node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
   }
 
   extractTopLevelJSDocSuppreessions(sourceFile, fileNode) {

package/src/ast/BarrelParser.js

@@ -99,6 +99,18 @@ export class BarrelParser {
           node.declarationList.declarations.forEach(decl => {
             if (ts.isIdentifier(decl.name)) {
               spec.declaredLocalExports.add(decl.name.text);
+            } else if (ts.isObjectBindingPattern(decl.name)) {
+              decl.name.elements.forEach(element => {
+                if (element.name && ts.isIdentifier(element.name)) {
+                  spec.declaredLocalExports.add(element.name.text);
+                }
+              });
+            } else if (ts.isArrayBindingPattern(decl.name)) {
+              decl.name.elements.forEach(element => {
+                if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+                  spec.declaredLocalExports.add(element.name.text);
+                }
+              });
             }
           });
         }
@@ -148,36 +160,36 @@ export class BarrelParser {
     if (spec.forwardedNamedExports.has(targetSymbolName)) {
       const routingRule = spec.forwardedNamedExports.get(targetSymbolName);
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, routingRule.targetModule);
-      return this.determineSymbolDeclarationOrigin(fullyResolvedPath, routingRule.sourceSymbol, activeProjectGraph, protectionStack);
+      if (fullyResolvedPath) {
+        return this.determineSymbolDeclarationOrigin(fullyResolvedPath, routingRule.sourceSymbol, activeProjectGraph, protectionStack);
+      }
     }
 
-    // Rule C: Evaluate structural namespace alias groupings
-    if (spec.namespacedWildcardExports.has(targetSymbolName)) {
-      const relativeModule = spec.namespacedWildcardExports.get(targetSymbolName);
-      const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
-      return { originFile: fullyResolvedPath, originSymbol: '*' };
+    // Rule C: Evaluate structural namespace alias groupings (export * as name from 'module')
+    for (const [namespaceAlias, relativeModule] of spec.namespacedWildcardExports.entries()) {
+      // If the targetSymbolName is prefixed with the namespaceAlias, then it's a member of this namespace re-export
+      if (targetSymbolName.startsWith(`${namespaceAlias}.`)) {
+        const originalSymbol = targetSymbolName.substring(namespaceAlias.length + 1);
+        const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
+        if (fullyResolvedPath) {
+          return this.determineSymbolDeclarationOrigin(fullyResolvedPath, originalSymbol, activeProjectGraph, protectionStack);
+        }
+      }
     }
 
-    // Rule D: Sweep through anonymous star re-exports vectors
+    // Rule D: Sweep through anonymous star re-exports vectors (export * from 'module')
     for (const relativePath of spec.wildcardExports) {
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativePath);
       
-      // Look inside the graph metadata map configuration to verify child target availability
-      const targetSubSpec = await this.parseBarrelSpecification(fullyResolvedPath);
-      
-      if (targetSubSpec.declaredLocalExports.has(targetSymbolName) || 
-          targetSubSpec.forwardedNamedExports.has(targetSymbolName)) {
-        return this.determineSymbolDeclarationOrigin(fullyResolvedPath, targetSymbolName, activeProjectGraph, protectionStack);
-      }
-
-      // Dynamic recursive trace for multi-tier nested barrel file layouts
-      if (targetSubSpec.isBarrelInstance) {
+      if (fullyResolvedPath) {
+        // Look inside the graph metadata map configuration to verify child target availability
         const continuousResolutionTrace = await this.determineSymbolDeclarationOrigin(
           fullyResolvedPath,
           targetSymbolName,
           activeProjectGraph,
           protectionStack
         );
+        // If a resolution was found in a child barrel, return it
         if (continuousResolutionTrace && continuousResolutionTrace.originFile !== fullyResolvedPath) {
           return continuousResolutionTrace;
         }

package/src/ast/DeadCodeDetector.js

@@ -0,0 +1,73 @@
+export class DeadCodeDetector {
+  constructor(context) {
+    this.context = context;
+  }
+
+  detectDeadCode(graph) {
+    const deadFiles = [];
+    const deadExports = [];
+    
+    // Find all entry points
+    const entryPoints = new Set();
+    for (const [filePath, node] of graph.entries()) {
+      if (node.isEntry || node.isNextJsRoute || node.isSvelteComponent || node.isAstroPage) {
+        entryPoints.add(filePath);
+      }
+    }
+
+    // Traverse from entry points to find used files
+    const usedFiles = new Set();
+    const queue = Array.from(entryPoints);
+    
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!usedFiles.has(current)) {
+        usedFiles.add(current);
+        const node = graph.get(current);
+        if (node && node.outgoingEdges) {
+          for (const edge of node.outgoingEdges) {
+            queue.push(edge);
+          }
+        }
+      }
+    }
+
+    // Identify dead files
+    for (const filePath of graph.keys()) {
+      if (!usedFiles.has(filePath)) {
+        deadFiles.push(filePath);
+      }
+    }
+
+    // Identify dead exports in used files
+    for (const filePath of usedFiles) {
+      const node = graph.get(filePath);
+      if (!node) continue;
+      
+      // If it's an entry point, we consider its exports used (unless strictly configured otherwise)
+      if (node.isEntry) continue;
+
+      for (const [exportName, exportInfo] of node.internalExports.entries()) {
+        if (exportName === '*' || exportName === 'default') continue; // Skip wildcards for now
+        
+        let isUsed = false;
+        // Check incoming edges if they import this specific symbol
+        for (const [otherPath, otherNode] of graph.entries()) {
+          if (otherNode.outgoingEdges.has(filePath)) {
+            if (otherNode.importedSymbols.has(`${filePath}:${exportName}`) || 
+                otherNode.importedSymbols.has(`${filePath}:*`)) {
+              isUsed = true;
+              break;
+            }
+          }
+        }
+
+        if (!isUsed) {
+          deadExports.push({ file: filePath, symbol: exportName, line: exportInfo.start });
+        }
+      }
+    }
+
+    return { deadFiles, deadExports };
+  }
+}

package/src/ast/MagicDetector.js

@@ -68,7 +68,9 @@ export class MagicDetector {
       'jest.config.', 'vitest.config.', 'playwright.config.', 'cypress.config.',
       'webpack.config.', 'vite.config.', 'rollup.config.', 'tailwind.config.',
       '.eslintrc.', 'prettier.config.', '.postcssrc.', 'postcss.config.',
-      'bin/cli.js', 'index.js', 'WorkerTaskRunner.js'
+      'bin/cli.js', 'index.js', 'WorkerTaskRunner.js',
+      'src/server.ts', 'src/main.ts', 'src/app.ts', 'src/index.tsx', 'src/index.ts',
+      'server.ts', 'main.ts', 'app.ts'
     ];
     
     return testEnvironments.some(matchPattern => normalizedPath.includes(matchPattern));