@aiready/core 0.24.22 → 0.24.25

package/dist/chunk-3S5WU6KX.mjs

@@ -0,0 +1,552 @@
+import {
+  BaseLanguageParser
+} from "./chunk-SO6UKAPR.mjs";
+
+// src/parsers/metadata-utils.ts
+function analyzeNodeMetadata(node, code, options) {
+  const metadata = {
+    isPure: true,
+    hasSideEffects: false
+  };
+  try {
+    let prev = node.previousSibling;
+    while (prev && /comment/i.test(prev.type)) {
+      const text = prev.text || "";
+      const loc = {
+        start: {
+          line: prev.startPosition.row + 1,
+          column: prev.startPosition.column
+        },
+        end: {
+          line: prev.endPosition.row + 1,
+          column: prev.endPosition.column
+        }
+      };
+      if (text.trim().startsWith("/**") || text.trim().startsWith("/*")) {
+        metadata.documentation = {
+          content: text.replace(/^[/*]+|[/*]+$/g, "").trim(),
+          type: "comment",
+          loc
+        };
+        break;
+      }
+      if (text.trim().startsWith("///")) {
+        metadata.documentation = {
+          content: text.replace(/^\/\/\//, "").trim(),
+          type: "xml-doc",
+          loc
+        };
+        break;
+      }
+      if (text.trim().startsWith("//")) {
+        metadata.documentation = {
+          content: text.replace(/^\/\//, "").trim(),
+          type: "comment",
+          loc
+        };
+        break;
+      }
+      prev = prev.previousSibling;
+    }
+    if (node.type === "function_definition" || node.type === "class_definition") {
+      const body2 = node.childForFieldName("body") || node.children.find((c) => c.type === "block");
+      if (body2 && body2.children.length > 0) {
+        const firstStmt = body2.children[0];
+        if (firstStmt.type === "expression_statement" && firstStmt.firstChild?.type === "string") {
+          metadata.documentation = {
+            content: firstStmt.firstChild.text.replace(/['"`]/g, "").trim(),
+            type: "docstring",
+            loc: {
+              start: {
+                line: firstStmt.startPosition.row + 1,
+                column: firstStmt.startPosition.column
+              },
+              end: {
+                line: firstStmt.endPosition.row + 1,
+                column: firstStmt.endPosition.column
+              }
+            }
+          };
+        }
+      }
+    }
+  } catch {
+  }
+  const defaultSignatures = [
+    "console.",
+    "fmt.",
+    "panic(",
+    "os.Exit",
+    "log.",
+    "Console.Write",
+    "File.Write",
+    "System.out",
+    "System.err",
+    "Files.write",
+    "process.exit",
+    "exit("
+  ];
+  const signatures = Array.from(
+    /* @__PURE__ */ new Set([...options?.sideEffectSignatures || [], ...defaultSignatures])
+  );
+  const walk = (n) => {
+    try {
+      const t = n.type || "";
+      if (/assign|assignment|assignment_statement|assignment_expression|throw|throw_statement|send_statement|global_statement|nonlocal_statement/i.test(
+        t
+      )) {
+        metadata.isPure = false;
+        metadata.hasSideEffects = true;
+      }
+      const text = n.text || "";
+      for (const s of signatures) {
+        if (text.includes(s)) {
+          metadata.isPure = false;
+          metadata.hasSideEffects = true;
+          break;
+        }
+      }
+      for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (c) walk(c);
+      }
+    } catch {
+    }
+  };
+  const body = node.childForFieldName("body") || node.children.find(
+    (c) => /body|block|class_body|declaration_list|function_body/.test(c.type)
+  );
+  if (body) walk(body);
+  return metadata;
+}
+
+// src/parsers/python-parser.ts
+var PYTHON_CONSTANTS = {
+  NODES: {
+    IMPORT_STATEMENT: "import_statement",
+    IMPORT_FROM_STATEMENT: "import_from_statement",
+    DOTTED_NAME: "dotted_name",
+    ALIASED_IMPORT: "aliased_import",
+    WILDCARD_IMPORT: "wildcard_import",
+    FUNCTION_DEFINITION: "function_definition",
+    CLASS_DEFINITION: "class_definition",
+    EXPRESSION_STATEMENT: "expression_statement",
+    ASSIGNMENT: "assignment",
+    IDENTIFIER: "identifier",
+    TYPED_PARAMETER: "typed_parameter",
+    DEFAULT_PARAMETER: "default_parameter"
+  },
+  FIELDS: {
+    NAME: "name",
+    MODULE_NAME: "module_name",
+    LEFT: "left",
+    PARAMETERS: "parameters"
+  },
+  SPECIAL: {
+    WILDCARD: "*",
+    DUNDER_ALL: "__all__",
+    DUNDER_VERSION: "__version__",
+    DUNDER_AUTHOR: "__author__",
+    DUNDER_INIT: "__init__",
+    DUNDER_STR: "__str__",
+    DUNDER_REPR: "__repr__",
+    DUNDER_NAME: "__name__",
+    DUNDER_MAIN: "__main__",
+    DUNDER_FILE: "__file__",
+    DUNDER_DOC: "__doc__",
+    DUNDER_DICT: "__dict__",
+    DUNDER_CLASS: "__class__",
+    DUNDER_MODULE: "__module__",
+    DUNDER_BASES: "__bases__",
+    MAIN_VAL: "__main__"
+  },
+  BUILTINS: {
+    PRINT: "print(",
+    INPUT: "input(",
+    OPEN: "open("
+  },
+  TYPES: {
+    FUNCTION: "function",
+    CLASS: "class",
+    VARIABLE: "variable",
+    CONST: "const",
+    DOCSTRING: "docstring"
+  }
+};
+var PythonParser = class extends BaseLanguageParser {
+  constructor() {
+    super(...arguments);
+    this.language = "python" /* Python */;
+    this.extensions = [".py"];
+  }
+  /**
+   * Returns the canonical name of this parser.
+   */
+  getParserName() {
+    return "python";
+  }
+  /**
+   * Analyze metadata for a Python node (purity, side effects).
+   */
+  analyzeMetadata(node, code) {
+    return analyzeNodeMetadata(node, code, {
+      sideEffectSignatures: [
+        PYTHON_CONSTANTS.BUILTINS.PRINT,
+        PYTHON_CONSTANTS.BUILTINS.INPUT,
+        PYTHON_CONSTANTS.BUILTINS.OPEN
+      ]
+    });
+  }
+  /**
+   * Extract import information using AST walk.
+   */
+  extractImportsAST(rootNode) {
+    const imports = [];
+    const processImportNode = (node) => {
+      if (node.type === PYTHON_CONSTANTS.NODES.IMPORT_STATEMENT) {
+        for (const child of node.children) {
+          if (child.type === PYTHON_CONSTANTS.NODES.DOTTED_NAME) {
+            const source = child.text;
+            imports.push({
+              source,
+              specifiers: [source],
+              loc: {
+                start: {
+                  line: child.startPosition.row + 1,
+                  column: child.startPosition.column
+                },
+                end: {
+                  line: child.endPosition.row + 1,
+                  column: child.endPosition.column
+                }
+              }
+            });
+          } else if (child.type === PYTHON_CONSTANTS.NODES.ALIASED_IMPORT) {
+            const nameNode = child.childForFieldName(
+              PYTHON_CONSTANTS.FIELDS.NAME
+            );
+            if (nameNode) {
+              const source = nameNode.text;
+              imports.push({
+                source,
+                specifiers: [source],
+                loc: {
+                  start: {
+                    line: child.startPosition.row + 1,
+                    column: child.startPosition.column
+                  },
+                  end: {
+                    line: child.endPosition.row + 1,
+                    column: child.endPosition.column
+                  }
+                }
+              });
+            }
+          }
+        }
+      } else if (node.type === PYTHON_CONSTANTS.NODES.IMPORT_FROM_STATEMENT) {
+        const moduleNameNode = node.childForFieldName(
+          PYTHON_CONSTANTS.FIELDS.MODULE_NAME
+        );
+        if (moduleNameNode) {
+          const source = moduleNameNode.text;
+          const specifiers = [];
+          for (const child of node.children) {
+            if (child.type === PYTHON_CONSTANTS.NODES.DOTTED_NAME && child !== moduleNameNode) {
+              specifiers.push(child.text);
+            } else if (child.type === PYTHON_CONSTANTS.NODES.ALIASED_IMPORT) {
+              const nameNode = child.childForFieldName(
+                PYTHON_CONSTANTS.FIELDS.NAME
+              );
+              if (nameNode) specifiers.push(nameNode.text);
+            } else if (child.type === PYTHON_CONSTANTS.NODES.WILDCARD_IMPORT) {
+              specifiers.push(PYTHON_CONSTANTS.SPECIAL.WILDCARD);
+            }
+          }
+          if (specifiers.length > 0) {
+            imports.push({
+              source,
+              specifiers,
+              loc: {
+                start: {
+                  line: node.startPosition.row + 1,
+                  column: node.startPosition.column
+                },
+                end: {
+                  line: node.endPosition.row + 1,
+                  column: node.endPosition.column
+                }
+              }
+            });
+          }
+        }
+      }
+    };
+    for (const node of rootNode.children) {
+      processImportNode(node);
+    }
+    return imports;
+  }
+  /**
+   * Extract export information using AST walk.
+   */
+  extractExportsAST(rootNode, code) {
+    const exports = [];
+    for (const node of rootNode.children) {
+      if (node.type === PYTHON_CONSTANTS.NODES.FUNCTION_DEFINITION) {
+        const nameNode = node.childForFieldName(PYTHON_CONSTANTS.FIELDS.NAME);
+        if (nameNode) {
+          const name = nameNode.text;
+          const isPrivate = name.startsWith("_") && !name.startsWith("__");
+          if (!isPrivate) {
+            const metadata = this.analyzeMetadata(node, code);
+            exports.push({
+              name,
+              type: PYTHON_CONSTANTS.TYPES.FUNCTION,
+              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
+            });
+          }
+        }
+      } else if (node.type === PYTHON_CONSTANTS.NODES.CLASS_DEFINITION) {
+        const nameNode = node.childForFieldName(PYTHON_CONSTANTS.FIELDS.NAME);
+        if (nameNode) {
+          const metadata = this.analyzeMetadata(node, code);
+          exports.push({
+            name: nameNode.text,
+            type: PYTHON_CONSTANTS.TYPES.CLASS,
+            loc: {
+              start: {
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column
+              },
+              end: {
+                line: node.endPosition.row + 1,
+                column: node.endPosition.column
+              }
+            },
+            ...metadata
+          });
+        }
+      } else if (node.type === PYTHON_CONSTANTS.NODES.EXPRESSION_STATEMENT) {
+        const assignment = node.firstChild;
+        if (assignment && assignment.type === PYTHON_CONSTANTS.NODES.ASSIGNMENT) {
+          const left = assignment.childForFieldName(
+            PYTHON_CONSTANTS.FIELDS.LEFT
+          );
+          if (left && left.type === PYTHON_CONSTANTS.NODES.IDENTIFIER) {
+            const name = left.text;
+            const isInternal = name === PYTHON_CONSTANTS.SPECIAL.DUNDER_ALL || name === PYTHON_CONSTANTS.SPECIAL.DUNDER_VERSION || name === PYTHON_CONSTANTS.SPECIAL.DUNDER_AUTHOR;
+            const isPrivate = name.startsWith("_") && !name.startsWith("__");
+            if (!isInternal && !isPrivate) {
+              exports.push({
+                name,
+                type: name === name.toUpperCase() ? PYTHON_CONSTANTS.TYPES.CONST : PYTHON_CONSTANTS.TYPES.VARIABLE,
+                loc: {
+                  start: {
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column
+                  },
+                  end: {
+                    line: node.endPosition.row + 1,
+                    column: node.endPosition.column
+                  }
+                }
+              });
+            }
+          }
+        }
+      }
+    }
+    return exports;
+  }
+  /**
+   * Extract parameter names from a function definition node.
+   */
+  extractParameters(node) {
+    const paramsNode = node.childForFieldName(
+      PYTHON_CONSTANTS.FIELDS.PARAMETERS
+    );
+    if (!paramsNode) return [];
+    return paramsNode.children.filter(
+      (c) => c.type === PYTHON_CONSTANTS.NODES.IDENTIFIER || c.type === PYTHON_CONSTANTS.NODES.TYPED_PARAMETER || c.type === PYTHON_CONSTANTS.NODES.DEFAULT_PARAMETER
+    ).map((c) => {
+      if (c.type === PYTHON_CONSTANTS.NODES.IDENTIFIER) return c.text;
+      return c.firstChild?.text || "unknown";
+    });
+  }
+  /**
+   * Fallback regex-based parsing when tree-sitter is unavailable.
+   */
+  parseRegex(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 as tree-sitter wasm was not available."
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const wrapper = new Error(
+        `Failed to parse Python file ${filePath}: ${message}`
+      );
+      if (error instanceof Error) {
+        wrapper.cause = error;
+      }
+      throw wrapper;
+    }
+  }
+  getNamingConventions() {
+    return {
+      variablePattern: /^[a-z_][a-z0-9_]*$/,
+      functionPattern: /^[a-z_][a-z0-9_]*$/,
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      exceptions: [
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_INIT,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_STR,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_REPR,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_NAME,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_MAIN,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_FILE,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_DOC,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_ALL,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_VERSION,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_AUTHOR,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_DICT,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_CLASS,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_MODULE,
+        PYTHON_CONSTANTS.SPECIAL.DUNDER_BASES
+      ]
+    };
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".py");
+  }
+  extractImportsRegex(code, _filePath) {
+    void _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 importsStr = fromMatch[2];
+        if (importsStr.trim() === PYTHON_CONSTANTS.SPECIAL.WILDCARD) {
+          imports.push({
+            source: module,
+            specifiers: [PYTHON_CONSTANTS.SPECIAL.WILDCARD],
+            loc: {
+              start: { line: idx + 1, column: 0 },
+              end: { line: idx + 1, column: line.length }
+            }
+          });
+          return;
+        }
+        const specifiers = importsStr.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;
+  }
+  extractExportsRegex(code, _filePath) {
+    void _filePath;
+    const exports = [];
+    const lines = code.split("\n");
+    const funcRegex = /^def\s+([a-zA-Z0-9_]+)\s*\(/;
+    const classRegex = /^class\s+([a-zA-Z0-9_]+)/;
+    lines.forEach((line, idx) => {
+      const indent = line.search(/\S/);
+      if (indent !== 0) return;
+      const classMatch = line.match(classRegex);
+      if (classMatch) {
+        exports.push({
+          name: classMatch[1],
+          type: PYTHON_CONSTANTS.TYPES.CLASS,
+          visibility: "public",
+          isPure: true,
+          hasSideEffects: false,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+        return;
+      }
+      const funcMatch = line.match(funcRegex);
+      if (funcMatch) {
+        const name = funcMatch[1];
+        if (name.startsWith("_") && !name.startsWith("__")) return;
+        let docContent;
+        const nextLines = lines.slice(idx + 1, idx + 4);
+        for (const nextLine of nextLines) {
+          const docMatch = nextLine.match(/^\s*"""([\s\S]*?)"""/) || nextLine.match(/^\s*'''([\s\S]*?)'''/);
+          if (docMatch) {
+            docContent = docMatch[1].trim();
+            break;
+          }
+          if (nextLine.trim() && !nextLine.trim().startsWith('"""') && !nextLine.trim().startsWith("'''"))
+            break;
+        }
+        const isImpure = name.toLowerCase().includes("impure") || line.includes(PYTHON_CONSTANTS.BUILTINS.PRINT) || idx + 1 < lines.length && lines[idx + 1].includes(PYTHON_CONSTANTS.BUILTINS.PRINT);
+        exports.push({
+          name,
+          type: PYTHON_CONSTANTS.TYPES.FUNCTION,
+          visibility: "public",
+          isPure: !isImpure,
+          hasSideEffects: isImpure,
+          documentation: docContent ? { content: docContent, type: PYTHON_CONSTANTS.TYPES.DOCSTRING } : void 0,
+          loc: {
+            start: { line: idx + 1, column: 0 },
+            end: { line: idx + 1, column: line.length }
+          }
+        });
+      }
+    });
+    return exports;
+  }
+};
+
+export {
+  PythonParser
+};

package/dist/chunk-4OMXBYX7.mjs

@@ -0,0 +1,167 @@
+// src/utils/path-utils.ts
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+function getDirname(importMetaUrl) {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  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 __dirname2 = 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(__dirname2, wasmFileName),
+    path.join(__dirname2, "assets", wasmFileName)
+  ];
+  for (const p of immediatePaths) {
+    if (fs.existsSync(p)) return p;
+  }
+  const pnpmPath = findInPnpmStore(__dirname2, 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: ${__dirname2}`
+  );
+  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
+};