swynx-lite 1.0.0

package/src/shared/scanner/analysers/generatedCode.mjs

@@ -0,0 +1,297 @@
+// src/scanner/analysers/generatedCode.mjs
+// Detection and exclusion of generated code files
+
+import { readFileSync, existsSync } from 'fs';
+import { basename, dirname } from 'path';
+
+/**
+ * Default patterns for generated code files
+ * These files should be excluded from dead code analysis
+ */
+export const DEFAULT_GENERATED_PATTERNS = [
+  // JavaScript/TypeScript
+  /\.generated\.(ts|tsx|js|jsx|mjs)$/,
+  /\.g\.(ts|js)$/,
+  /\/generated\//,
+  /\/__generated__\//,
+  /\/codegen\//,
+
+  // GraphQL
+  /\/graphql\.(ts|tsx|js)$/,
+  /\/gql\.(ts|tsx|js)$/,
+  /\.graphql\.(ts|tsx|js)$/,
+  /types\.generated\.(ts|tsx|js)$/,
+  /\/__graphql__\//,
+
+  // Protocol Buffers
+  /_pb\.(js|d\.ts)$/,
+  /_pb2\.py$/,
+  /_pb2_grpc\.py$/,
+  /\.pb\.(go|cc|h)$/,
+
+  // OpenAPI/Swagger
+  /\/api-client\//,
+  /\/swagger-client\//,
+  /\/openapi\/.*\.generated\./,
+
+  // Java build outputs
+  /\/target\/generated-sources\//,
+  /\/target\/generated-test-sources\//,
+  /\/build\/generated\//,
+  /\/build\/generated-sources\//,
+  /_\.java$/,  // MapStruct generated
+
+  // .NET build outputs
+  /\/obj\//,
+  /\.Designer\.cs$/,
+  /\.g\.cs$/,
+  /\.g\.i\.cs$/,
+  /\/Migrations\/.*\.cs$/,
+  /^Migrations\/.*\.cs$/,           // Migrations at repo root (relative paths)
+  /\.AssemblyAttributes\.cs$/,      // Auto-generated assembly attributes
+  /GlobalSuppressions\.cs$/,        // Auto-generated code analysis suppressions
+
+  // Go generated
+  /_gen\.go$/,
+  /mock_.*\.go$/,
+  /.*_mock\.go$/,
+  /\/mocks\/.*\.go$/,
+  /_string\.go$/,  // stringer
+
+  // Rust
+  /\.rs\.bk$/,
+
+  // Build outputs (all languages)
+  /\/dist\//,
+  /\/build\//,
+  /\/out\//,
+  /\/output\//,
+  /\/.next\//,
+  /\/.nuxt\//,
+  /\/.output\//,
+  /\/node_modules\//,
+  /\/vendor\//,
+
+  // Bazel outputs
+  /\/bazel-bin\//,
+  /\/bazel-out\//,
+  /\/bazel-testlogs\//
+];
+
+/**
+ * Header comments that indicate generated code
+ */
+const GENERATED_HEADERS = [
+  /^\/\/ Code generated .* DO NOT EDIT/i,
+  /^\/\/ AUTO-GENERATED/i,
+  /^\/\/ GENERATED CODE/i,
+  /^\/\/ This file was auto-?generated/i,
+  /^# Generated by/i,
+  /^# DO NOT EDIT/i,
+  /^\s*\* @generated/,
+  /^\/\*\s*eslint-disable\s*\*\//,  // Often in generated files
+  /^\/\/ @ts-nocheck/,  // Often in generated files
+  /@generated/,
+  /DO NOT EDIT THIS FILE/i,
+  /This file is auto-?generated/i,
+  /Generated from /i
+];
+
+/**
+ * Check if a file path matches generated code patterns
+ * @param {string} filePath - File path to check
+ * @param {RegExp[]} customPatterns - Additional patterns to check
+ * @returns {Object} - { isGenerated: boolean, matchedPattern: string|null }
+ */
+export function isGeneratedPath(filePath, customPatterns = []) {
+  const allPatterns = [...DEFAULT_GENERATED_PATTERNS, ...customPatterns];
+
+  for (const pattern of allPatterns) {
+    if (pattern.test(filePath)) {
+      return {
+        isGenerated: true,
+        matchedPattern: pattern.toString(),
+        reason: 'path'
+      };
+    }
+  }
+
+  return { isGenerated: false, matchedPattern: null };
+}
+
+/**
+ * Check if file content indicates generated code (by header comments)
+ * @param {string} content - File content
+ * @param {number} linesToCheck - Number of lines to check from start (default 20)
+ * @returns {Object} - { isGenerated: boolean, matchedPattern: string|null }
+ */
+export function isGeneratedContent(content, linesToCheck = 20) {
+  if (!content) return { isGenerated: false };
+
+  const lines = content.split('\n').slice(0, linesToCheck);
+  const headerText = lines.join('\n');
+
+  for (const pattern of GENERATED_HEADERS) {
+    if (pattern.test(headerText)) {
+      return {
+        isGenerated: true,
+        matchedPattern: pattern.toString(),
+        reason: 'header'
+      };
+    }
+  }
+
+  return { isGenerated: false, matchedPattern: null };
+}
+
+/**
+ * Check if a file is generated (by path or content)
+ * @param {string} filePath - File path
+ * @param {string} [content] - File content (optional, will be read if not provided)
+ * @param {Object} options - Options
+ * @returns {Object} - { isGenerated: boolean, reason: string|null }
+ */
+export function isGeneratedFile(filePath, content = null, options = {}) {
+  const { customPatterns = [], checkContent = true } = options;
+
+  // First check path
+  const pathCheck = isGeneratedPath(filePath, customPatterns);
+  if (pathCheck.isGenerated) {
+    return pathCheck;
+  }
+
+  // Then check content if requested
+  if (checkContent) {
+    let fileContent = content;
+    if (!fileContent && existsSync(filePath)) {
+      try {
+        fileContent = readFileSync(filePath, 'utf-8');
+      } catch {
+        // Can't read file, assume not generated
+        return { isGenerated: false };
+      }
+    }
+
+    if (fileContent) {
+      const contentCheck = isGeneratedContent(fileContent);
+      if (contentCheck.isGenerated) {
+        return contentCheck;
+      }
+    }
+  }
+
+  return { isGenerated: false, reason: null };
+}
+
+/**
+ * Filter out generated files from a list
+ * @param {Array} files - Array of file objects with path/relativePath
+ * @param {Object} options - Options
+ * @returns {Object} - { included: Array, excluded: Array }
+ */
+export function filterGeneratedFiles(files, options = {}) {
+  const included = [];
+  const excluded = [];
+
+  for (const file of files) {
+    const filePath = file.relativePath || file.path || file;
+    const content = file.content || null;
+
+    const check = isGeneratedFile(filePath, content, options);
+    if (check.isGenerated) {
+      excluded.push({
+        file: filePath,
+        reason: check.reason,
+        pattern: check.matchedPattern
+      });
+    } else {
+      included.push(file);
+    }
+  }
+
+  return { included, excluded };
+}
+
+/**
+ * Get patterns for a specific codegen type
+ * @param {string} type - Codegen type (graphql, protobuf, openapi, etc.)
+ * @returns {RegExp[]} - Patterns for that type
+ */
+export function getPatternsForCodegenType(type) {
+  const typePatterns = {
+    graphql: [
+      /\.graphql\.(ts|tsx|js)$/,
+      /\/graphql\.(ts|tsx|js)$/,
+      /\/gql\.(ts|tsx|js)$/,
+      /types\.generated\.(ts|tsx|js)$/,
+      /\/__generated__\//,
+      /operations\.(ts|tsx|js)$/
+    ],
+    protobuf: [
+      /_pb\.(js|d\.ts)$/,
+      /_pb2\.py$/,
+      /_pb2_grpc\.py$/,
+      /\.pb\.(go|cc|h)$/,
+      /\.pb\.ts$/
+    ],
+    openapi: [
+      /\/api-client\//,
+      /\/swagger-client\//,
+      /\/openapi\/.*\.generated\./,
+      /api\.generated\.(ts|js)$/
+    ],
+    thrift: [
+      /_types\.(js|ts)$/,
+      /\.thrift\.ts$/
+    ],
+    grpc: [
+      /_grpc_pb\.(js|ts)$/,
+      /_grpc\.pb\.go$/
+    ]
+  };
+
+  return typePatterns[type] || [];
+}
+
+/**
+ * Find codegen config files in a project
+ * @param {string} projectPath - Path to project root
+ * @param {Object} codegenConfigs - Config file patterns by type
+ * @returns {Array} - Found config files
+ */
+export function findCodegenConfigs(projectPath, codegenConfigs = {}) {
+  const defaults = {
+    graphql: ['codegen.yml', 'codegen.yaml', 'codegen.ts', 'codegen.js', '.graphqlrc.yml', '.graphqlrc.json'],
+    protobuf: ['buf.yaml', 'buf.gen.yaml', 'buf.work.yaml'],
+    openapi: ['openapi.yaml', 'openapi.yml', 'openapi.json', 'swagger.yaml', 'swagger.json'],
+    grpc: ['grpc-tools.config.js']
+  };
+
+  const configs = { ...defaults, ...codegenConfigs };
+  const found = [];
+
+  for (const [type, files] of Object.entries(configs)) {
+    for (const file of files) {
+      const fullPath = `${projectPath}/${file}`;
+      if (existsSync(fullPath)) {
+        found.push({
+          type,
+          file,
+          path: fullPath
+        });
+      }
+    }
+  }
+
+  return found;
+}
+
+export default {
+  isGeneratedPath,
+  isGeneratedContent,
+  isGeneratedFile,
+  filterGeneratedFiles,
+  getPatternsForCodegenType,
+  findCodegenConfigs,
+  DEFAULT_GENERATED_PATTERNS
+};

package/src/shared/scanner/analysers/imports.mjs

@@ -0,0 +1,60 @@
+// src/scanner/analysers/imports.mjs
+// Import/export graph analysis
+
+/**
+ * Analyse import relationships
+ */
+export async function analyseImports(jsAnalysis, onProgress = () => {}) {
+  const graph = new Map();
+  const usedPackages = new Set();
+  const unusedExports = [];
+  const total = jsAnalysis.length;
+
+  for (let i = 0; i < jsAnalysis.length; i++) {
+    const file = jsAnalysis[i];
+
+    // Report progress every 2 files and yield to event loop
+    if (i % 2 === 0 || i === total - 1) {
+      onProgress({ current: i + 1, total, file: file.file?.relativePath || file.file });
+      await new Promise(resolve => setImmediate(resolve));
+    }
+    const filePath = file.file?.relativePath || file.file;
+
+    // Track imports
+    for (const imp of file.imports || []) {
+      const module = imp.module;
+      if (typeof module !== "string") continue;
+
+      // Track npm packages
+      if (!module.startsWith('.') && !module.startsWith('/')) {
+        const packageName = module.startsWith('@')
+          ? module.split('/').slice(0, 2).join('/')
+          : module.split('/')[0];
+        usedPackages.add(packageName);
+      }
+
+      // Build graph
+      if (!graph.has(filePath)) {
+        graph.set(filePath, { imports: [], exports: [], importedBy: [] });
+      }
+      graph.get(filePath).imports.push(module);
+    }
+
+    // Track exports
+    for (const exp of file.exports || []) {
+      if (!graph.has(filePath)) {
+        graph.set(filePath, { imports: [], exports: [], importedBy: [] });
+      }
+      graph.get(filePath).exports.push(exp);
+    }
+  }
+
+  return {
+    graph,
+    usedPackages,
+    unusedExports,
+    fileCount: graph.size
+  };
+}
+
+export default { analyseImports };

package/src/shared/scanner/discovery.mjs

@@ -0,0 +1,240 @@
+// src/scanner/discovery.mjs
+// File discovery utilities
+
+import { statSync, existsSync, readFileSync } from 'fs';
+import { join, extname, relative } from 'path';
+import { glob } from 'glob';
+
+/**
+ * Parse .gitmodules file to extract submodule paths
+ * @param {string} projectPath - Project root path
+ * @returns {string[]} - Array of submodule paths (as glob patterns)
+ */
+function getGitSubmodulePaths(projectPath) {
+  const gitmodulesPath = join(projectPath, '.gitmodules');
+  if (!existsSync(gitmodulesPath)) return [];
+
+  const submodulePaths = [];
+  try {
+    const content = readFileSync(gitmodulesPath, 'utf-8');
+    // Match: path = vendor/shared-lib
+    const pathMatches = content.matchAll(/^\s*path\s*=\s*(.+)$/gm);
+    for (const match of pathMatches) {
+      const submodulePath = match[1].trim();
+      // Add as glob pattern to exclude entire directory
+      submodulePaths.push(`${submodulePath}/**`);
+    }
+  } catch {
+    // Ignore parse errors
+  }
+  return submodulePaths;
+}
+
+const DEFAULT_EXCLUDE = [
+  '**/node_modules/**',
+  '**/bower_components/**',
+  '**/jspm_packages/**',
+  '**/web_modules/**',
+  '**/.git/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/.swynx-quarantine/**',
+  '**/coverage/**',
+  '**/*.min.js',
+  '**/*.min.css',
+  // Vendored third-party code
+  '**/third_party/**',
+  '**/3rdparty/**',
+  '**/vendor/**',
+  // Exclude log directories and files (can be huge, not code)
+  '**/logs/**',
+  '**/log/**',
+  '**/*.log',
+  // Exclude temp/cache directories
+  '**/tmp/**',
+  '**/temp/**',
+  '**/.cache/**',
+  '**/cache/**',
+  // Exclude Python cache
+  '**/__pycache__/**',
+  '**/*.pyc',
+  '**/*.pyo',
+  // Exclude other common non-JS caches
+  '**/.pytest_cache/**',
+  '**/.mypy_cache/**',
+  // Exclude data files
+  '**/*.sql',
+  '**/*.sqlite',
+  '**/*.sqlite3',
+  '**/*.db',
+  // Exclude large binary/media (analyzed separately via assets)
+  '**/*.mp4',
+  '**/*.mov',
+  '**/*.avi',
+  '**/*.zip',
+  '**/*.tar',
+  '**/*.gz',
+  '**/*.rar',
+  // Test fixture / baseline directories
+  '**/testdata/**',
+  '**/test-data/**',
+  '**/test_data/**',
+  '**/fixtures/**',
+  '**/fixture/**',
+  '**/TestData/**',
+  '**/test-cases/**',
+  '**/test_cases/**',
+  '**/testcases/**',
+  '**/conformance/**',
+  '**/test-fixture/**',
+  '**/tests/baselines/**',
+  '**/test/baselines/**',
+  // Compiler test input directories
+  '**/cases/**/*.ts',
+  '**/test/cases/**',
+  // C# intermediate / compiled output
+  '**/obj/**',
+  '**/bin/Debug/**',
+  '**/bin/Release/**',
+  // C# scaffolding baselines (test-generated output)
+  '**/Scaffolding/Baselines/**',
+  // Rust compiler test inputs (standalone files compiled by test harness, not source code)
+  '**/tests/ui/**', '**/tests/derive_ui/**', '**/tests/compile-fail/**',
+  '**/tests/run-pass/**', '**/tests/run-fail/**', '**/tests/ui-fulldeps/**',
+  '**/tests/pretty/**', '**/tests/mir-opt/**', '**/tests/assembly/**',
+  '**/tests/codegen/**', '**/tests/debuginfo/**', '**/tests/incremental/**',
+  '**/tests/codegen-llvm/**', '**/tests/rustdoc-html/**', '**/tests/crashes/**',
+  '**/tests/assembly-llvm/**', '**/tests/rustdoc-ui/**', '**/tests/rustdoc-js/**',
+  '**/tests/rustdoc-json/**', '**/tests/codegen-units/**', '**/tests/coverage-run-rustdoc/**',
+  // Cypress/E2E system test fixture projects (standalone apps used as test targets)
+  '**/system-tests/projects/**', '**/system-tests/project-fixtures/**',
+  // RustPython test snippet inputs
+  '**/extra_tests/snippets/**',
+  // Python stdlib copies (RustPython, cpython)
+  '**/Lib/encodings/**',
+  // Python vendored third-party code
+  '**/_vendor/**', '**/_distutils/**',
+  // Compiled/bundled static assets (Phoenix/Elixir)
+  '**/static/assets/**',
+  // Generated protobuf/gRPC output directories
+  '**/gen/proto/**',
+  // Snapshots
+  '**/__snapshots__/**',
+  '**/snapshots/**',
+];
+
+/**
+ * Discover all files in project
+ */
+export async function discoverFiles(projectPath, options = {}) {
+  // Get git submodule paths to exclude
+  const submodulePaths = getGitSubmodulePaths(projectPath);
+
+  // Combine default excludes with submodule paths
+  const exclude = [...(options.exclude || DEFAULT_EXCLUDE), ...submodulePaths];
+  const include = options.include || ['**/*'];
+  const onProgress = options.onProgress || (() => {});
+
+  const files = [];
+
+  // Report that we're starting the glob (this allows heartbeat to show activity)
+  onProgress({ current: 0, total: 0, file: 'Scanning directory structure...' });
+
+  for (const pattern of include) {
+    // Use async glob to allow event loop to run (enables heartbeat during large scans)
+    const matches = await glob(pattern, {
+      cwd: projectPath,
+      ignore: exclude,
+      nodir: true,
+      absolute: false
+    });
+
+    const total = matches.length;
+    let processed = 0;
+
+    // Report that glob is complete, now processing files
+    onProgress({ current: 0, total, file: `Found ${total} files, processing...` });
+
+    for (const match of matches) {
+      const fullPath = join(projectPath, match);
+      if (existsSync(fullPath)) {
+        try {
+          const stats = statSync(fullPath);
+          files.push({
+            path: fullPath,
+            relativePath: match,
+            size: stats.size,
+            mtime: stats.mtime.toISOString(),
+            ext: extname(match).toLowerCase()
+          });
+        } catch (e) {
+          // Skip files we can't stat
+        }
+      }
+
+      processed++;
+      // Report progress every 500 files (was every 2 — 50K setImmediate calls for 100K files)
+      if (processed % 500 === 0 || processed === total) {
+        onProgress({ current: processed, total, file: match });
+        // Yield to event loop to allow heartbeat to fire
+        await new Promise(resolve => setImmediate(resolve));
+      }
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Categorize files by type
+ */
+export function categoriseFiles(files) {
+  const categories = {
+    javascript: [],
+    python: [],
+    java: [],
+    kotlin: [],
+    csharp: [],
+    go: [],
+    rust: [],
+    css: [],
+    assets: [],
+    other: []
+  };
+
+  for (const file of files) {
+    const ext = file.ext;
+    if (['.js', '.mjs', '.cjs', '.jsx', '.ts', '.mts', '.cts', '.tsx', '.vue', '.svelte'].includes(ext)) {
+      categories.javascript.push(file);
+    } else if (['.py', '.pyi'].includes(ext)) {
+      categories.python.push(file);
+    } else if (['.java'].includes(ext)) {
+      categories.java.push(file);
+    } else if (['.kt', '.kts'].includes(ext)) {
+      categories.kotlin.push(file);
+    } else if (['.cs'].includes(ext)) {
+      categories.csharp.push(file);
+    } else if (['.go'].includes(ext)) {
+      categories.go.push(file);
+    } else if (['.rs'].includes(ext)) {
+      categories.rust.push(file);
+    } else if (['.css', '.scss', '.sass', '.less'].includes(ext)) {
+      categories.css.push(file);
+    } else if (['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico', '.woff', '.woff2', '.ttf', '.eot'].includes(ext)) {
+      categories.assets.push(file);
+    } else {
+      categories.other.push(file);
+    }
+  }
+
+  return categories;
+}
+
+/**
+ * Get total size of files
+ */
+export function getTotalSize(files) {
+  return files.reduce((sum, f) => sum + (f.size || 0), 0);
+}
+
+export default { discoverFiles, categoriseFiles, getTotalSize };

package/src/shared/scanner/parse-worker.mjs

@@ -0,0 +1,82 @@
+// src/scanner/parse-worker.mjs
+// Worker thread for parallel file parsing
+// Receives a chunk of files and a parser type, returns parsed results
+
+import { parentPort, workerData } from 'worker_threads';
+
+const { files, parserType } = workerData;
+
+const BATCH_SIZE = 200;  // Send results in batches to reduce structured clone overhead
+
+async function run() {
+  let parseFn;
+
+  switch (parserType) {
+    case 'javascript': {
+      const mod = await import('./parsers/javascript.mjs');
+      parseFn = mod.parseJavaScript;
+      break;
+    }
+    case 'css': {
+      const mod = await import('./parsers/css.mjs');
+      parseFn = mod.parseCSS;
+      break;
+    }
+    case 'assets': {
+      const mod = await import('./parsers/assets.mjs');
+      parseFn = mod.analyseAssets;
+      break;
+    }
+    case 'other': {
+      const mod = await import('./parsers/registry.mjs');
+      parseFn = mod.parseFile;
+      break;
+    }
+    default:
+      throw new Error(`Unknown parser type: ${parserType}`);
+  }
+
+  const batch = [];
+
+  for (let i = 0; i < files.length; i++) {
+    try {
+      const result = await parseFn(files[i]);
+      if (result) {
+        // B1: Strip content and function/method bodies before postMessage
+        // Content is only needed for DI/C# analysis in deadcode.mjs — those will re-read from disk
+        result.content = null;
+        if (result.functions) {
+          for (const fn of result.functions) { fn.body = undefined; }
+        }
+        if (result.classes) {
+          for (const cls of result.classes) {
+            cls.body = undefined;
+            if (cls.methods) {
+              for (const m of cls.methods) { m.body = undefined; }
+            }
+          }
+        }
+        batch.push(result);
+      }
+    } catch {
+      // Skip files that fail to parse
+    }
+
+    // Report progress every 100 files
+    if ((i + 1) % 100 === 0 || i === files.length - 1) {
+      parentPort.postMessage({ type: 'progress', done: i + 1, total: files.length });
+    }
+
+    // Send results in batches of BATCH_SIZE to reduce peak structured clone memory
+    if (batch.length >= BATCH_SIZE) {
+      parentPort.postMessage({ type: 'batch', results: batch.splice(0) });
+    }
+  }
+
+  // Send any remaining results and signal completion
+  parentPort.postMessage({ type: 'done', results: batch });
+}
+
+run().catch(err => {
+  parentPort.postMessage({ type: 'error', message: err.message });
+});