@aiready/core 0.24.4 → 0.24.6

package/dist/chunk-SM6INS52.mjs

@@ -1,501 +0,0 @@
-import {
-  BaseLanguageParser
-} from "./chunk-2N7ISIKE.mjs";
-
-// src/parsers/metadata-utils.ts
-function analyzeNodeMetadata(node, code, options) {
-  const metadata = {
-    isPure: true,
-    hasSideEffects: false
-  };
-  try {
-    let prev = node.previousSibling || null;
-    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 ? 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 PythonParser = class extends BaseLanguageParser {
-  constructor() {
-    super(...arguments);
-    this.language = "python" /* Python */;
-    this.extensions = [".py"];
-  }
-  getParserName() {
-    return "python";
-  }
-  /**
-   * Analyze metadata for a Python 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 analyzeNodeMetadata(node, code, {
-      sideEffectSignatures: ["print(", "input(", "open("]
-    });
-  }
-  /**
-   * Extract import information using AST walk.
-   *
-   * @param rootNode - Root node of the Python AST.
-   * @returns Array of discovered FileImport objects.
-   */
-  extractImportsAST(rootNode) {
-    const imports = [];
-    const processImportNode = (node) => {
-      if (node.type === "import_statement") {
-        for (const child of node.children) {
-          if (child.type === "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 === "aliased_import") {
-            const nameNode = child.childForFieldName("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 === "import_from_statement") {
-        const moduleNameNode = node.childForFieldName("module_name");
-        if (moduleNameNode) {
-          const source = moduleNameNode.text;
-          const specifiers = [];
-          for (const child of node.children) {
-            if (child.type === "dotted_name" && child !== moduleNameNode) {
-              specifiers.push(child.text);
-            } else if (child.type === "aliased_import") {
-              const nameNode = child.childForFieldName("name");
-              if (nameNode) specifiers.push(nameNode.text);
-            } else if (child.type === "wildcard_import") {
-              specifiers.push("*");
-            }
-          }
-          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.
-   *
-   * @param rootNode - Root node of the Python 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 === "function_definition") {
-        const nameNode = node.childForFieldName("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: "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 === "class_definition") {
-        const nameNode = node.childForFieldName("name");
-        if (nameNode) {
-          const metadata = this.analyzeMetadata(node, code);
-          exports.push({
-            name: nameNode.text,
-            type: "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 === "expression_statement") {
-        const assignment = node.firstChild;
-        if (assignment && assignment.type === "assignment") {
-          const left = assignment.childForFieldName("left");
-          if (left && left.type === "identifier") {
-            const name = left.text;
-            const isInternal = name === "__all__" || name === "__version__" || name === "__author__";
-            const isPrivate = name.startsWith("_") && !name.startsWith("__");
-            if (!isInternal && !isPrivate) {
-              exports.push({
-                name,
-                type: name === name.toUpperCase() ? "const" : "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.
-   *
-   * @param node - Function definition node.
-   * @returns Array of parameter name strings.
-   */
-  extractParameters(node) {
-    const paramsNode = node.childForFieldName("parameters");
-    if (!paramsNode) return [];
-    return paramsNode.children.filter(
-      (c) => c.type === "identifier" || c.type === "typed_parameter" || c.type === "default_parameter"
-    ).map((c) => {
-      if (c.type === "identifier") return c.text;
-      if (c.type === "typed_parameter" || c.type === "default_parameter") {
-        return c.firstChild?.text || "unknown";
-      }
-      return "unknown";
-    });
-  }
-  /**
-   * Fallback regex-based parsing when tree-sitter is unavailable.
-   *
-   * @param code - Source code content.
-   * @param filePath - Path to the file being parsed.
-   * @returns Consolidated ParseResult.
-   */
-  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 wrapper = new Error(
-        `Failed to parse Python file ${filePath}: ${error.message}`
-      );
-      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: [
-        "__init__",
-        "__str__",
-        "__repr__",
-        "__name__",
-        "__main__",
-        "__file__",
-        "__doc__",
-        "__all__",
-        "__version__",
-        "__author__",
-        "__dict__",
-        "__class__",
-        "__module__",
-        "__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() === "*") {
-          imports.push({
-            source: module,
-            specifiers: ["*"],
-            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: "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("print(") || idx + 1 < lines.length && lines[idx + 1].includes("print(");
-        exports.push({
-          name,
-          type: "function",
-          visibility: "public",
-          isPure: !isImpure,
-          hasSideEffects: isImpure,
-          documentation: docContent ? { content: docContent, type: "docstring" } : void 0,
-          loc: {
-            start: { line: idx + 1, column: 0 },
-            end: { line: idx + 1, column: line.length }
-          }
-        });
-      }
-    });
-    return exports;
-  }
-};
-
-export {
-  PythonParser
-};