@aiready/core 0.23.19 → 0.23.21

package/dist/chunk-UTCRW3N7.mjs

@@ -0,0 +1,301 @@
+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) {
+      throw new ParseError(error.message, filePath, {
+        line: error.lineNumber || 1,
+        column: error.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,
+                    // Pass the outer ExportNamedDeclaration
+                    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;
+      }
+    }
+    const structNode = node.type === "ExportNamedDeclaration" ? node.declaration : node.type === "ExportDefaultDeclaration" ? node.declaration : 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 hasReturnType = !!structNode.returnType;
+        const allParamsTyped = structNode.params.length === 0 || structNode.params.every((p) => !!p.typeAnnotation);
+        isTyped = hasReturnType && allParamsTyped;
+      } else if (structNode.type === "VariableDeclaration") {
+        isTyped = structNode.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(Boolean);
+        }
+      }
+    }
+    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(Boolean);
+      }
+    }
+    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 structNode = node.type === "ExportNamedDeclaration" ? node.declaration : node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+    if (structNode.type === "VariableDeclaration" && structNode.kind === "const")
+      return true;
+    if (structNode.type === "FunctionDeclaration" || structNode.type === "TSDeclareFunction" || structNode.type === "MethodDefinition" && structNode.value) {
+      const body = structNode.type === "MethodDefinition" ? structNode.value.body : structNode.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
+};

package/dist/{chunk-RMH2TPAT.mjs → chunk-UYLH35LA.mjs}

@@ -335,13 +335,7 @@ var ParseError = class extends Error {
   }
 };
 
-// src/scoring.ts
-var RecommendationPriority = /* @__PURE__ */ ((RecommendationPriority2) => {
-  RecommendationPriority2["High"] = "high";
-  RecommendationPriority2["Medium"] = "medium";
-  RecommendationPriority2["Low"] = "low";
-  return RecommendationPriority2;
-})(RecommendationPriority || {});
+// src/utils/rating-helpers.ts
 var ReadinessRating = /* @__PURE__ */ ((ReadinessRating2) => {
   ReadinessRating2["Excellent"] = "Excellent";
   ReadinessRating2["Good"] = "Good";
@@ -350,6 +344,83 @@ var ReadinessRating = /* @__PURE__ */ ((ReadinessRating2) => {
   ReadinessRating2["Critical"] = "Critical";
   return ReadinessRating2;
 })(ReadinessRating || {});
+function getRatingMetadata(score) {
+  if (score >= 90) {
+    return {
+      label: "Excellent",
+      slug: "excellent",
+      emoji: "\u2705",
+      rating: "Excellent" /* Excellent */
+    };
+  }
+  if (score >= 75) {
+    return {
+      label: "Good",
+      slug: "good",
+      emoji: "\u{1F44D}",
+      rating: "Good" /* Good */
+    };
+  }
+  if (score >= 60) {
+    return {
+      label: "Fair",
+      slug: "fair",
+      emoji: "\u{1F44C}",
+      rating: "Fair" /* Fair */
+    };
+  }
+  if (score >= 40) {
+    return {
+      label: "Needs Work",
+      slug: "needs-work",
+      emoji: "\u{1F528}",
+      rating: "Needs Work" /* NeedsWork */
+    };
+  }
+  return {
+    label: "Critical",
+    slug: "critical",
+    emoji: "\u{1F6A8}",
+    rating: "Critical" /* Critical */
+  };
+}
+function getRatingLabel(score) {
+  return getRatingMetadata(score).label;
+}
+function getRatingSlug(score) {
+  return getRatingMetadata(score).slug;
+}
+function getRatingEmoji(score) {
+  return getRatingMetadata(score).emoji;
+}
+function getToolEmoji(score) {
+  return getRatingEmoji(score);
+}
+function getPriorityIcon(priority) {
+  switch (priority) {
+    case "critical":
+      return "\u{1F534}";
+    case "high":
+      return "\u{1F7E0}";
+    case "medium":
+      return "\u{1F7E1}";
+    case "low":
+      return "\u{1F535}";
+    default:
+      return "\u26AA";
+  }
+}
+function getRating(score) {
+  return getRatingMetadata(score).rating;
+}
+
+// src/scoring.ts
+var RecommendationPriority = /* @__PURE__ */ ((RecommendationPriority2) => {
+  RecommendationPriority2["High"] = "high";
+  RecommendationPriority2["Medium"] = "medium";
+  RecommendationPriority2["Low"] = "low";
+  return RecommendationPriority2;
+})(RecommendationPriority || {});
 var DEFAULT_TOOL_WEIGHTS = {
   ["pattern-detect" /* PatternDetect */]: 22,
   ["context-analyzer" /* ContextAnalyzer */]: 19,
@@ -510,8 +581,8 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
   const rating = getRating(overall);
   const formulaParts = Array.from(toolOutputs.entries()).map(
     ([name, output]) => {
-      const w = weights.get(name) ?? 5;
-      return `(${output.score} \xD7 ${w})`;
+      const weight = weights.get(name) ?? 5;
+      return `(${output.score} \xD7 ${weight})`;
     }
   );
   const formulaStr = `[${formulaParts.join(" + ")}] / ${totalWeight} = ${overall}`;
@@ -528,20 +599,6 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
     }
   };
 }
-function getRating(score) {
-  if (score >= 90) return "Excellent" /* Excellent */;
-  if (score >= 75) return "Good" /* Good */;
-  if (score >= 60) return "Fair" /* Fair */;
-  if (score >= 40) return "Needs Work" /* NeedsWork */;
-  return "Critical" /* Critical */;
-}
-function getRatingSlug(score) {
-  if (score >= 90) return "excellent";
-  if (score >= 75) return "good";
-  if (score >= 60) return "fair";
-  if (score >= 40) return "needs-work";
-  return "critical";
-}
 function getRatingWithContext(score, fileCount, modelTier = "standard") {
   const threshold = getRecommendedThreshold(fileCount, modelTier);
   const normalized = score - threshold + 70;
@@ -798,8 +855,15 @@ export {
   Language,
   LANGUAGE_EXTENSIONS,
   ParseError,
-  RecommendationPriority,
   ReadinessRating,
+  getRatingMetadata,
+  getRatingLabel,
+  getRatingSlug,
+  getRatingEmoji,
+  getToolEmoji,
+  getPriorityIcon,
+  getRating,
+  RecommendationPriority,
   DEFAULT_TOOL_WEIGHTS,
   TOOL_NAME_MAP,
   ScoringProfile,
@@ -812,8 +876,6 @@ export {
   getToolWeight,
   parseWeightString,
   calculateOverallScore,
-  getRating,
-  getRatingSlug,
   getRatingWithContext,
   getRatingDisplay,
   formatScore,