entkapp 4.1.0

package/src/ast/BarrelParser.js

@@ -0,0 +1,221 @@
+import ts from 'typescript';
+import fs from 'fs/promises';
+
+/**
+ * Enterprise Wildcard Optimization & Flattening Layer for Barrel Operations
+ * Traces unreferenced paths through redistribution entries.
+ */
+export class BarrelParser {
+  constructor(context, resolver) {
+    this.context = context;
+    this.resolver = resolver;
+    this.cachedSpecifications = new Map();
+  }
+
+  /**
+   * Compiles the structural export layout for a specific index or barrel target.
+   * @param {string} filePath - Absolute path to on-disk target element
+   */
+  async parseBarrelSpecification(filePath) {
+    if (this.cachedSpecifications.has(filePath)) {
+      return this.cachedSpecifications.get(filePath);
+    }
+
+    const specification = {
+      isBarrelInstance: false,
+      wildcardExports: new Set(),         // export * from './module';
+      namespacedWildcardExports: new Map(), // export * as Utils from './module';
+      forwardedNamedExports: new Map(),   // export { token as alias } from './module';
+      declaredLocalExports: new Set()      // export const a = 1;
+    };
+
+    try {
+      const code = await fs.readFile(filePath, 'utf8');
+      const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+
+      this.harvestExportSignatures(sourceFile, specification);
+
+      if (specification.wildcardExports.size > 0 || 
+          specification.namespacedWildcardExports.size > 0 || 
+          specification.forwardedNamedExports.size > 0) {
+        specification.isBarrelInstance = true;
+      }
+
+      this.cachedSpecifications.set(filePath, specification);
+      return specification;
+    } catch {
+      return specification; // Error state defaults to safe boundaries layout manifest
+    }
+  }
+
+  harvestExportSignatures(node, spec) {
+    if (!node) return;
+
+    switch (node.kind) {
+      case ts.SyntaxKind.ExportDeclaration: {
+        const targetSpecifier = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)
+          ? node.moduleSpecifier.text
+          : null;
+
+        if (targetSpecifier) {
+          if (!node.exportClause) {
+            // Standard Wildcard Transfer: export * from './module';
+            spec.wildcardExports.add(targetSpecifier);
+          } else if (ts.isNamespaceExport(node.exportClause)) {
+            // Namespaced Wildcard Transfer: export * as Core from './module';
+            const namespaceAlias = node.exportClause.name.text;
+            spec.namespacedWildcardExports.set(namespaceAlias, targetSpecifier);
+          } else if (ts.isNamedExports(node.exportClause)) {
+            // Selective Re-export Forwarding: export { x, y as z } from './module';
+            node.exportClause.elements.forEach(element => {
+              const originalSymbol = element.propertyName ? element.propertyName.text : element.name.text;
+              const exposedAlias = element.name.text;
+              spec.forwardedNamedExports.set(exposedAlias, {
+                targetModule: targetSpecifier,
+                sourceSymbol: originalSymbol
+              });
+            });
+          }
+        }
+        break;
+      }
+
+      // Track items declared directly within the file boundary
+      case ts.SyntaxKind.FunctionDeclaration:
+      case ts.SyntaxKind.ClassDeclaration:
+      case ts.SyntaxKind.InterfaceDeclaration:
+      case ts.SyntaxKind.TypeAliasDeclaration:
+      case ts.SyntaxKind.EnumDeclaration: {
+        if (node.modifiers && node.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          if (node.name && ts.isIdentifier(node.name)) {
+            spec.declaredLocalExports.add(node.name.text);
+          }
+        }
+        break;
+      }
+
+      case ts.SyntaxKind.VariableStatement: {
+        if (node.modifiers && node.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          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);
+                }
+              });
+            }
+          });
+        }
+        break;
+      }
+
+      // Track default exports declared directly within the file boundary:
+      // Handles both `export default function foo()` and `export default expression`.
+      // The canonical symbol name stored is 'default' so that forwardedNamedExports
+      // entries whose sourceSymbol is 'default' can resolve correctly via Rule A.
+      case ts.SyntaxKind.ExportAssignment: {
+        // ExportAssignment covers `export default <expr>` (isExportEquals === false)
+        // as well as `export = <expr>` (isExportEquals === true, CommonJS style).
+        // We register 'default' for both to ensure the barrel tracer can settle here.
+        spec.declaredLocalExports.add('default');
+        break;
+      }
+    }
+
+    ts.forEachChild(node, child => this.harvestExportSignatures(child, spec));
+  }
+
+  /**
+   * Challenge #3 Resolution Logic. Unwraps nested redistribution links to find origin source nodes.
+   * @param {string} contextFilePath - Current position filename vector pointer
+   * @param {string} targetSymbolName - Targeted semantic variable signature name
+   * @param {Map} activeProjectGraph - Global active module maps directory registry
+   * @param {Set} [protectionStack] - Avoids cyclic validation traps inside self-referencing links
+   */
+  async determineSymbolDeclarationOrigin(contextFilePath, targetSymbolName, activeProjectGraph, protectionStack = new Set()) {
+    if (protectionStack.has(contextFilePath)) {
+      return { originFile: contextFilePath, originSymbol: targetSymbolName };
+    }
+    protectionStack.add(contextFilePath);
+
+    const spec = await this.parseBarrelSpecification(contextFilePath);
+    if (!spec.isBarrelInstance) {
+      return { originFile: contextFilePath, originSymbol: targetSymbolName };
+    }
+
+    // Rule A: Settle boundary immediately if local declaration matches token signature name
+    if (spec.declaredLocalExports.has(targetSymbolName)) {
+      return { originFile: contextFilePath, originSymbol: targetSymbolName };
+    }
+
+    // Rule B: Evaluate explicit named re-export mappings
+    if (spec.forwardedNamedExports.has(targetSymbolName)) {
+      const routingRule = spec.forwardedNamedExports.get(targetSymbolName);
+      const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, routingRule.targetModule);
+      if (fullyResolvedPath) {
+        return this.determineSymbolDeclarationOrigin(fullyResolvedPath, routingRule.sourceSymbol, activeProjectGraph, protectionStack);
+      }
+    }
+
+    // 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 (export * from 'module')
+    //
+    // Algorithm:
+    // 1. For each `export * from './child'`, recursively resolve the symbol in the child.
+    // 2. A non-barrel child immediately returns `{ originFile: childPath }` regardless of
+    //    whether it actually declares the symbol.  We therefore must verify that the
+    //    returned origin file actually contains the symbol in its declaredLocalExports
+    //    before accepting the result.
+    // 3. If the child is itself a barrel, the recursive call already performs the full
+    //    chain walk, so we only need to verify the final origin.
+    for (const relativePath of spec.wildcardExports) {
+      const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativePath);
+      
+      if (fullyResolvedPath) {
+        const continuousResolutionTrace = await this.determineSymbolDeclarationOrigin(
+          fullyResolvedPath,
+          targetSymbolName,
+          activeProjectGraph,
+          new Set(protectionStack) // Use a copy so sibling branches don't block each other
+        );
+
+        if (!continuousResolutionTrace) continue;
+        if (continuousResolutionTrace.originFile === contextFilePath) continue;
+
+        // Verify that the resolved origin actually declares the symbol.
+        // This prevents a non-barrel sibling (e.g. constants.ts) from being
+        // incorrectly returned for a symbol it does not export (e.g. formatData).
+        const originSpec = await this.parseBarrelSpecification(continuousResolutionTrace.originFile);
+        if (originSpec.declaredLocalExports.has(continuousResolutionTrace.originSymbol)) {
+          return continuousResolutionTrace;
+        }
+        // The origin spec is itself a barrel (isBarrelInstance = true) and the
+        // recursive call already resolved through it – accept the result.
+        if (originSpec.isBarrelInstance) {
+          return continuousResolutionTrace;
+        }
+      }
+    }
+
+    return { originFile: contextFilePath, originSymbol: targetSymbolName };
+  }
+}

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

@@ -0,0 +1,203 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { PluginRegistry } from '../plugins/PluginRegistry.js';
+
+/**
+ * Ecosystem Entry Point Manifest & Dynamic Framework Router Heuristic Validator
+ * Intercepts implicit conventions to handle cases where direct import statements are absent.
+ * Now refactored to use a pluggable architecture.
+ *
+ * Improvements over v1:
+ * - Extended config-file detection list (Biome, Oxlint, tsup, unbuild, etc.)
+ * - Next.js App Router conventions (page.tsx, layout.tsx, loading.tsx, error.tsx, etc.)
+ * - Remix conventions (route files under app/routes/)
+ * - SvelteKit conventions (+page.svelte, +layout.svelte, etc.)
+ * - Astro page/layout conventions
+ * - Common entry-point patterns (bin/, cli.ts, server.ts, main.ts, app.ts)
+ * - Test file patterns extended to cover Vitest workspace files
+ */
+export class MagicDetector {
+  constructor(context) {
+    this.context = context;
+    this.registry = new PluginRegistry(context);
+    this.isInitialized = false;
+  }
+
+  async ensureInitialized(baseDir) {
+    if (this.isInitialized) return;
+    await this.registry.init(baseDir || process.cwd());
+    this.isInitialized = true;
+  }
+
+  /**
+   * Audits the project context to map active micro-framework ecosystems.
+   * @param {string} baseContextDirectory - Root file workspace context execution vector path
+   */
+  async identifyActiveProjectEcosystems(baseContextDirectory) {
+    await this.ensureInitialized(baseContextDirectory);
+    const activePlugins = await this.registry.getActivePlugins(baseContextDirectory);
+    const activeFrameworkFlags = activePlugins.map(p => p.name);
+    
+    // Universal infrastructure overrides (testing platforms and common bundlers)
+    activeFrameworkFlags.push('universal-tooling-vectors');
+    return activeFrameworkFlags;
+  }
+
+  /**
+   * Assesses if a file path acts as an implicit route entry point.
+   */
+  async isImplicitlyRequiredByEcosystem(absolutePath, activeFrameworks, baseDir) {
+    await this.ensureInitialized();
+    const normalizedSystemPath = absolutePath.replace(/\\/g, '/');
+
+    const plugins = this.registry.getPlugins();
+    for (const plugin of plugins) {
+      if (activeFrameworks.includes(plugin.name)) {
+        const patterns = plugin.getRoutePatterns();
+        if (patterns.some(regex => regex.test(normalizedSystemPath))) {
+          return true;
+        }
+      }
+    }
+
+    // Apply baseline platform rules (Test suites, lint parameters, continuous integration files)
+    if (this.isCoreToolingSuiteElement(normalizedSystemPath)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  isCoreToolingSuiteElement(normalizedPath) {
+    // ── Test / spec files ──────────────────────────────────────────────────────
+    if (/\.(test|spec|e2e|cy)\.(js|ts|tsx|jsx)$/i.test(normalizedPath)) return true;
+    if (/\.stories\.(js|ts|tsx|jsx)$/i.test(normalizedPath)) return true;
+
+    // ── Build / bundler config files ───────────────────────────────────────────
+    const configFragments = [
+      // Test runners
+      'jest.config.', 'vitest.config.', 'vitest.workspace.',
+      'playwright.config.', 'cypress.config.',
+      // Bundlers
+      'webpack.config.', 'vite.config.', 'rollup.config.',
+      'esbuild.config.', 'parcel.config.',
+      'tsup.config.', 'unbuild.config.', 'pkgroll.config.',
+      // CSS / styling
+      'tailwind.config.', 'postcss.config.', '.postcssrc.',
+      // Linters / formatters
+      '.eslintrc.', 'eslint.config.', 'prettier.config.', '.prettierrc.',
+      '.stylelintrc.', 'stylelint.config.',
+      'biome.json', '.oxlintrc.',
+      // Babel / transpilation
+      '.babelrc.', 'babel.config.',
+      // Commit / git hooks
+      '.commitlintrc.', 'commitlint.config.',
+      '.lintstagedrc.', 'lint-staged.config.',
+      // Documentation
+      'typedoc.config.', 'typedoc.json',
+      // Monorepo tools
+      'turbo.json', 'nx.json', 'lerna.json',
+      // Misc tooling
+      'knip.config.', 'knip.json',
+      'syncpack.config.',
+      // Internal worker
+      'WorkerTaskRunner.js'
+    ];
+    if (configFragments.some(f => normalizedPath.includes(f))) return true;
+
+    // ── Common application entry points ───────────────────────────────────────
+    const entryPatterns = [
+      // CLI binaries
+      '/bin/cli.js', '/bin/cli.ts', '/bin/cli.mjs',
+      '/bin/index.js', '/bin/index.ts',
+      // Server / app entry points (Reduced in v3.3.8 to avoid false positives in libraries)
+      '/src/main.ts', '/src/main.js',
+      '/src/app.ts', '/src/app.js',
+      '/src/api/HeadlessAPI.js', '/src/api/PluginSDK.js',
+      '/main.ts', '/main.js',
+      '/app.ts', '/app.js',
+    ];
+    if (entryPatterns.some(p => normalizedPath.endsWith(p))) return true;
+
+    // ── Next.js App Router conventions ────────────────────────────────────────
+    // Files under app/ directory with Next.js special names
+    if (/\/app\/(page|layout|loading|error|not-found|template|default|route|middleware)\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    // Next.js Pages Router
+    if (/\/pages\/.*\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    // Next.js API routes
+    if (/\/pages\/api\/.*\.(js|ts)$/.test(normalizedPath)) return true;
+    // Next.js middleware
+    if (/\/middleware\.(js|ts)$/.test(normalizedPath)) return true;
+    // Next.js config
+    if (/\/next\.config\.(js|ts|mjs|cjs)$/.test(normalizedPath)) return true;
+
+    // ── Remix conventions ─────────────────────────────────────────────────────
+    if (/\/app\/routes\/.*\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    if (/\/app\/root\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    if (/\/app\/entry\.(client|server)\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+
+    // ── SvelteKit conventions ─────────────────────────────────────────────────
+    if (/\/\+page(\.(server|client))?\.(svelte|js|ts)$/.test(normalizedPath)) return true;
+    if (/\/\+layout(\.(server|client))?\.(svelte|js|ts)$/.test(normalizedPath)) return true;
+    if (/\/\+error\.(svelte|js|ts)$/.test(normalizedPath)) return true;
+    if (/\/\+server\.(js|ts)$/.test(normalizedPath)) return true;
+    if (/\/svelte\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
+
+    // ── Astro conventions ─────────────────────────────────────────────────────
+    if (/\/src\/pages\/.*\.astro$/.test(normalizedPath)) return true;
+    if (/\/src\/layouts\/.*\.astro$/.test(normalizedPath)) return true;
+    if (/\/astro\.config\.(mjs|js|ts)$/.test(normalizedPath)) return true;
+
+    // ── Nuxt conventions ──────────────────────────────────────────────────────
+    if (/\/pages\/.*\.vue$/.test(normalizedPath)) return true;
+    if (/\/layouts\/.*\.vue$/.test(normalizedPath)) return true;
+    if (/\/server\/api\/.*\.(js|ts)$/.test(normalizedPath)) return true;
+    if (/\/nuxt\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
+
+    // ── React / Vite entry points ─────────────────────────────────────────────
+    if (/\/vite\.config\.(js|ts|mjs)$/.test(normalizedPath)) return true;
+
+    // ── Angular conventions ───────────────────────────────────────────────────
+    if (/\/main\.(ts|js)$/.test(normalizedPath)) return true;
+    if (/\/app\.module\.(ts|js)$/.test(normalizedPath)) return true;
+    if (/\/angular\.json$/.test(normalizedPath)) return true;
+
+    // ── Expo / React Native ───────────────────────────────────────────────────
+    if (/\/app\/_layout\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+    if (/\/app\/index\.(js|ts|tsx|jsx)$/.test(normalizedPath)) return true;
+
+    return false;
+  }
+
+  /**
+   * Challenge #4 Framework Overrides. Protects interface boundaries from false positive report flags.
+   */
+  async injectVirtualConsumerEdges(filePath, fileNode, activeFrameworks) {
+    await this.ensureInitialized();
+    if (!await this.isImplicitlyRequiredByEcosystem(filePath, activeFrameworks)) return;
+
+    // Retain entry point elements within memory to keep verification safe
+    fileNode.isLibraryEntry = true;
+
+    // Apply dynamic exports coverage metrics based on active platform contracts
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const plugins = this.registry.getPlugins();
+
+    for (const plugin of plugins) {
+      if (activeFrameworks.includes(plugin.name)) {
+        const patterns = plugin.getRoutePatterns();
+        const appliesToFramework = patterns.some(regex => regex.test(normalizedPath));
+        
+        if (appliesToFramework) {
+          const contracts = plugin.getRequiredSystemContracts();
+          contracts.forEach(contractMethodToken => {
+            if (fileNode.internalExports.has(contractMethodToken)) {
+              // Emulate active local reference linkages to protect the export
+              fileNode.instantiatedIdentifiers.add(contractMethodToken);
+            }
+          });
+        }
+      }
+    }
+  }
+}