@aiready/core 0.7.13 → 0.8.0

package/dist/index.mjs

@@ -1,3 +1,34 @@
+// src/types/language.ts
+var Language = /* @__PURE__ */ ((Language3) => {
+  Language3["TypeScript"] = "typescript";
+  Language3["JavaScript"] = "javascript";
+  Language3["Python"] = "python";
+  Language3["Java"] = "java";
+  Language3["Go"] = "go";
+  Language3["Rust"] = "rust";
+  Language3["CSharp"] = "csharp";
+  return Language3;
+})(Language || {});
+var LANGUAGE_EXTENSIONS = {
+  ".ts": "typescript" /* TypeScript */,
+  ".tsx": "typescript" /* TypeScript */,
+  ".js": "javascript" /* JavaScript */,
+  ".jsx": "javascript" /* JavaScript */,
+  ".py": "python" /* Python */,
+  ".java": "java" /* Java */,
+  ".go": "go" /* Go */,
+  ".rs": "rust" /* Rust */,
+  ".cs": "csharp" /* CSharp */
+};
+var ParseError = class extends Error {
+  constructor(message, filePath, loc) {
+    super(message);
+    this.filePath = filePath;
+    this.loc = loc;
+    this.name = "ParseError";
+  }
+};
+
 // src/utils/file-scanner.ts
 import { glob } from "glob";
 import { readFile } from "fs/promises";
@@ -51,8 +82,8 @@ var DEFAULT_EXCLUDE = [
 async function scanFiles(options) {
   const {
     rootDir,
-    include = ["**/*.{ts,tsx,js,jsx,py,java}"],
-    // Broad default - tools should filter further
+    include = ["**/*.{ts,tsx,js,jsx,py,java,go,rs,cs}"],
+    // Multi-language support
     exclude
   } = options;
   const ignoreFilePath = join(rootDir || ".", ".aireadyignore");
@@ -522,10 +553,496 @@ function formatToolScore(output) {
   }
   return result;
 }
+
+// src/parsers/typescript-parser.ts
+import { parse as parse2 } from "@typescript-eslint/typescript-estree";
+var TypeScriptParser = class {
+  constructor() {
+    this.language = "typescript" /* TypeScript */;
+    this.extensions = [".ts", ".tsx", ".js", ".jsx"];
+  }
+  parse(code, filePath) {
+    try {
+      const isJavaScript = filePath.match(/\.jsx?$/i);
+      const ast = parse2(code, {
+        loc: true,
+        range: true,
+        jsx: filePath.match(/\.[jt]sx$/i) !== null,
+        filePath,
+        sourceType: "module",
+        ecmaVersion: "latest"
+      });
+      const imports = this.extractImports(ast);
+      const exports = this.extractExports(ast, imports);
+      return {
+        exports,
+        imports,
+        language: isJavaScript ? "javascript" /* JavaScript */ : "typescript" /* TypeScript */,
+        warnings: []
+      };
+    } catch (error) {
+      const err = error;
+      throw new ParseError(
+        `Failed to parse ${filePath}: ${err.message}`,
+        filePath
+      );
+    }
+  }
+  getNamingConventions() {
+    return {
+      // camelCase for variables and functions
+      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
+      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
+      // PascalCase for classes
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      // UPPER_CASE for constants
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      // Common exceptions (React hooks, etc.)
+      exceptions: ["__filename", "__dirname", "__esModule"]
+    };
+  }
+  canHandle(filePath) {
+    return this.extensions.some((ext) => filePath.toLowerCase().endsWith(ext));
+  }
+  extractImports(ast) {
+    const imports = [];
+    for (const node of ast.body) {
+      if (node.type === "ImportDeclaration") {
+        const specifiers = [];
+        let isTypeOnly = false;
+        if (node.importKind === "type") {
+          isTypeOnly = true;
+        }
+        for (const spec of node.specifiers) {
+          if (spec.type === "ImportSpecifier") {
+            const imported = spec.imported;
+            const name = imported.type === "Identifier" ? imported.name : imported.value;
+            specifiers.push(name);
+          } else if (spec.type === "ImportDefaultSpecifier") {
+            specifiers.push("default");
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            specifiers.push("*");
+          }
+        }
+        imports.push({
+          source: node.source.value,
+          specifiers,
+          isTypeOnly,
+          loc: node.loc ? {
+            start: { line: node.loc.start.line, column: node.loc.start.column },
+            end: { line: node.loc.end.line, column: node.loc.end.column }
+          } : void 0
+        });
+      }
+    }
+    return imports;
+  }
+  extractExports(ast, imports) {
+    const exports = [];
+    const importedNames = new Set(
+      imports.flatMap((imp) => imp.specifiers.filter((s) => s !== "*" && s !== "default"))
+    );
+    for (const node of ast.body) {
+      if (node.type === "ExportNamedDeclaration" && node.declaration) {
+        const extracted = this.extractFromDeclaration(node.declaration, importedNames);
+        exports.push(...extracted);
+      } else if (node.type === "ExportDefaultDeclaration") {
+        let name = "default";
+        let type = "default";
+        if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
+          name = node.declaration.id.name;
+          type = "function";
+        } else if (node.declaration.type === "ClassDeclaration" && node.declaration.id) {
+          name = node.declaration.id.name;
+          type = "class";
+        }
+        exports.push({
+          name,
+          type,
+          loc: node.loc ? {
+            start: { line: node.loc.start.line, column: node.loc.start.column },
+            end: { line: node.loc.end.line, column: node.loc.end.column }
+          } : void 0
+        });
+      }
+    }
+    return exports;
+  }
+  extractFromDeclaration(declaration, importedNames) {
+    const exports = [];
+    if (declaration.type === "FunctionDeclaration" && declaration.id) {
+      exports.push({
+        name: declaration.id.name,
+        type: "function",
+        parameters: declaration.params.map(
+          (p) => p.type === "Identifier" ? p.name : "unknown"
+        ),
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: { line: declaration.loc.end.line, column: declaration.loc.end.column }
+        } : void 0
+      });
+    } else if (declaration.type === "ClassDeclaration" && declaration.id) {
+      exports.push({
+        name: declaration.id.name,
+        type: "class",
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: { line: declaration.loc.end.line, column: declaration.loc.end.column }
+        } : void 0
+      });
+    } else if (declaration.type === "VariableDeclaration") {
+      for (const declarator of declaration.declarations) {
+        if (declarator.id.type === "Identifier") {
+          exports.push({
+            name: declarator.id.name,
+            type: "const",
+            loc: declarator.loc ? {
+              start: {
+                line: declarator.loc.start.line,
+                column: declarator.loc.start.column
+              },
+              end: {
+                line: declarator.loc.end.line,
+                column: declarator.loc.end.column
+              }
+            } : void 0
+          });
+        }
+      }
+    } else if (declaration.type === "TSTypeAliasDeclaration") {
+      exports.push({
+        name: declaration.id.name,
+        type: "type",
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: { line: declaration.loc.end.line, column: declaration.loc.end.column }
+        } : void 0
+      });
+    } else if (declaration.type === "TSInterfaceDeclaration") {
+      exports.push({
+        name: declaration.id.name,
+        type: "interface",
+        loc: declaration.loc ? {
+          start: {
+            line: declaration.loc.start.line,
+            column: declaration.loc.start.column
+          },
+          end: { line: declaration.loc.end.line, column: declaration.loc.end.column }
+        } : void 0
+      });
+    }
+    return exports;
+  }
+};
+
+// src/parsers/python-parser.ts
+var PythonParser = class {
+  constructor() {
+    this.language = "python" /* Python */;
+    this.extensions = [".py"];
+    this.parser = null;
+    this.initialized = false;
+  }
+  /**
+   * Initialize the tree-sitter parser
+   * This is async because tree-sitter WASM needs to be loaded
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      this.initialized = true;
+    } catch (error) {
+      throw new Error(`Failed to initialize Python parser: ${error.message}`);
+    }
+  }
+  parse(code, filePath) {
+    try {
+      const imports = this.extractImportsRegex(code, filePath);
+      const exports = this.extractExportsRegex(code, filePath);
+      return {
+        exports,
+        imports,
+        language: "python" /* Python */,
+        warnings: ["Python parsing is currently using regex-based extraction. Tree-sitter support coming soon."]
+      };
+    } catch (error) {
+      throw new ParseError(
+        `Failed to parse Python file ${filePath}: ${error.message}`,
+        filePath
+      );
+    }
+  }
+  getNamingConventions() {
+    return {
+      // snake_case for variables and functions
+      variablePattern: /^[a-z_][a-z0-9_]*$/,
+      functionPattern: /^[a-z_][a-z0-9_]*$/,
+      // PascalCase for classes
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      // UPPER_CASE for constants
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      // Python special methods and common exceptions
+      exceptions: [
+        "__init__",
+        "__str__",
+        "__repr__",
+        "__name__",
+        "__main__",
+        "__file__",
+        "__doc__",
+        "__all__",
+        "__version__",
+        "__author__",
+        "__dict__",
+        "__class__",
+        "__module__",
+        "__bases__"
+      ]
+    };
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".py");
+  }
+  /**
+   * Regex-based import extraction (temporary implementation)
+   */
+  extractImportsRegex(code, filePath) {
+    const imports = [];
+    const lines = code.split("\n");
+    const importRegex = /^\s*import\s+([a-zA-Z0-9_., ]+)/;
+    const fromImportRegex = /^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+(.+)/;
+    lines.forEach((line, idx) => {
+      if (line.trim().startsWith("#")) return;
+      const importMatch = line.match(importRegex);
+      if (importMatch) {
+        const modules = importMatch[1].split(",").map((m) => m.trim().split(" as ")[0]);
+        modules.forEach((module) => {
+          imports.push({
+            source: module,
+            specifiers: [module],
+            loc: {
+              start: { line: idx + 1, column: 0 },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+        });
+        return;
+      }
+      const fromMatch = line.match(fromImportRegex);
+      if (fromMatch) {
+        const module = fromMatch[1];
+        const imports_str = fromMatch[2];
+        if (imports_str.trim() === "*") {
+          imports.push({
+            source: module,
+            specifiers: ["*"],
+            loc: {
+              start: { line: idx + 1, column: 0 },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+          return;
+        }
+        const specifiers = imports_str.split(",").map((s) => s.trim().split(" as ")[0]);
+        imports.push({
+          source: module,
+          specifiers,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return imports;
+  }
+  /**
+   * Regex-based export extraction (temporary implementation)
+   * 
+   * Python doesn't have explicit exports like JavaScript.
+   * We extract:
+   * - Functions defined at module level (def)
+   * - Classes defined at module level (class)
+   * - Variables in __all__ list
+   */
+  extractExportsRegex(code, filePath) {
+    const exports = [];
+    const lines = code.split("\n");
+    const functionRegex = /^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/;
+    const classRegex = /^class\s+([a-zA-Z_][a-zA-Z0-9_]*)/;
+    const allRegex = /__all__\s*=\s*\[([^\]]+)\]/;
+    let inClass = false;
+    let classIndent = 0;
+    lines.forEach((line, idx) => {
+      const indent = line.search(/\S/);
+      if (line.match(classRegex)) {
+        inClass = true;
+        classIndent = indent;
+      } else if (inClass && indent <= classIndent && line.trim()) {
+        inClass = false;
+      }
+      if (inClass) {
+        const classMatch = line.match(classRegex);
+        if (classMatch) {
+          exports.push({
+            name: classMatch[1],
+            type: "class",
+            loc: {
+              start: { line: idx + 1, column: indent },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+        }
+        return;
+      }
+      const funcMatch = line.match(functionRegex);
+      if (funcMatch && indent === 0) {
+        const name = funcMatch[1];
+        if (!name.startsWith("_") || name.startsWith("__")) {
+          exports.push({
+            name,
+            type: "function",
+            loc: {
+              start: { line: idx + 1, column: 0 },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+        }
+      }
+      const allMatch = line.match(allRegex);
+      if (allMatch) {
+        const names = allMatch[1].split(",").map((n) => n.trim().replace(/['"]/g, ""));
+        names.forEach((name) => {
+          if (name && !exports.find((e) => e.name === name)) {
+            exports.push({
+              name,
+              type: "variable",
+              loc: {
+                start: { line: idx + 1, column: 0 },
+                end: { line: idx + 1, column: line.length }
+              }
+            });
+          }
+        });
+      }
+    });
+    return exports;
+  }
+};
+
+// src/parsers/parser-factory.ts
+var ParserFactory = class _ParserFactory {
+  constructor() {
+    this.parsers = /* @__PURE__ */ new Map();
+    this.extensionMap = new Map(
+      Object.entries(LANGUAGE_EXTENSIONS).map(([ext, lang]) => [ext, lang])
+    );
+    this.registerParser(new TypeScriptParser());
+    this.registerParser(new PythonParser());
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance() {
+    if (!_ParserFactory.instance) {
+      _ParserFactory.instance = new _ParserFactory();
+    }
+    return _ParserFactory.instance;
+  }
+  /**
+   * Register a language parser
+   */
+  registerParser(parser) {
+    this.parsers.set(parser.language, parser);
+    parser.extensions.forEach((ext) => {
+      this.extensionMap.set(ext, parser.language);
+    });
+  }
+  /**
+   * Get parser for a specific language
+   */
+  getParserForLanguage(language) {
+    return this.parsers.get(language) || null;
+  }
+  /**
+   * Get parser for a file based on its extension
+   */
+  getParserForFile(filePath) {
+    const ext = this.getFileExtension(filePath);
+    const language = this.extensionMap.get(ext);
+    if (!language) {
+      return null;
+    }
+    return this.parsers.get(language) || null;
+  }
+  /**
+   * Check if a file is supported
+   */
+  isSupported(filePath) {
+    return this.getParserForFile(filePath) !== null;
+  }
+  /**
+   * Get all registered languages
+   */
+  getSupportedLanguages() {
+    return Array.from(this.parsers.keys());
+  }
+  /**
+   * Get all supported file extensions
+   */
+  getSupportedExtensions() {
+    return Array.from(this.extensionMap.keys());
+  }
+  /**
+   * Get language for a file
+   */
+  getLanguageForFile(filePath) {
+    const ext = this.getFileExtension(filePath);
+    return this.extensionMap.get(ext) || null;
+  }
+  /**
+   * Extract file extension (with dot)
+   */
+  getFileExtension(filePath) {
+    const match = filePath.match(/\.[^.]+$/);
+    return match ? match[0].toLowerCase() : "";
+  }
+  /**
+   * Reset factory (useful for testing)
+   */
+  static reset() {
+    _ParserFactory.instance = new _ParserFactory();
+  }
+};
+function getParser(filePath) {
+  return ParserFactory.getInstance().getParserForFile(filePath);
+}
+function isFileSupported(filePath) {
+  return ParserFactory.getInstance().isSupported(filePath);
+}
+function getSupportedLanguages() {
+  return ParserFactory.getInstance().getSupportedLanguages();
+}
 export {
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
+  LANGUAGE_EXTENSIONS,
+  Language,
+  ParseError,
+  ParserFactory,
+  PythonParser,
   TOOL_NAME_MAP,
+  TypeScriptParser,
   calculateImportSimilarity,
   calculateOverallScore,
   estimateTokens,
@@ -535,11 +1052,14 @@ export {
   formatToolScore,
   getElapsedTime,
   getFileExtension,
+  getParser,
   getRating,
   getRatingDisplay,
+  getSupportedLanguages,
   getToolWeight,
   handleCLIError,
   handleJSONOutput,
+  isFileSupported,
   isSourceFile,
   loadConfig,
   loadMergedConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.7.13",
+  "version": "0.8.0",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",