swynx-lite 1.0.0

package/src/shared/scanner/parsers/registry.mjs

@@ -0,0 +1,233 @@
+// src/scanner/parsers/registry.mjs
+// Multi-language parser registry with lazy loading
+
+import { extname } from 'path';
+
+/**
+ * Parser result structure (common across all languages)
+ * @typedef {Object} ParseResult
+ * @property {Object} file - File info (path, relativePath)
+ * @property {string} content - File content
+ * @property {Array} functions - Detected functions/methods
+ * @property {Array} classes - Detected classes/types
+ * @property {Array} exports - Detected exports
+ * @property {Array} imports - Detected imports/dependencies
+ * @property {Array} annotations - Detected annotations/decorators
+ * @property {number} lines - Line count
+ * @property {number} size - Byte size
+ * @property {string} parseMethod - Parser used
+ * @property {string} [error] - Error message if parsing failed
+ */
+
+/**
+ * Parser registry with lazy loading
+ * Each parser is loaded on-demand to reduce startup time
+ */
+const parserRegistry = {
+  // JavaScript/TypeScript (primary, always loaded)
+  '.js': () => import('./javascript.mjs'),
+  '.mjs': () => import('./javascript.mjs'),
+  '.cjs': () => import('./javascript.mjs'),
+  '.jsx': () => import('./javascript.mjs'),
+  '.ts': () => import('./javascript.mjs'),
+  '.mts': () => import('./javascript.mjs'),
+  '.cts': () => import('./javascript.mjs'),
+  '.tsx': () => import('./javascript.mjs'),
+  '.vue': () => import('./javascript.mjs'),
+  '.svelte': () => import('./javascript.mjs'),
+
+  // Java/Kotlin (JVM)
+  '.java': () => import('./java.mjs'),
+  '.kt': () => import('./kotlin.mjs'),
+  '.kts': () => import('./kotlin.mjs'),
+
+  // .NET
+  '.cs': () => import('./csharp.mjs'),
+  // '.fs': () => import('./fsharp.mjs'),  // TODO: Not implemented
+  // '.vb': () => import('./vb.mjs'),      // TODO: Not implemented
+
+  // Python
+  '.py': () => import('./python.mjs'),
+  '.pyi': () => import('./python.mjs'),
+
+  // Go
+  '.go': () => import('./go.mjs'),
+
+  // Rust
+  '.rs': () => import('./rust.mjs')
+
+  // TODO: Future language support
+  // '.rb': () => import('./ruby.mjs'),
+  // '.php': () => import('./php.mjs'),
+  // '.swift': () => import('./swift.mjs'),
+  // '.scala': () => import('./scala.mjs'),
+  // '.sc': () => import('./scala.mjs')
+};
+
+// Cache for loaded parsers
+const loadedParsers = new Map();
+
+/**
+ * Get the appropriate parser for a file extension
+ * @param {string} extension - File extension (with dot, e.g., '.java')
+ * @returns {Promise<Object|null>} - Parser module or null if not supported
+ */
+export async function getParser(extension) {
+  const normalizedExt = extension.toLowerCase();
+  const loader = parserRegistry[normalizedExt];
+
+  if (!loader) {
+    return null;
+  }
+
+  // Check cache
+  if (loadedParsers.has(normalizedExt)) {
+    return loadedParsers.get(normalizedExt);
+  }
+
+  // Load parser
+  try {
+    const module = await loader();
+    const parser = module.default || module;
+    loadedParsers.set(normalizedExt, parser);
+    return parser;
+  } catch (error) {
+    // Parser not implemented yet - return null
+    console.warn(`[ParserRegistry] Failed to load parser for ${extension}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Check if a file extension is supported
+ * @param {string} extension - File extension (with dot)
+ * @returns {boolean} - True if supported
+ */
+export function isSupported(extension) {
+  return extension.toLowerCase() in parserRegistry;
+}
+
+/**
+ * Get all supported extensions
+ * @returns {string[]} - Array of supported extensions
+ */
+export function getSupportedExtensions() {
+  return Object.keys(parserRegistry);
+}
+
+/**
+ * Parse a file using the appropriate parser
+ * @param {Object|string} file - File object with path/relativePath or just path string
+ * @param {Object} options - Parser options
+ * @returns {Promise<ParseResult|null>} - Parse result or null if unsupported
+ */
+export async function parseFile(file, options = {}) {
+  const filePath = typeof file === 'string' ? file : (file.path || file.relativePath);
+  const extension = extname(filePath);
+
+  const parser = await getParser(extension);
+  if (!parser) {
+    return null;
+  }
+
+  // Find the parse function
+  const parseFn = parser.parse || parser.parseFile || parser.parseJavaScript || parser.default;
+  if (typeof parseFn !== 'function') {
+    console.warn(`[ParserRegistry] No parse function found for ${extension}`);
+    return null;
+  }
+
+  try {
+    return await parseFn(file, options);
+  } catch (error) {
+    return {
+      file: { path: filePath, relativePath: filePath },
+      content: '',
+      functions: [],
+      classes: [],
+      exports: [],
+      imports: [],
+      annotations: [],
+      lines: 0,
+      size: 0,
+      parseMethod: 'error',
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Parse multiple files in parallel
+ * @param {Array<Object|string>} files - Array of file objects or paths
+ * @param {Object} options - Parser options
+ * @param {number} [options.concurrency=10] - Max concurrent parses
+ * @param {Function} [options.onProgress] - Progress callback
+ * @returns {Promise<ParseResult[]>} - Array of parse results
+ */
+export async function parseFiles(files, options = {}) {
+  const { concurrency = 10, onProgress } = options;
+  const results = [];
+  const total = files.length;
+
+  // Process in batches
+  for (let i = 0; i < files.length; i += concurrency) {
+    const batch = files.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map(file => parseFile(file, options))
+    );
+
+    results.push(...batchResults.filter(r => r !== null));
+
+    if (onProgress) {
+      onProgress({ current: Math.min(i + concurrency, total), total });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get language info for a file extension
+ * @param {string} extension - File extension
+ * @returns {Object} - Language info
+ */
+export function getLanguageInfo(extension) {
+  const ext = extension.toLowerCase();
+  const languageMap = {
+    '.js': { name: 'JavaScript', family: 'js' },
+    '.mjs': { name: 'JavaScript', family: 'js' },
+    '.cjs': { name: 'JavaScript', family: 'js' },
+    '.jsx': { name: 'JSX', family: 'js' },
+    '.ts': { name: 'TypeScript', family: 'js' },
+    '.mts': { name: 'TypeScript', family: 'js' },
+    '.cts': { name: 'TypeScript', family: 'js' },
+    '.tsx': { name: 'TSX', family: 'js' },
+    '.vue': { name: 'Vue', family: 'js' },
+    '.svelte': { name: 'Svelte', family: 'js' },
+    '.java': { name: 'Java', family: 'jvm' },
+    '.kt': { name: 'Kotlin', family: 'jvm' },
+    '.kts': { name: 'Kotlin Script', family: 'jvm' },
+    '.scala': { name: 'Scala', family: 'jvm' },
+    '.cs': { name: 'C#', family: 'dotnet' },
+    '.fs': { name: 'F#', family: 'dotnet' },
+    '.vb': { name: 'Visual Basic', family: 'dotnet' },
+    '.py': { name: 'Python', family: 'python' },
+    '.pyi': { name: 'Python Stub', family: 'python' },
+    '.go': { name: 'Go', family: 'go' },
+    '.rs': { name: 'Rust', family: 'rust' },
+    '.rb': { name: 'Ruby', family: 'ruby' },
+    '.php': { name: 'PHP', family: 'php' },
+    '.swift': { name: 'Swift', family: 'swift' }
+  };
+
+  return languageMap[ext] || { name: 'Unknown', family: 'unknown' };
+}
+
+export default {
+  getParser,
+  isSupported,
+  getSupportedExtensions,
+  parseFile,
+  parseFiles,
+  getLanguageInfo
+};

package/src/shared/scanner/parsers/rust.mjs

@@ -0,0 +1,427 @@
+// src/scanner/parsers/rust.mjs
+// Rust parser with workspace and module support
+
+import { readFileSync, existsSync } from 'fs';
+
+/**
+ * Parse a Rust file and extract functions, structs, traits, impl blocks, imports
+ * @param {Object|string} file - File object or path
+ * @returns {Object} - Parse result
+ */
+export async function parse(file) {
+  const filePath = typeof file === 'string' ? file : file.path;
+  const relativePath = typeof file === 'string' ? file : file.relativePath;
+
+  if (!existsSync(filePath)) {
+    return createEmptyResult(filePath, relativePath, 'File not found');
+  }
+
+  let content;
+  try {
+    content = readFileSync(filePath, 'utf-8');
+  } catch (error) {
+    return createEmptyResult(filePath, relativePath, `Read error: ${error.message}`);
+  }
+
+  try {
+    const lines = content.split('\n');
+    const functions = [];
+    const classes = [];  // Structs, enums, traits
+    const exports = [];
+    const imports = [];
+    const mods = [];  // Module declarations
+
+    // Track attributes for next item
+    let pendingAttributes = [];
+
+    // Extract use statements
+    const usePattern = /^\s*(?:pub\s+)?use\s+([\w:]+(?:::\{[^}]+\}|::\*)?)\s*;/gm;
+    let match;
+    while ((match = usePattern.exec(content)) !== null) {
+      const lineNum = content.substring(0, match.index).split('\n').length;
+      imports.push({
+        module: match[1],
+        type: 'use',
+        line: lineNum
+      });
+    }
+
+    // Extract mod declarations (supports pub, pub(crate), pub(super), pub(in path))
+    // Also handles attributes before mod: #[macro_use] mod foo; #[cfg(...)] mod bar;
+    const modPattern = /^\s*(?:#\[[^\]]*\]\s*)*(?:pub(?:\([^)]+\))?\s+)?mod\s+(\w+)\s*[;{]/gm;
+    while ((match = modPattern.exec(content)) !== null) {
+      const lineNum = content.substring(0, match.index).split('\n').length;
+      mods.push({
+        name: match[1],
+        public: match[0].includes('pub'),
+        line: lineNum
+      });
+    }
+
+    // Extract #[path = "..."] mod declarations — custom file paths for modules
+    // Pattern: #[path = "filename.rs"] mod name; or #[cfg_attr(..., path = "...")] mod name;
+    const pathModPattern = /^\s*#\[(?:cfg_attr\([^,]+,\s*)?path\s*=\s*"([^"]+)"\)?\]\s*(?:#\[[^\]]*\]\s*)*(?:pub(?:\([^)]+\))?\s+)?mod\s+(\w+)\s*[;{]/gm;
+    while ((match = pathModPattern.exec(content)) !== null) {
+      const lineNum = content.substring(0, match.index).split('\n').length;
+      // Store path-remapped mod with the target filename
+      const existing = mods.find(m => m.name === match[2] && m.line === lineNum);
+      if (existing) {
+        existing.pathOverride = match[1]; // e.g., "unix.rs", "windows/mod.rs"
+      } else {
+        mods.push({
+          name: match[2],
+          public: match[0].includes('pub'),
+          line: lineNum,
+          pathOverride: match[1]
+        });
+      }
+    }
+
+    // Parse line by line
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNum = i + 1;
+
+      // Detect attributes (#[...])
+      const attrMatch = line.match(/^\s*#\[([^\]]+)\]/);
+      if (attrMatch) {
+        pendingAttributes.push({
+          name: attrMatch[1],
+          line: lineNum
+        });
+        continue;
+      }
+
+      // Detect function declaration
+      const funcMatch = line.match(/^\s*(pub(?:\([^)]+\))?\s+)?(async\s+)?fn\s+(\w+)(?:<[^>]+>)?\s*\(([^)]*)\)(?:\s*->\s*([\w<>,\s&']+))?/);
+      if (funcMatch) {
+        const funcInfo = {
+          name: funcMatch[3],
+          type: funcMatch[2] ? 'async function' : 'function',
+          visibility: funcMatch[1] ? 'public' : 'private',
+          async: !!funcMatch[2],
+          line: lineNum,
+          endLine: findBlockEnd(lines, i),
+          params: parseParams(funcMatch[4]),
+          returnType: funcMatch[5]?.trim() || null,
+          decorators: [...pendingAttributes],
+          attributes: [...pendingAttributes],
+          signature: `fn ${funcMatch[3]}(${funcMatch[4]})`,
+          exported: !!funcMatch[1]
+        };
+
+        funcInfo.lineCount = funcInfo.endLine - funcInfo.line + 1;
+        funcInfo.sizeBytes = extractCode(content, funcInfo.line, funcInfo.endLine).length;
+
+        // Check for main function
+        if (funcMatch[3] === 'main' && !funcMatch[1]) {
+          funcInfo.isMainFunction = true;
+        }
+
+        functions.push(funcInfo);
+        pendingAttributes = [];
+      }
+
+      // Detect struct declaration
+      const structMatch = line.match(/^\s*(pub(?:\([^)]+\))?\s+)?struct\s+(\w+)(?:<[^>]+>)?/);
+      if (structMatch) {
+        const structInfo = {
+          name: structMatch[2],
+          type: 'struct',
+          visibility: structMatch[1] ? 'public' : 'private',
+          line: lineNum,
+          endLine: findBlockEnd(lines, i),
+          decorators: [...pendingAttributes],
+          attributes: [...pendingAttributes],
+          methods: [],
+          exported: !!structMatch[1]
+        };
+
+        structInfo.lineCount = structInfo.endLine - structInfo.line + 1;
+        structInfo.sizeBytes = extractCode(content, structInfo.line, structInfo.endLine).length;
+
+        classes.push(structInfo);
+        pendingAttributes = [];
+      }
+
+      // Detect enum declaration
+      const enumMatch = line.match(/^\s*(pub(?:\([^)]+\))?\s+)?enum\s+(\w+)(?:<[^>]+>)?/);
+      if (enumMatch) {
+        const enumInfo = {
+          name: enumMatch[2],
+          type: 'enum',
+          visibility: enumMatch[1] ? 'public' : 'private',
+          line: lineNum,
+          endLine: findBlockEnd(lines, i),
+          decorators: [...pendingAttributes],
+          attributes: [...pendingAttributes],
+          exported: !!enumMatch[1]
+        };
+
+        enumInfo.lineCount = enumInfo.endLine - enumInfo.line + 1;
+        enumInfo.sizeBytes = extractCode(content, enumInfo.line, enumInfo.endLine).length;
+
+        classes.push(enumInfo);
+        pendingAttributes = [];
+      }
+
+      // Detect trait declaration
+      const traitMatch = line.match(/^\s*(pub(?:\([^)]+\))?\s+)?trait\s+(\w+)(?:<[^>]+>)?/);
+      if (traitMatch) {
+        const traitInfo = {
+          name: traitMatch[2],
+          type: 'trait',
+          visibility: traitMatch[1] ? 'public' : 'private',
+          line: lineNum,
+          endLine: findBlockEnd(lines, i),
+          decorators: [...pendingAttributes],
+          attributes: [...pendingAttributes],
+          methods: [],
+          exported: !!traitMatch[1]
+        };
+
+        traitInfo.lineCount = traitInfo.endLine - traitInfo.line + 1;
+        traitInfo.sizeBytes = extractCode(content, traitInfo.line, traitInfo.endLine).length;
+
+        classes.push(traitInfo);
+        pendingAttributes = [];
+      }
+
+      // Detect impl block
+      const implMatch = line.match(/^\s*impl(?:<[^>]+>)?\s+(?:(\w+)\s+for\s+)?(\w+)(?:<[^>]+>)?/);
+      if (implMatch && !line.includes('fn ')) {
+        const implInfo = {
+          name: implMatch[2],
+          trait: implMatch[1] || null,
+          type: 'impl',
+          line: lineNum,
+          endLine: findBlockEnd(lines, i),
+          methods: []
+        };
+
+        // Find the struct/enum this impl is for and add methods
+        const target = classes.find(c => c.name === implInfo.name);
+        if (target) {
+          // Parse impl methods would go here
+        }
+
+        pendingAttributes = [];
+      }
+
+      // Clear pending attributes if we hit something else
+      if (line.trim() && !line.trim().startsWith('#[') && !line.trim().startsWith('//')) {
+        if (!funcMatch && !structMatch && !enumMatch && !traitMatch && !implMatch) {
+          pendingAttributes = [];
+        }
+      }
+    }
+
+    // Determine exports (public items)
+    exports.push(
+      ...functions.filter(f => f.exported).map(f => ({
+        name: f.name,
+        type: 'function',
+        line: f.line
+      })),
+      ...classes.filter(c => c.exported).map(c => ({
+        name: c.name,
+        type: c.type,
+        line: c.line
+      }))
+    );
+
+    // Check if this is a main.rs or lib.rs
+    const isMainFile = relativePath.endsWith('main.rs');
+    const isLibFile = relativePath.endsWith('lib.rs');
+    const isModFile = relativePath.endsWith('mod.rs');
+
+    return {
+      file: { path: filePath, relativePath },
+      content,
+      functions,
+      classes,
+      exports,
+      imports,
+      annotations: pendingAttributes,  // Rust uses attributes instead of annotations
+      mods,
+      lines: lines.length,
+      size: content.length,
+      parseMethod: 'rust-regex',
+      metadata: {
+        hasMainFunction: functions.some(f => f.isMainFunction),
+        isMainFile,
+        isLibFile,
+        isModFile,
+        isBinaryCrate: isMainFile && functions.some(f => f.isMainFunction),
+        isLibraryCrate: isLibFile,
+        publicMods: mods.filter(m => m.public).map(m => m.name),
+        privateMods: mods.filter(m => !m.public).map(m => m.name)
+      }
+    };
+
+  } catch (error) {
+    return createEmptyResult(filePath, relativePath, `Parse error: ${error.message}`);
+  }
+}
+
+/**
+ * Parse function parameters
+ */
+function parseParams(paramsStr) {
+  if (!paramsStr || !paramsStr.trim()) return [];
+
+  const params = [];
+  let depth = 0;
+  let current = '';
+
+  for (const char of paramsStr) {
+    if (char === '<' || char === '(' || char === '[') depth++;
+    else if (char === '>' || char === ')' || char === ']') depth--;
+    else if (char === ',' && depth === 0) {
+      if (current.trim()) {
+        params.push(parseParam(current.trim()));
+      }
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+
+  if (current.trim()) {
+    params.push(parseParam(current.trim()));
+  }
+
+  return params;
+}
+
+/**
+ * Parse a single parameter
+ */
+function parseParam(paramStr) {
+  // Handle: name: Type, &self, &mut self, mut name: Type
+  if (paramStr === 'self' || paramStr === '&self' || paramStr === '&mut self') {
+    return { name: 'self', type: 'self', isSelf: true };
+  }
+
+  const match = paramStr.match(/^(mut\s+)?(\w+)\s*:\s*(.+)$/);
+  if (match) {
+    return {
+      name: match[2],
+      type: match[3].trim(),
+      mutable: !!match[1]
+    };
+  }
+  return { name: paramStr, type: null };
+}
+
+/**
+ * Find end of a code block (matching braces)
+ */
+function findBlockEnd(lines, startIndex) {
+  let braceCount = 0;
+  let started = false;
+
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+
+    let inString = false;
+    let stringChar = '';
+
+    for (let j = 0; j < line.length; j++) {
+      const char = line[j];
+      const nextChar = line[j + 1];
+
+      if (!inString && char === '"') {
+        inString = true;
+        stringChar = char;
+        continue;
+      }
+      if (inString && char === stringChar && line[j - 1] !== '\\') {
+        inString = false;
+        continue;
+      }
+      if (inString) continue;
+
+      if (char === '/' && nextChar === '/') break;
+
+      if (char === '{') {
+        braceCount++;
+        started = true;
+      } else if (char === '}') {
+        braceCount--;
+        if (started && braceCount === 0) {
+          return i + 1;
+        }
+      }
+    }
+  }
+
+  return startIndex + 1;
+}
+
+/**
+ * Extract code between line numbers
+ */
+function extractCode(content, startLine, endLine) {
+  const lines = content.split('\n');
+  return lines.slice(startLine - 1, endLine).join('\n');
+}
+
+/**
+ * Create empty result
+ */
+function createEmptyResult(filePath, relativePath, error) {
+  return {
+    file: { path: filePath, relativePath },
+    content: '',
+    functions: [],
+    classes: [],
+    exports: [],
+    imports: [],
+    annotations: [],
+    mods: [],
+    lines: 0,
+    size: 0,
+    error,
+    parseMethod: 'none'
+  };
+}
+
+/**
+ * Check if a Rust file is an entry point
+ */
+export function isEntryPoint(parseResult) {
+  // Binary crate with main function
+  if (parseResult.metadata?.isBinaryCrate) {
+    return { isEntry: true, reason: 'Is binary crate (main.rs with fn main)' };
+  }
+
+  // Library crate entry
+  if (parseResult.metadata?.isLibraryCrate) {
+    return { isEntry: true, reason: 'Is library crate entry (lib.rs)' };
+  }
+
+  // Test files
+  const hasTestAttr = parseResult.functions.some(f =>
+    f.attributes?.some(a => a.name.includes('test'))
+  );
+  if (hasTestAttr) {
+    return { isEntry: true, reason: 'Has #[test] functions' };
+  }
+
+  return { isEntry: false };
+}
+
+/**
+ * Check if module is publicly declared
+ */
+export function isPublicModule(parseResult, modName) {
+  const mod = parseResult.mods?.find(m => m.name === modName);
+  return mod?.public ?? false;
+}
+
+export default {
+  parse,
+  isEntryPoint,
+  isPublicModule
+};