@aiready/core 0.24.14 → 0.24.15

package/dist/chunk-OT6FOHL4.mjs

@@ -0,0 +1,304 @@
+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('"name":"fs"') || bodyContent.includes('"name":"fetch"') || bodyContent.includes('"name":"axios"')) {
+          return false;
+        }
+        return true;
+      }
+      return true;
+    }
+    return false;
+  }
+};
+
+export {
+  TypeScriptParser
+};

package/dist/index.js

@@ -362,7 +362,7 @@ var init_typescript_parser = __esm({
           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"')) {
+            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;
@@ -4834,7 +4834,7 @@ function inferPatternType(keyword, name) {
   if (n.includes("validate") || n.includes("schema")) return "validator";
   if (n.includes("util") || n.includes("helper")) return "utility";
   if (keyword === "class") return "class-method";
-  if (n.match(/^[A-Z]/)) return "component";
+  if (name.match(/^[A-Z]/)) return "component";
   if (keyword === "function" || keyword === "def") return "function";
   return "unknown";
 }
@@ -4900,7 +4900,14 @@ function extractCodeBlocks(file, content) {
       patternType: inferPatternType(type, name)
     });
   }
-  return blocks;
+  return blocks.filter((block) => {
+    const code = block.code.trim();
+    if (/^export\s+\{[^}]+\}\s*(from\s+['"][^'"]+['"])?\s*;?\s*$/.test(code))
+      return false;
+    if (/^export\s+\*\s+from\s+/.test(code)) return false;
+    if (/^export\s+\*\s+as\s+\w+\s+from\s+/.test(code)) return false;
+    return true;
+  });
 }
 function extractBlocksPython(file, content) {
   const blocks = [];
@@ -6332,7 +6339,15 @@ function calculateChangeAmplification(params) {
       recommendations: []
     };
   }
-  const hotspots = files.map((f) => ({ ...f, amplificationFactor: f.fanOut + f.fanIn * 0.5 })).sort((a, b) => b.amplificationFactor - a.amplificationFactor);
+  const hotspots = files.map((f) => {
+    const lowerFile = f.file.toLowerCase();
+    const isSharedInfra = lowerFile.endsWith("logger.ts") || lowerFile.endsWith("logger.js") || lowerFile.endsWith("constants.ts") || lowerFile.endsWith("constants.js") || lowerFile.endsWith("types.ts") || lowerFile.endsWith("types.js") || lowerFile.endsWith("index.ts") || lowerFile.endsWith("index.js");
+    const fanInWeight = isSharedInfra ? 0.1 : 0.5;
+    return {
+      ...f,
+      amplificationFactor: f.fanOut + f.fanIn * fanInWeight
+    };
+  }).sort((a, b) => b.amplificationFactor - a.amplificationFactor);
   const maxAmplification = hotspots[0].amplificationFactor;
   const avgAmplification = hotspots.reduce((sum, h) => sum + h.amplificationFactor, 0) / hotspots.length;
   const avgPenalty = Math.log2(avgAmplification + 1) * 15;

package/dist/index.mjs

@@ -55,7 +55,7 @@ import {
 } from "./chunk-LRM26BOB.mjs";
 import {
   TypeScriptParser
-} from "./chunk-5IVDH26E.mjs";
+} from "./chunk-OT6FOHL4.mjs";
 import {
   PythonParser
 } from "./chunk-QY5YG2AZ.mjs";
@@ -922,11 +922,11 @@ var ParserFactory = class _ParserFactory {
       Object.entries(LANGUAGE_EXTENSIONS).map(([ext, lang]) => [ext, lang])
     );
     this.registerLazyParser("typescript" /* TypeScript */, async () => {
-      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-4BA4VYAF.mjs");
+      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-RMNCTHRD.mjs");
       return new TypeScriptParser2();
     });
     this.registerLazyParser("javascript" /* JavaScript */, async () => {
-      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-4BA4VYAF.mjs");
+      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-RMNCTHRD.mjs");
       return new TypeScriptParser2();
     });
     this.registerLazyParser("python" /* Python */, async () => {
@@ -1865,7 +1865,7 @@ function inferPatternType(keyword, name) {
   if (n.includes("validate") || n.includes("schema")) return "validator";
   if (n.includes("util") || n.includes("helper")) return "utility";
   if (keyword === "class") return "class-method";
-  if (n.match(/^[A-Z]/)) return "component";
+  if (name.match(/^[A-Z]/)) return "component";
   if (keyword === "function" || keyword === "def") return "function";
   return "unknown";
 }
@@ -1931,7 +1931,14 @@ function extractCodeBlocks(file, content) {
       patternType: inferPatternType(type, name)
     });
   }
-  return blocks;
+  return blocks.filter((block) => {
+    const code = block.code.trim();
+    if (/^export\s+\{[^}]+\}\s*(from\s+['"][^'"]+['"])?\s*;?\s*$/.test(code))
+      return false;
+    if (/^export\s+\*\s+from\s+/.test(code)) return false;
+    if (/^export\s+\*\s+as\s+\w+\s+from\s+/.test(code)) return false;
+    return true;
+  });
 }
 function extractBlocksPython(file, content) {
   const blocks = [];
@@ -3355,7 +3362,15 @@ function calculateChangeAmplification(params) {
       recommendations: []
     };
   }
-  const hotspots = files.map((f) => ({ ...f, amplificationFactor: f.fanOut + f.fanIn * 0.5 })).sort((a, b) => b.amplificationFactor - a.amplificationFactor);
+  const hotspots = files.map((f) => {
+    const lowerFile = f.file.toLowerCase();
+    const isSharedInfra = lowerFile.endsWith("logger.ts") || lowerFile.endsWith("logger.js") || lowerFile.endsWith("constants.ts") || lowerFile.endsWith("constants.js") || lowerFile.endsWith("types.ts") || lowerFile.endsWith("types.js") || lowerFile.endsWith("index.ts") || lowerFile.endsWith("index.js");
+    const fanInWeight = isSharedInfra ? 0.1 : 0.5;
+    return {
+      ...f,
+      amplificationFactor: f.fanOut + f.fanIn * fanInWeight
+    };
+  }).sort((a, b) => b.amplificationFactor - a.amplificationFactor);
   const maxAmplification = hotspots[0].amplificationFactor;
   const avgAmplification = hotspots.reduce((sum, h) => sum + h.amplificationFactor, 0) / hotspots.length;
   const avgPenalty = Math.log2(avgAmplification + 1) * 15;

package/dist/typescript-parser-RMNCTHRD.mjs

@@ -0,0 +1,7 @@
+import {
+  TypeScriptParser
+} from "./chunk-OT6FOHL4.mjs";
+import "./chunk-U3IY2CFC.mjs";
+export {
+  TypeScriptParser
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.24.14",
+  "version": "0.24.15",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",