@aiready/core 0.24.8 → 0.24.10

package/dist/chunk-Q4LOPVH6.mjs

@@ -1,305 +0,0 @@
-import {
-  ParseError
-} from "./chunk-U3IY2CFC.mjs";
-
-// src/parsers/typescript-parser.ts
-import { parse } from "@typescript-eslint/typescript-estree";
-var TypeScriptParser = class {
-  constructor() {
-    this.language = "typescript" /* TypeScript */;
-    this.extensions = [".ts", ".tsx", ".js", ".jsx"];
-  }
-  async initialize() {
-  }
-  canHandle(filePath) {
-    return this.extensions.some((ext) => filePath.endsWith(ext));
-  }
-  async getAST(code, filePath) {
-    try {
-      return parse(code, {
-        filePath,
-        loc: true,
-        range: true,
-        tokens: true,
-        comment: true,
-        jsx: filePath.endsWith("x")
-      });
-    } catch (error) {
-      const err = error;
-      throw new ParseError(err.message || "Unknown error", filePath, {
-        line: err.lineNumber || 1,
-        column: err.column || 0
-      });
-    }
-  }
-  parse(code, filePath) {
-    try {
-      const ast = parse(code, {
-        filePath,
-        loc: true,
-        range: true,
-        tokens: true,
-        comment: true,
-        jsx: filePath.endsWith("x")
-      });
-      const imports = this.extractImports(ast);
-      const exports = this.extractExports(ast, code, filePath);
-      return {
-        exports,
-        imports,
-        language: this.language
-      };
-    } catch (error) {
-      throw new ParseError(error.message, filePath, {
-        line: error.lineNumber || 1,
-        column: error.column || 0
-      });
-    }
-  }
-  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_]*$/,
-      typePattern: /^[A-Z][a-zA-Z0-9]*$/,
-      interfacePattern: /^I?[A-Z][a-zA-Z0-9]*$/
-    };
-  }
-  analyzeMetadata(node, code) {
-    if (!code) return {};
-    return {
-      isPure: this.isLikelyPure(node),
-      hasSideEffects: !this.isLikelyPure(node)
-    };
-  }
-  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, code, filePath) {
-    const exports = [];
-    for (const node of ast.body) {
-      if (node.type === "ExportNamedDeclaration") {
-        if (node.declaration) {
-          const declaration = node.declaration;
-          if ((declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") && declaration.id) {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "function",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code,
-                filePath
-              )
-            );
-          } else if (declaration.type === "ClassDeclaration" && declaration.id) {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "class",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code,
-                filePath
-              )
-            );
-          } else if (declaration.type === "TSTypeAliasDeclaration") {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "type",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code,
-                filePath
-              )
-            );
-          } else if (declaration.type === "TSInterfaceDeclaration") {
-            exports.push(
-              this.createExport(
-                declaration.id.name,
-                "interface",
-                node,
-                // Pass the outer ExportNamedDeclaration
-                code,
-                filePath
-              )
-            );
-          } else if (declaration.type === "VariableDeclaration") {
-            for (const decl of declaration.declarations) {
-              if (decl.id.type === "Identifier") {
-                exports.push(
-                  this.createExport(
-                    decl.id.name,
-                    "const",
-                    node,
-                    code,
-                    filePath,
-                    decl.init
-                  )
-                );
-              }
-            }
-          }
-        }
-      } else if (node.type === "ExportDefaultDeclaration") {
-        exports.push(
-          this.createExport("default", "default", node, code, filePath)
-        );
-      }
-    }
-    return exports;
-  }
-  createExport(name, type, node, code, filePath, initializer) {
-    const documentation = this.extractDocumentation(node, code);
-    let methodCount;
-    let propertyCount;
-    let parameters;
-    let isPrimitive = false;
-    let isTyped = false;
-    if (initializer) {
-      if (initializer.type === "Literal" || initializer.type === "TemplateLiteral" && initializer.expressions.length === 0) {
-        isPrimitive = true;
-      }
-    }
-    let structNode = node.type === "ExportNamedDeclaration" && node.declaration ? node.declaration : node.type === "ExportDefaultDeclaration" ? node.declaration : node;
-    if (!structNode) structNode = node;
-    if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
-      if (structNode.type === "TSTypeAliasDeclaration" || structNode.type === "TSInterfaceDeclaration" || structNode.type === "TSEnumDeclaration") {
-        isTyped = true;
-      } else if (structNode.type === "FunctionDeclaration" || structNode.type === "TSDeclareFunction") {
-        const func = structNode;
-        const hasReturnType = !!func.returnType;
-        const allParamsTyped = func.params.length === 0 || func.params.every((p) => !!p.typeAnnotation);
-        isTyped = hasReturnType && allParamsTyped;
-      } else if (structNode.type === "VariableDeclaration") {
-        const variable = structNode;
-        isTyped = variable.declarations.every(
-          (d) => !!d.id.typeAnnotation || !!d.init
-        );
-      } else if (structNode.type === "ClassDeclaration") {
-        isTyped = true;
-      }
-    } else if (filePath.endsWith(".js") || filePath.endsWith(".jsx")) {
-      isTyped = false;
-    }
-    if (structNode.type === "ClassDeclaration" || structNode.type === "TSInterfaceDeclaration") {
-      const body = structNode.type === "ClassDeclaration" ? structNode.body.body : structNode.body.body;
-      methodCount = body.filter(
-        (m) => m.type === "MethodDefinition" || m.type === "TSMethodSignature"
-      ).length;
-      propertyCount = body.filter(
-        (m) => m.type === "PropertyDefinition" || m.type === "TSPropertySignature"
-      ).length;
-      if (structNode.type === "ClassDeclaration") {
-        const constructor = body.find(
-          (m) => m.type === "MethodDefinition" && m.kind === "constructor"
-        );
-        if (constructor && constructor.value && constructor.value.params) {
-          parameters = constructor.value.params.map((p) => {
-            if (p.type === "Identifier") return p.name;
-            if (p.type === "TSParameterProperty" && p.parameter.type === "Identifier") {
-              return p.parameter.name;
-            }
-            return void 0;
-          }).filter((p) => !!p);
-        }
-      }
-    }
-    if (!parameters && (structNode.type === "FunctionDeclaration" || structNode.type === "TSDeclareFunction" || structNode.type === "MethodDefinition")) {
-      const funcNode = structNode.type === "MethodDefinition" ? structNode.value : structNode;
-      if (funcNode && funcNode.params) {
-        parameters = funcNode.params.map((p) => {
-          if (p.type === "Identifier") return p.name;
-          return void 0;
-        }).filter((p) => !!p);
-      }
-    }
-    return {
-      name,
-      type,
-      isPrimitive,
-      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,
-      documentation,
-      methodCount,
-      propertyCount,
-      parameters,
-      isPure: this.isLikelyPure(node),
-      hasSideEffects: !this.isLikelyPure(node),
-      isTyped
-    };
-  }
-  extractDocumentation(node, code) {
-    if (node.range) {
-      const start = node.range[0];
-      const precedingCode = code.substring(0, start);
-      const jsdocMatch = precedingCode.match(/\/\*\*([\s\S]*?)\*\/\s*$/);
-      if (jsdocMatch) {
-        return {
-          content: jsdocMatch[1].trim(),
-          type: "jsdoc"
-        };
-      }
-    }
-    return void 0;
-  }
-  isLikelyPure(node) {
-    const sn = node.type === "ExportNamedDeclaration" && node.declaration ? node.declaration : node.type === "ExportDefaultDeclaration" ? node.declaration : node;
-    if (!sn) return false;
-    if (sn.type === "VariableDeclaration" && sn.kind === "const")
-      return true;
-    if (sn.type === "FunctionDeclaration" || sn.type === "MethodDefinition") {
-      const body = sn.type === "MethodDefinition" ? sn.value.body : sn.body;
-      if (body && body.type === "BlockStatement") {
-        const bodyContent = JSON.stringify(body);
-        if (bodyContent.includes('"name":"console"') || bodyContent.includes('"name":"process"') || bodyContent.includes('"type":"AssignmentExpression"')) {
-          return false;
-        }
-        return true;
-      }
-      return true;
-    }
-    return false;
-  }
-};
-
-export {
-  TypeScriptParser
-};