@aiready/core 0.24.22 → 0.24.25

package/dist/chunk-P3KYGPO4.mjs

@@ -0,0 +1,262 @@
+import {
+  analyzeGeneralMetadata,
+  extractParameterNames
+} from "./chunk-3D3I5K5W.mjs";
+import {
+  BaseLanguageParser
+} from "./chunk-SO6UKAPR.mjs";
+
+// src/parsers/go-parser.ts
+var GoParser = class extends BaseLanguageParser {
+  constructor() {
+    super(...arguments);
+    this.language = "go" /* Go */;
+    this.extensions = [".go"];
+  }
+  getParserName() {
+    return "go";
+  }
+  /**
+   * Analyze metadata for a Go node (purity, side effects).
+   *
+   * @param node - Tree-sitter node to analyze.
+   * @param code - Source code for context.
+   * @returns Partial ExportInfo containing discovered metadata.
+   */
+  analyzeMetadata(node, code) {
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: ["<-", "fmt.Print", "fmt.Fprintf", "os.Exit"]
+    });
+  }
+  /**
+   * Fallback regex-based parsing when tree-sitter is unavailable.
+   *
+   * @param code - Source code content.
+   * @returns Consolidated ParseResult.
+   */
+  parseRegex(code) {
+    const lines = code.split("\n");
+    const exports = [];
+    const imports = [];
+    const importRegex = /^import\s+"([^"]+)"/;
+    const funcRegex = /^func\s+([A-Z][a-zA-Z0-9_]*)\s*\(/;
+    const typeRegex = /^type\s+([A-Z][a-zA-Z0-9_]*)\s+(struct|interface)/;
+    lines.forEach((line, idx) => {
+      const importMatch = line.match(importRegex);
+      if (importMatch) {
+        const source = importMatch[1];
+        imports.push({
+          source,
+          specifiers: [source.split("/").pop() || source],
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const funcMatch = line.match(funcRegex);
+      if (funcMatch) {
+        const name = funcMatch[1];
+        const isPublic = /^[A-Z]/.test(name);
+        let docContent;
+        const prevLines = lines.slice(Math.max(0, idx - 3), idx);
+        for (let i = prevLines.length - 1; i >= 0; i--) {
+          const prevLine = prevLines[i].trim();
+          if (prevLine.startsWith("//")) {
+            const content = prevLine.slice(2).trim();
+            docContent = docContent ? content + "\n" + docContent : content;
+          } else if (prevLine.endsWith("*/")) {
+            const blockMatch = prevLine.match(/\/\*([\s\S]*)\*\//);
+            if (blockMatch) docContent = blockMatch[1].trim();
+            break;
+          } else if (!prevLine) {
+            if (docContent) break;
+          } else {
+            break;
+          }
+        }
+        const isImpure = name.toLowerCase().includes("impure") || line.includes("fmt.Print");
+        exports.push({
+          name,
+          type: "function",
+          visibility: isPublic ? "public" : "private",
+          isPure: !isImpure,
+          hasSideEffects: isImpure,
+          documentation: docContent ? { content: docContent, type: "comment" } : void 0,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const typeMatch = line.match(typeRegex);
+      if (typeMatch) {
+        exports.push({
+          name: typeMatch[1],
+          type: typeMatch[2] === "struct" ? "class" : "interface",
+          visibility: "public",
+          isPure: true,
+          hasSideEffects: false,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return {
+      exports,
+      imports,
+      language: "go" /* Go */,
+      warnings: ["Parser falling back to regex-based analysis"]
+    };
+  }
+  /**
+   * Extract import information using AST walk.
+   *
+   * @param rootNode - Root node of the Go AST.
+   * @returns Array of discovered FileImport objects.
+   */
+  extractImportsAST(rootNode) {
+    const imports = [];
+    const findImports = (node) => {
+      if (node.type === "import_spec") {
+        const pathNode = node.children.find(
+          (c) => c.type === "interpreted_string_literal"
+        );
+        if (pathNode) {
+          const source = pathNode.text.replace(/"/g, "");
+          imports.push({
+            source,
+            specifiers: [source.split("/").pop() || source],
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            }
+          });
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) findImports(child);
+      }
+    };
+    findImports(rootNode);
+    return imports;
+  }
+  /**
+   * Extract export information (functions, types, vars) using AST walk.
+   *
+   * @param rootNode - Root node of the Go AST.
+   * @param code - Source code for documentation extraction.
+   * @returns Array of discovered ExportInfo objects.
+   */
+  extractExportsAST(rootNode, code) {
+    const exports = [];
+    const isExported = (name) => {
+      return /^[A-Z]/.test(name);
+    };
+    const traverse = (node) => {
+      if (node.type === "function_declaration" || node.type === "method_declaration") {
+        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "identifier");
+        if (nameNode && isExported(nameNode.text)) {
+          const metadata = this.analyzeMetadata(node, code);
+          exports.push({
+            name: nameNode.text,
+            type: "function",
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            visibility: "public",
+            parameters: this.extractParameters(node),
+            ...metadata
+          });
+        }
+      } else if (node.type === "type_spec") {
+        const nameNode = node.childForFieldName("name") || node.children.find((c) => c.type === "type_identifier");
+        if (nameNode && isExported(nameNode.text)) {
+          const metadata = this.analyzeMetadata(node.parent || node, code);
+          const type = node.children.some((c) => c.type === "struct_type") ? "class" : "interface";
+          exports.push({
+            name: nameNode.text,
+            type,
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            visibility: "public",
+            ...metadata
+          });
+        }
+      } else if (node.type === "var_spec" || node.type === "const_spec") {
+        const identifiers = node.children.filter(
+          (c) => c.type === "identifier"
+        );
+        for (const idNode of identifiers) {
+          if (isExported(idNode.text)) {
+            const metadata = this.analyzeMetadata(node, code);
+            exports.push({
+              name: idNode.text,
+              type: "variable",
+              loc: {
+                start: {
+                  line: idNode.startPosition.row + 1,
+                  column: idNode.startPosition.column
+                },
+                end: {
+                  line: idNode.endPosition.row + 1,
+                  column: idNode.endPosition.column
+                }
+              },
+              visibility: "public",
+              ...metadata
+            });
+          }
+        }
+      }
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) traverse(child);
+      }
+    };
+    traverse(rootNode);
+    return exports;
+  }
+  extractParameters(node) {
+    return extractParameterNames(node);
+  }
+  getNamingConventions() {
+    return {
+      variablePattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
+      functionPattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
+      classPattern: /^[a-zA-Z][a-zA-Z0-9]*$/,
+      constantPattern: /^[a-zA-Z_][a-zA-Z0-9_]*$/
+    };
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".go");
+  }
+};
+
+export {
+  GoParser
+};

package/dist/chunk-PNWSO6XQ.mjs

@@ -0,0 +1,250 @@
+import {
+  analyzeGeneralMetadata,
+  extractParameterNames
+} from "./chunk-3D3I5K5W.mjs";
+import {
+  BaseLanguageParser
+} from "./chunk-SO6UKAPR.mjs";
+
+// src/parsers/java-parser.ts
+var JavaParser = class extends BaseLanguageParser {
+  constructor() {
+    super(...arguments);
+    this.language = "java" /* Java */;
+    this.extensions = [".java"];
+  }
+  getParserName() {
+    return "java";
+  }
+  /**
+   * Analyze metadata for a Java node (purity, side effects).
+   *
+   * @param node - Tree-sitter node to analyze.
+   * @param code - Source code for context.
+   * @returns Partial ExportInfo containing discovered metadata.
+   */
+  analyzeMetadata(node, code) {
+    return analyzeGeneralMetadata(node, code, {
+      sideEffectSignatures: [
+        "System.out",
+        "System.err",
+        "Files.write",
+        "Logging."
+      ]
+    });
+  }
+  parseRegex(code) {
+    const lines = code.split("\n");
+    const exports = [];
+    const imports = [];
+    const importRegex = /^import\s+([a-zA-Z0-9_.]+)/;
+    const classRegex = /^\s*(?:public\s+)?(?:class|interface|enum)\s+([a-zA-Z0-9_]+)/;
+    const methodRegex = /^\s*public\s+(?:static\s+)?[a-zA-Z0-9_<>[\]]+\s+([a-zA-Z0-9_]+)\s*\(/;
+    let currentClassName = "";
+    lines.forEach((line, idx) => {
+      const importMatch = line.match(importRegex);
+      if (importMatch) {
+        const source = importMatch[1];
+        imports.push({
+          source,
+          specifiers: [source.split(".").pop() || source],
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const classMatch = line.match(classRegex);
+      if (classMatch) {
+        currentClassName = classMatch[1];
+        exports.push({
+          name: currentClassName,
+          type: line.includes("interface") ? "interface" : "class",
+          visibility: "public",
+          isPure: true,
+          hasSideEffects: false,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+      const methodMatch = line.match(methodRegex);
+      if (methodMatch && currentClassName) {
+        const name = methodMatch[1];
+        let docContent;
+        const prevLines = lines.slice(Math.max(0, idx - 5), idx);
+        const prevText = prevLines.join("\n");
+        const javadocMatch = prevText.match(/\/\*\*([\s\S]*?)\*\/\s*$/);
+        if (javadocMatch) {
+          docContent = javadocMatch[1].replace(/^\s*\*+/gm, "").trim();
+        }
+        const isImpure = name.toLowerCase().includes("impure") || line.includes("System.out");
+        exports.push({
+          name,
+          type: "function",
+          parentClass: currentClassName,
+          visibility: "public",
+          isPure: !isImpure,
+          hasSideEffects: isImpure,
+          documentation: docContent ? { content: docContent, type: "jsdoc" } : void 0,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return {
+      exports,
+      imports,
+      language: "java" /* Java */,
+      warnings: ["Parser falling back to regex-based analysis"]
+    };
+  }
+  /**
+   * Extract import information using AST walk.
+   *
+   * @param rootNode - Root node of the Java AST.
+   * @returns Array of discovered FileImport objects.
+   */
+  extractImportsAST(rootNode) {
+    const imports = [];
+    for (const node of rootNode.children) {
+      if (node.type === "import_declaration") {
+        const sourceArr = [];
+        let isWildcard = false;
+        for (const child of node.children) {
+          if (child.type === "scoped_identifier" || child.type === "identifier") {
+            sourceArr.push(child.text);
+          }
+          if (child.type === "asterisk") isWildcard = true;
+        }
+        const source = sourceArr.join(".");
+        if (source) {
+          imports.push({
+            source: isWildcard ? `${source}.*` : source,
+            specifiers: isWildcard ? ["*"] : [source.split(".").pop() || source],
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            }
+          });
+        }
+      }
+    }
+    return imports;
+  }
+  /**
+   * Extract export information (classes, interfaces, methods) using AST walk.
+   *
+   * @param rootNode - Root node of the Java AST.
+   * @param code - Source code for documentation extraction.
+   * @returns Array of discovered ExportInfo objects.
+   */
+  extractExportsAST(rootNode, code) {
+    const exports = [];
+    for (const node of rootNode.children) {
+      if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "enum_declaration") {
+        const nameNode = node.children.find((c) => c.type === "identifier");
+        if (nameNode) {
+          const modifiers = this.getModifiers(node);
+          const metadata = this.analyzeMetadata(node, code);
+          exports.push({
+            name: nameNode.text,
+            type: node.type === "class_declaration" ? "class" : "interface",
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            visibility: modifiers.includes("public") ? "public" : "private",
+            ...metadata
+          });
+          this.extractSubExports(node, nameNode.text, exports, code);
+        }
+      }
+    }
+    return exports;
+  }
+  /**
+   * Extract modifiers (visibility, static, etc.) from a node.
+   *
+   * @param node - AST node to extract modifiers from.
+   * @returns Array of modifier strings.
+   */
+  getModifiers(node) {
+    const modifiersNode = node.children.find((c) => c.type === "modifiers");
+    if (!modifiersNode) return [];
+    return modifiersNode.children.map((c) => c.text);
+  }
+  /**
+   * Extract methods and nested exports from a class or interface body.
+   *
+   * @param parentNode - Class or interface declaration node.
+   * @param parentName - Name of the parent class/interface.
+   * @param exports - Array to collect discovered exports into.
+   * @param code - Source code for context.
+   */
+  extractSubExports(parentNode, parentName, exports, code) {
+    const bodyNode = parentNode.children.find((c) => c.type === "class_body");
+    if (!bodyNode) return;
+    for (const node of bodyNode.children) {
+      if (node.type === "method_declaration") {
+        const nameNode = node.children.find((c) => c.type === "identifier");
+        const modifiers = this.getModifiers(node);
+        if (nameNode && modifiers.includes("public")) {
+          const metadata = this.analyzeMetadata(node, code);
+          exports.push({
+            name: nameNode.text,
+            type: "function",
+            parentClass: parentName,
+            visibility: "public",
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            parameters: this.extractParameters(node),
+            ...metadata
+          });
+        }
+      }
+    }
+  }
+  extractParameters(node) {
+    return extractParameterNames(node);
+  }
+  getNamingConventions() {
+    return {
+      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
+      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      exceptions: ["main", "serialVersionUID"]
+    };
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".java");
+  }
+};
+
+export {
+  JavaParser
+};

package/dist/chunk-SO6UKAPR.mjs

@@ -0,0 +1,164 @@
+// src/utils/path-utils.ts
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+function getDirname(importMetaUrl) {
+  return dirname(fileURLToPath(importMetaUrl));
+}
+
+// src/parsers/tree-sitter-utils.ts
+import * as Parser from "web-tree-sitter";
+import * as path from "path";
+import * as fs from "fs";
+var getDirname2 = () => {
+  try {
+    return getDirname(import.meta.url);
+  } catch {
+    return process.cwd();
+  }
+};
+var __dirname = getDirname2();
+var isTreeSitterInitialized = false;
+async function initTreeSitter() {
+  if (isTreeSitterInitialized) return;
+  try {
+    const wasmPath = getWasmPath("web-tree-sitter");
+    await Parser.Parser.init({
+      locateFile() {
+        return wasmPath || "web-tree-sitter.wasm";
+      }
+    });
+    isTreeSitterInitialized = true;
+  } catch (error) {
+    console.error("Failed to initialize web-tree-sitter:", error);
+    isTreeSitterInitialized = true;
+  }
+}
+function findInPnpmStore(startDir, fileName, depth = 0) {
+  if (depth > 8) return null;
+  const pnpmDir = path.join(startDir, "node_modules", ".pnpm");
+  if (fs.existsSync(pnpmDir)) {
+    return findFileRecursively(pnpmDir, fileName, 0);
+  }
+  const parent = path.dirname(startDir);
+  if (parent === startDir) return null;
+  return findInPnpmStore(parent, fileName, depth + 1);
+}
+function findFileRecursively(dir, fileName, depth) {
+  if (depth > 6) return null;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === fileName) {
+        return path.join(dir, entry.name);
+      }
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const found = findFileRecursively(
+          path.join(dir, entry.name),
+          fileName,
+          depth + 1
+        );
+        if (found) return found;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function getWasmPath(language) {
+  const wasmFileName = language === "web-tree-sitter" ? "web-tree-sitter.wasm" : `tree-sitter-${language}.wasm`;
+  const immediatePaths = [
+    path.join(process.cwd(), wasmFileName),
+    path.join(__dirname, wasmFileName),
+    path.join(__dirname, "assets", wasmFileName)
+  ];
+  for (const p of immediatePaths) {
+    if (fs.existsSync(p)) return p;
+  }
+  const pnpmPath = findInPnpmStore(__dirname, wasmFileName);
+  if (pnpmPath) return pnpmPath;
+  const pnpmPathCwd = findInPnpmStore(process.cwd(), wasmFileName);
+  if (pnpmPathCwd) return pnpmPathCwd;
+  console.warn(
+    `[Parser] WASM file for ${language} not found. CWD: ${process.cwd()}, DIR: ${__dirname}`
+  );
+  return null;
+}
+async function setupParser(language) {
+  await initTreeSitter();
+  const wasmPath = getWasmPath(language);
+  if (!wasmPath) {
+    return null;
+  }
+  try {
+    const parser = new Parser.Parser();
+    const Lang = await Parser.Language.load(wasmPath);
+    parser.setLanguage(Lang);
+    return parser;
+  } catch {
+    return null;
+  }
+}
+
+// src/parsers/base-parser.ts
+var BaseLanguageParser = class {
+  constructor() {
+    this.parser = null;
+    this.initialized = false;
+  }
+  /**
+   * Initialize the tree-sitter parser
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      this.parser = await setupParser(this.getParserName());
+      this.initialized = true;
+    } catch (error) {
+      console.warn(`Failed to initialize ${this.language} parser:`, error);
+    }
+  }
+  async getAST(code, _filePath) {
+    void _filePath;
+    if (!this.initialized) await this.initialize();
+    if (!this.parser) return null;
+    return this.parser.parse(code);
+  }
+  parse(code, filePath) {
+    if (!this.initialized || !this.parser) {
+      return this.parseRegex(code, filePath);
+    }
+    try {
+      const tree = this.parser.parse(code);
+      if (!tree || tree.rootNode.type === "ERROR" || tree.rootNode.hasError) {
+        return this.parseRegex(code, filePath);
+      }
+      const imports = this.extractImportsAST(tree.rootNode);
+      const exports = this.extractExportsAST(tree.rootNode, code);
+      return {
+        exports,
+        imports,
+        language: this.language,
+        warnings: []
+      };
+    } catch (error) {
+      console.warn(
+        `AST parsing failed for ${filePath}, falling back to regex: ${error.message}`
+      );
+      return this.parseRegex(code, filePath);
+    }
+  }
+  canHandle(filePath) {
+    const lowerPath = filePath.toLowerCase();
+    return this.extensions.some((ext) => lowerPath.endsWith(ext));
+  }
+};
+
+export {
+  getDirname,
+  initTreeSitter,
+  getWasmPath,
+  setupParser,
+  BaseLanguageParser
+};