@aiready/core 0.24.19 → 0.24.21

package/dist/chunk-WUDUSXUE.mjs

@@ -0,0 +1,366 @@
+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 === 'TSDeclareFunction' ||
+      sn.type === 'MethodDefinition'
+    ) {
+      const body = sn.type === 'MethodDefinition' ? sn.value.body : sn.body;
+      if (body && body.type === 'BlockStatement') {
+        const bodyContent = JSON.stringify(body, (_, v) =>
+          typeof v === 'bigint' ? v.toString() : v
+        );
+        if (
+          bodyContent.includes('"name":"console"') ||
+          bodyContent.includes('"name":"process"') ||
+          bodyContent.includes('"name":"fs"') ||
+          bodyContent.includes('"name":"fetch"') ||
+          bodyContent.includes('"name":"axios"')
+        ) {
+          return false;
+        }
+        return true;
+      }
+      return true;
+    }
+    return false;
+  }
+};
+
+export { TypeScriptParser };

package/dist/chunk-YQATXOKD.mjs

@@ -0,0 +1,36 @@
+// src/types/language.ts
+var Language = /* @__PURE__ */ ((Language2) => {
+  Language2["TypeScript"] = "typescript";
+  Language2["JavaScript"] = "javascript";
+  Language2["Python"] = "python";
+  Language2["Java"] = "java";
+  Language2["Go"] = "go";
+  Language2["Rust"] = "rust";
+  Language2["CSharp"] = "csharp";
+  return Language2;
+})(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";
+  }
+};
+
+export {
+  Language,
+  LANGUAGE_EXTENSIONS,
+  ParseError
+};