@aiready/core 0.24.5 → 0.24.6

package/dist/index.js

@@ -99,9 +99,10 @@ var init_typescript_parser = __esm({
             jsx: filePath.endsWith("x")
           });
         } catch (error) {
-          throw new ParseError(error.message, filePath, {
-            line: error.lineNumber || 1,
-            column: error.column || 0
+          const err = error;
+          throw new ParseError(err.message || "Unknown error", filePath, {
+            line: err.lineNumber || 1,
+            column: err.column || 0
           });
         }
       }
@@ -240,7 +241,6 @@ var init_typescript_parser = __esm({
                         decl.id.name,
                         "const",
                         node,
-                        // Pass the outer ExportNamedDeclaration
                         code,
                         filePath,
                         decl.init
@@ -270,16 +270,19 @@ var init_typescript_parser = __esm({
             isPrimitive = true;
           }
         }
-        const structNode = node.type === "ExportNamedDeclaration" ? node.declaration : node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+        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 hasReturnType = !!structNode.returnType;
-            const allParamsTyped = structNode.params.length === 0 || structNode.params.every((p) => !!p.typeAnnotation);
+            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") {
-            isTyped = structNode.declarations.every(
+            const variable = structNode;
+            isTyped = variable.declarations.every(
               (d) => !!d.id.typeAnnotation || !!d.init
             );
           } else if (structNode.type === "ClassDeclaration") {
@@ -307,7 +310,7 @@ var init_typescript_parser = __esm({
                   return p.parameter.name;
                 }
                 return void 0;
-              }).filter(Boolean);
+              }).filter((p) => !!p);
             }
           }
         }
@@ -317,7 +320,7 @@ var init_typescript_parser = __esm({
             parameters = funcNode.params.map((p) => {
               if (p.type === "Identifier") return p.name;
               return void 0;
-            }).filter(Boolean);
+            }).filter((p) => !!p);
           }
         }
         return {
@@ -352,11 +355,11 @@ var init_typescript_parser = __esm({
         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;
+        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"')) {
@@ -379,7 +382,7 @@ function analyzeNodeMetadata(node, code, options) {
     hasSideEffects: false
   };
   try {
-    let prev = node.previousSibling || null;
+    let prev = node.previousSibling;
     while (prev && /comment/i.test(prev.type)) {
       const text = prev.text || "";
       const loc = {
@@ -419,7 +422,7 @@ function analyzeNodeMetadata(node, code, options) {
       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");
+      const body2 = 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") {
@@ -483,7 +486,7 @@ function analyzeNodeMetadata(node, code, options) {
     } catch {
     }
   };
-  const body = node.childForFieldName?.("body") || node.children.find(
+  const body = node.childForFieldName("body") || node.children.find(
     (c) => /body|block|class_body|declaration_list|function_body/.test(c.type)
   );
   if (body) walk(body);
@@ -731,6 +734,9 @@ var init_python_parser = __esm({
         this.language = "python" /* Python */;
         this.extensions = [".py"];
       }
+      /**
+       * Returns the canonical name of this parser.
+       */
       getParserName() {
         return "python";
       }
@@ -931,10 +937,7 @@ var init_python_parser = __esm({
           (c) => c.type === PYTHON_CONSTANTS.NODES.IDENTIFIER || c.type === PYTHON_CONSTANTS.NODES.TYPED_PARAMETER || c.type === PYTHON_CONSTANTS.NODES.DEFAULT_PARAMETER
         ).map((c) => {
           if (c.type === PYTHON_CONSTANTS.NODES.IDENTIFIER) return c.text;
-          if (c.type === PYTHON_CONSTANTS.NODES.TYPED_PARAMETER || c.type === PYTHON_CONSTANTS.NODES.DEFAULT_PARAMETER) {
-            return c.firstChild?.text || "unknown";
-          }
-          return "unknown";
+          return c.firstChild?.text || "unknown";
         });
       }
       /**
@@ -953,10 +956,13 @@ var init_python_parser = __esm({
             ]
           };
         } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
           const wrapper = new Error(
-            `Failed to parse Python file ${filePath}: ${error.message}`
+            `Failed to parse Python file ${filePath}: ${message}`
           );
-          wrapper.cause = error;
+          if (error instanceof Error) {
+            wrapper.cause = error;
+          }
           throw wrapper;
         }
       }
@@ -1099,15 +1105,19 @@ var init_python_parser = __esm({
 });
 
 // src/parsers/shared-parser-utils.ts
+function getNodeProperty(node, prop) {
+  if (!node) return null;
+  return node[prop] ?? null;
+}
 function analyzeGeneralMetadata(node, code, options = {}) {
   const metadata = {
     isPure: true,
     hasSideEffects: false
   };
   try {
-    let prev = node.previousNamedSibling || node.previousSibling || null;
+    let prev = getNodeProperty(node, "previousNamedSibling") || getNodeProperty(node, "previousSibling") || null;
     while (prev && (!prev.type || !prev.text.trim())) {
-      prev = prev.previousSibling || null;
+      prev = getNodeProperty(prev, "previousSibling");
     }
     if (!prev && node.parent) {
       const children = node.parent.children;
@@ -1120,9 +1130,9 @@ function analyzeGeneralMetadata(node, code, options = {}) {
       }
     }
     while (prev && /attribute|decorator/i.test(prev.type)) {
-      prev = prev.previousNamedSibling || prev.previousSibling || null;
+      prev = getNodeProperty(prev, "previousNamedSibling") || getNodeProperty(prev, "previousSibling") || null;
       while (prev && (!prev.type || !prev.text.trim())) {
-        prev = prev.previousSibling || null;
+        prev = getNodeProperty(prev, "previousSibling");
       }
     }
     while (prev && (/comment|xml|doc|slash/i.test(prev.type) || prev.text.trim().startsWith("//") || prev.text.trim().startsWith("///"))) {
@@ -1148,7 +1158,7 @@ function analyzeGeneralMetadata(node, code, options = {}) {
         };
         break;
       }
-      prev = prev.previousSibling || null;
+      prev = getNodeProperty(prev, "previousSibling");
     }
   } catch {
   }
@@ -1185,8 +1195,12 @@ function extractParameterNames(node) {
   const params = [];
   const candidates = [
     // common field name
-    node.childForFieldName ? node.childForFieldName("parameters") : null,
-    node.childForFieldName ? node.childForFieldName("parameter_list") : null,
+    getNodeProperty(node, "childForFieldName") ? getNodeProperty(node, "childForFieldName")?.childForFieldName?.(
+      "parameters"
+    ) ?? null : null,
+    getNodeProperty(node, "childForFieldName") ? getNodeProperty(node, "childForFieldName")?.childForFieldName?.(
+      "parameter_list"
+    ) ?? null : null,
     node.children.find((c) => c.type === "parameter_list") || null,
     node.children.find((c) => c.type === "parameters") || null,
     node.children.find((c) => c.type === "formal_parameters") || null,
@@ -1196,7 +1210,9 @@ function extractParameterNames(node) {
   if (!list) return params;
   for (const child of list.children) {
     if (!child) continue;
-    const id = child.childForFieldName?.("name") || child.children.find(
+    const id = getNodeProperty(child, "childForFieldName")?.childForFieldName?.(
+      "name"
+    ) || child.children.find(
       (c) => [
         "identifier",
         "variable_name",
@@ -1648,11 +1664,17 @@ var init_csharp_parser = __esm({
               const isPublic = modifiers.includes("public") || modifiers.includes("protected");
               if (isPublic) {
                 const metadata = this.analyzeMetadata(node, code);
-                const type = node.type.replace("_declaration", "");
+                const nodeType = node.type.replace("_declaration", "");
+                let exportType = "class";
+                if (nodeType === "record" || nodeType === "struct" || nodeType === "enum") {
+                  exportType = "class";
+                } else if (nodeType === "interface" || nodeType === "interface_declaration") {
+                  exportType = "interface";
+                }
                 const fullName = nextClass ? `${nextClass}.${nameNode.text}` : nextNamespace ? `${nextNamespace}.${nameNode.text}` : nameNode.text;
-                exports2.push({
+                const exportItem = {
                   name: fullName,
-                  type: type === "record" ? "class" : type,
+                  type: exportType,
                   loc: {
                     start: {
                       line: node.startPosition.row + 1,
@@ -1665,7 +1687,8 @@ var init_csharp_parser = __esm({
                   },
                   visibility: modifiers.includes("public") ? "public" : "protected",
                   ...metadata
-                });
+                };
+                exports2.push(exportItem);
                 nextClass = fullName;
               }
             }
@@ -1676,9 +1699,9 @@ var init_csharp_parser = __esm({
               const isPublic = modifiers.includes("public") || modifiers.includes("protected");
               if (isPublic) {
                 const metadata = this.analyzeMetadata(node, code);
-                exports2.push({
+                const methodItem = {
                   name: nameNode.text,
-                  type: node.type === "method_declaration" ? "function" : "property",
+                  type: node.type === "method_declaration" ? "function" : "variable",
                   parentClass: currentClass,
                   loc: {
                     start: {
@@ -1693,7 +1716,8 @@ var init_csharp_parser = __esm({
                   visibility: modifiers.includes("public") ? "public" : "protected",
                   parameters: node.type === "method_declaration" ? this.extractParameters(node) : void 0,
                   ...metadata
-                });
+                };
+                exports2.push(methodItem);
               }
             }
           }
@@ -3536,7 +3560,7 @@ function extractExportsWithDependencies(ast, fileImports) {
         type: "default",
         imports: usedImports,
         dependencies: [],
-        typeReferences,
+        typeReferences: [],
         loc: node.loc
       });
     } else if (node.type === "ExportAllDeclaration") {
@@ -3585,6 +3609,7 @@ function findUsedImports(node, importedNames) {
       usedImports.add(n.name);
     }
     for (const key in n) {
+      if (key === "parent") continue;
       const value = n[key];
       if (value && typeof value === "object") {
         if (Array.isArray(value)) {
@@ -3628,6 +3653,7 @@ function extractTypeReferences(node) {
       }
     }
     for (const key of Object.keys(n)) {
+      if (key === "parent") continue;
       const value = n[key];
       if (Array.isArray(value)) {
         value.forEach(visit);
@@ -3992,65 +4018,146 @@ var REPORT_STYLES = `
 `;
 
 // src/utils/report-formatters.ts
+var REPORT_CONSTANTS = {
+  TAGS: {
+    HTML: "html",
+    HEAD: "head",
+    BODY: "body",
+    TITLE: "title",
+    STYLE: "style",
+    META: "meta",
+    DIV: "div",
+    H1: "h1",
+    H2: "h2",
+    P: "p",
+    SPAN: "span",
+    STRONG: "strong",
+    A: "a",
+    TABLE: "table",
+    THEAD: "thead",
+    TBODY: "tbody",
+    TR: "tr",
+    TH: "th",
+    TD: "td"
+  },
+  ATTRS: {
+    LANG: "lang",
+    CHARSET: "charset",
+    NAME: "name",
+    CONTENT: "content",
+    VIEWPORT: "viewport",
+    VIEWPORT_VAL: "width=device-width, initial-scale=1.0",
+    UTF8: "UTF-8",
+    EN: "en",
+    CLASS: "class",
+    STYLE: "style",
+    HREF: "href"
+  },
+  CLASSES: {
+    HERO: "hero",
+    STAT_CARD: "stat-card",
+    STAT_VALUE: "stat-value",
+    STAT_LABEL: "stat-label",
+    STATS: "stats",
+    CARD: "card",
+    CRITICAL: "critical",
+    MAJOR: "major",
+    MINOR: "minor",
+    FOOTER: "footer",
+    SCORE_CARD: "score-card",
+    SCORE_VALUE: "score-value",
+    SCORE_LABEL: "score-label"
+  }
+};
 function tag(name, content = "", attrs = {}) {
   const attrStr = Object.entries(attrs).map(([k, v]) => ` ${k}="${v}"`).join("");
   return `<${name}${attrStr}>${content}</${name}>`;
 }
 function generateReportHead(title, styles = REPORT_STYLES) {
+  const metaCharset = tag("", "", {
+    [REPORT_CONSTANTS.ATTRS.CHARSET]: REPORT_CONSTANTS.ATTRS.UTF8
+  }).replace(/^<|>/g, "");
+  const metaViewport = tag("", "", {
+    [REPORT_CONSTANTS.ATTRS.NAME]: REPORT_CONSTANTS.ATTRS.VIEWPORT,
+    [REPORT_CONSTANTS.ATTRS.CONTENT]: REPORT_CONSTANTS.ATTRS.VIEWPORT_VAL
+  }).replace(/^<|>/g, "");
   return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  ${tag("title", title)}
-  ${tag("style", styles)}
-</head>`;
+<${REPORT_CONSTANTS.TAGS.HTML} ${REPORT_CONSTANTS.ATTRS.LANG}="${REPORT_CONSTANTS.ATTRS.EN}">
+<${REPORT_CONSTANTS.TAGS.HEAD}>
+  <meta ${metaCharset}>
+  <meta ${metaViewport}>
+  ${tag(REPORT_CONSTANTS.TAGS.TITLE, title)}
+  ${tag(REPORT_CONSTANTS.TAGS.STYLE, styles)}
+</${REPORT_CONSTANTS.TAGS.HEAD}>`;
 }
 function generateReportHero(title, subtitle) {
-  return tag("div", tag("h1", title) + (subtitle ? tag("p", subtitle) : ""), {
-    class: "hero"
-  });
+  return tag(
+    REPORT_CONSTANTS.TAGS.DIV,
+    tag(REPORT_CONSTANTS.TAGS.H1, title) + (subtitle ? tag(REPORT_CONSTANTS.TAGS.P, subtitle) : ""),
+    {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.HERO
+    }
+  );
 }
 function generateStatCards(cards) {
   const cardsHtml = cards.map(
     (c) => tag(
-      "div",
-      tag("div", String(c.value), {
-        class: "stat-value",
-        ...c.color ? { style: `color: ${c.color}` } : {}
-      }) + tag("div", c.label, { class: "stat-label" }),
-      { class: "stat-card" }
+      REPORT_CONSTANTS.TAGS.DIV,
+      tag(REPORT_CONSTANTS.TAGS.DIV, String(c.value), {
+        [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.STAT_VALUE,
+        ...c.color ? { [REPORT_CONSTANTS.ATTRS.STYLE]: `color: ${c.color}` } : {}
+      }) + tag(REPORT_CONSTANTS.TAGS.DIV, c.label, {
+        [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.STAT_LABEL
+      }),
+      { [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.STAT_CARD }
     )
   ).join("");
-  return tag("div", cardsHtml, { class: "stats" });
+  return tag(REPORT_CONSTANTS.TAGS.DIV, cardsHtml, {
+    [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.STATS
+  });
 }
 function generateTable(config) {
   const head = tag(
-    "thead",
-    tag("tr", config.headers.map((h) => tag("th", h)).join(""))
+    REPORT_CONSTANTS.TAGS.THEAD,
+    tag(
+      REPORT_CONSTANTS.TAGS.TR,
+      config.headers.map((h) => tag(REPORT_CONSTANTS.TAGS.TH, h)).join("")
+    )
   );
   const body = tag(
-    "tbody",
+    REPORT_CONSTANTS.TAGS.TBODY,
     config.rows.map(
-      (row) => tag("tr", row.map((cell) => tag("td", cell)).join(""))
+      (row) => tag(
+        REPORT_CONSTANTS.TAGS.TR,
+        row.map((cell) => tag(REPORT_CONSTANTS.TAGS.TD, cell)).join("")
+      )
     ).join("")
   );
-  return tag("table", head + body);
+  return tag(REPORT_CONSTANTS.TAGS.TABLE, head + body);
 }
 function generateIssueSummary(crit, maj, min, savings) {
   const details = [
-    tag("span", `\u{1F534} Critical: ${crit}`, { class: "critical" }),
-    tag("span", `\u{1F7E1} Major: ${maj}`, { class: "major" }),
-    tag("span", `\u{1F535} Minor: ${min}`, { class: "minor" })
+    tag(REPORT_CONSTANTS.TAGS.SPAN, `\u{1F534} Critical: ${crit}`, {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.CRITICAL
+    }),
+    tag(REPORT_CONSTANTS.TAGS.SPAN, `\u{1F7E1} Major: ${maj}`, {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.MAJOR
+    }),
+    tag(REPORT_CONSTANTS.TAGS.SPAN, `\u{1F535} Minor: ${min}`, {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.MINOR
+    })
   ].join(" &nbsp; ");
   const savingsHtml = savings ? tag(
-    "p",
-    tag("strong", "Potential Savings: ") + savings.toLocaleString() + " tokens"
+    REPORT_CONSTANTS.TAGS.P,
+    tag(REPORT_CONSTANTS.TAGS.STRONG, "Potential Savings: ") + savings.toLocaleString() + " tokens"
   ) : "";
   return tag(
-    "div",
-    tag("h2", "\u26A0\uFE0F Issues Summary") + tag("p", details) + savingsHtml,
-    { class: "card", style: "margin-bottom: 30px;" }
+    REPORT_CONSTANTS.TAGS.DIV,
+    tag(REPORT_CONSTANTS.TAGS.H2, "\u26A0\uFE0F Issues Summary") + tag(REPORT_CONSTANTS.TAGS.P, details) + savingsHtml,
+    {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.CARD,
+      [REPORT_CONSTANTS.ATTRS.STYLE]: "margin-bottom: 30px;"
+    }
   );
 }
 function generateReportFooter(options) {
@@ -4059,33 +4166,41 @@ function generateReportFooter(options) {
   if (options.packageUrl)
     links.push(
       tag(
-        "p",
-        `Like AIReady? ${tag("a", "Star us on GitHub", { href: options.packageUrl })}`
+        REPORT_CONSTANTS.TAGS.P,
+        `Like AIReady? ${tag(REPORT_CONSTANTS.TAGS.A, "Star us on GitHub", {
+          [REPORT_CONSTANTS.ATTRS.HREF]: options.packageUrl
+        })}`
       )
     );
   if (options.bugUrl)
     links.push(
       tag(
-        "p",
-        `Like AIReady? ${tag("a", "Report it here", { href: options.bugUrl })}`
+        REPORT_CONSTANTS.TAGS.P,
+        `Like AIReady? ${tag(REPORT_CONSTANTS.TAGS.A, "Report it here", {
+          [REPORT_CONSTANTS.ATTRS.HREF]: options.bugUrl
+        })}`
       )
     );
   return tag(
-    "div",
+    REPORT_CONSTANTS.TAGS.DIV,
     tag(
-      "p",
-      `Generated by ${tag("strong", "@aiready/" + options.packageName)}` + version
+      REPORT_CONSTANTS.TAGS.P,
+      `Generated by ${tag(REPORT_CONSTANTS.TAGS.STRONG, "@aiready/" + options.packageName)}` + version
     ) + links.join(""),
-    { class: "footer" }
+    { [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.FOOTER }
   );
 }
 function wrapInCard(content, title) {
-  return tag("div", (title ? tag("h2", title) : "") + content, {
-    class: "card"
-  });
+  return tag(
+    REPORT_CONSTANTS.TAGS.DIV,
+    (title ? tag(REPORT_CONSTANTS.TAGS.H2, title) : "") + content,
+    {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.CARD
+    }
+  );
 }
 function generateCompleteReport(options, body) {
-  return generateReportHead(options.title) + tag("body", body + generateReportFooter(options));
+  return generateReportHead(options.title) + tag(REPORT_CONSTANTS.TAGS.BODY, body + generateReportFooter(options));
 }
 function generateStandardHtmlReport(options, stats, sections, score) {
   const hero = generateReportHero(
@@ -4093,9 +4208,13 @@ function generateStandardHtmlReport(options, stats, sections, score) {
     `Generated on ${(/* @__PURE__ */ new Date()).toLocaleString()}`
   );
   const scoreCard = score ? tag(
-    "div",
-    tag("div", String(score.value), { class: "score-value" }) + tag("div", score.label, { class: "score-label" }),
-    { class: "score-card" }
+    REPORT_CONSTANTS.TAGS.DIV,
+    tag(REPORT_CONSTANTS.TAGS.DIV, String(score.value), {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.SCORE_VALUE
+    }) + tag(REPORT_CONSTANTS.TAGS.DIV, score.label, {
+      [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.SCORE_LABEL
+    }),
+    { [REPORT_CONSTANTS.ATTRS.CLASS]: REPORT_CONSTANTS.CLASSES.SCORE_CARD }
   ) : "";
   const statsCards = generateStatCards(stats);
   const bodyContent = `
@@ -4195,6 +4314,31 @@ var RecommendationPriority = /* @__PURE__ */ ((RecommendationPriority2) => {
 })(RecommendationPriority || {});
 
 // src/scoring.ts
+var SCORING_CONSTANTS = {
+  WEIGHTS: {
+    DEFAULT: 5,
+    MAX: 100
+  },
+  THRESHOLDS: {
+    XS: 80,
+    SMALL: 75,
+    MEDIUM: 70,
+    LARGE: 65,
+    ENTERPRISE: 58,
+    NORMALIZATION_OFFSET: 70
+  },
+  FILE_COUNTS: {
+    XS: 50,
+    SMALL: 200,
+    MEDIUM: 500,
+    LARGE: 2e3
+  },
+  DELIMITERS: {
+    LIST: ",",
+    PAIR: ":",
+    FORMULA_JOIN: " + "
+  }
+};
 var DEFAULT_TOOL_WEIGHTS = {
   ["pattern-detect" /* PatternDetect */]: 22,
   ["context-analyzer" /* ContextAnalyzer */]: 19,
@@ -4282,22 +4426,22 @@ var CONTEXT_TIER_THRESHOLDS = {
   frontier: { idealTokens: 5e4, criticalTokens: 15e4, idealDepth: 10 }
 };
 var SIZE_ADJUSTED_THRESHOLDS = {
-  xs: 80,
+  xs: SCORING_CONSTANTS.THRESHOLDS.XS,
   // < 50 files
-  small: 75,
+  small: SCORING_CONSTANTS.THRESHOLDS.SMALL,
   // 50-200 files
-  medium: 70,
+  medium: SCORING_CONSTANTS.THRESHOLDS.MEDIUM,
   // 200-500 files
-  large: 65,
+  large: SCORING_CONSTANTS.THRESHOLDS.LARGE,
   // 500-2000 files
-  enterprise: 58
+  enterprise: SCORING_CONSTANTS.THRESHOLDS.ENTERPRISE
   // 2000+ files
 };
 function getProjectSizeTier(fileCount) {
-  if (fileCount < 50) return "xs";
-  if (fileCount < 200) return "small";
-  if (fileCount < 500) return "medium";
-  if (fileCount < 2e3) return "large";
+  if (fileCount < SCORING_CONSTANTS.FILE_COUNTS.XS) return "xs";
+  if (fileCount < SCORING_CONSTANTS.FILE_COUNTS.SMALL) return "small";
+  if (fileCount < SCORING_CONSTANTS.FILE_COUNTS.MEDIUM) return "medium";
+  if (fileCount < SCORING_CONSTANTS.FILE_COUNTS.LARGE) return "large";
   return "enterprise";
 }
 function getRecommendedThreshold(fileCount, modelTier = "standard") {
@@ -4313,14 +4457,16 @@ function getToolWeight(toolName, toolConfig, cliOverride, profile = "default" /*
   if (cliOverride !== void 0) return cliOverride;
   if (toolConfig?.scoreWeight !== void 0) return toolConfig.scoreWeight;
   const profileWeights = SCORING_PROFILES[profile] ?? DEFAULT_TOOL_WEIGHTS;
-  return profileWeights[toolName] ?? DEFAULT_TOOL_WEIGHTS[toolName] ?? 5;
+  return profileWeights[toolName] ?? DEFAULT_TOOL_WEIGHTS[toolName] ?? SCORING_CONSTANTS.WEIGHTS.DEFAULT;
 }
 function parseWeightString(weightStr) {
   const weights = /* @__PURE__ */ new Map();
   if (!weightStr) return weights;
-  const pairs = weightStr.split(",");
+  const pairs = weightStr.split(SCORING_CONSTANTS.DELIMITERS.LIST);
   for (const pair of pairs) {
-    const [toolShortName, weightValueStr] = pair.split(":");
+    const [toolShortName, weightValueStr] = pair.split(
+      SCORING_CONSTANTS.DELIMITERS.PAIR
+    );
     if (toolShortName && weightValueStr) {
       const toolName = normalizeToolName(toolShortName.trim());
       const weight = parseInt(weightValueStr.trim(), 10);
@@ -4335,7 +4481,7 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
   if (toolOutputs.size === 0) {
     throw new Error("No tool outputs provided for scoring");
   }
-  const profile = config?.scoring?.profile || "default" /* Default */;
+  const profile = config?.profile || "default" /* Default */;
   const weights = /* @__PURE__ */ new Map();
   for (const [toolName] of toolOutputs.entries()) {
     const cliWeight = cliWeights?.get(toolName);
@@ -4349,7 +4495,7 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
   const toolsUsed = [];
   const calculationWeights = {};
   for (const [toolName, output] of toolOutputs.entries()) {
-    const weight = weights.get(toolName) ?? 5;
+    const weight = weights.get(toolName) ?? SCORING_CONSTANTS.WEIGHTS.DEFAULT;
     weightedSum += output.score * weight;
     totalWeight += weight;
     toolsUsed.push(toolName);
@@ -4360,11 +4506,11 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
   const rating = getRating(overall);
   const formulaParts = Array.from(toolOutputs.entries()).map(
     ([name, output]) => {
-      const weight = weights.get(name) ?? 5;
+      const weight = weights.get(name) ?? SCORING_CONSTANTS.WEIGHTS.DEFAULT;
       return `(${output.score} \xD7 ${weight})`;
     }
   );
-  const formulaStr = `[${formulaParts.join(" + ")}] / ${totalWeight} = ${overall}`;
+  const formulaStr = `[${formulaParts.join(SCORING_CONSTANTS.DELIMITERS.FORMULA_JOIN)}] / ${totalWeight} = ${overall}`;
   return {
     overall,
     rating,
@@ -4380,7 +4526,7 @@ function calculateOverallScore(toolOutputs, config, cliWeights) {
 }
 function getRatingWithContext(score, fileCount, modelTier = "standard") {
   const threshold = getRecommendedThreshold(fileCount, modelTier);
-  const normalized = score - threshold + 70;
+  const normalized = score - threshold + SCORING_CONSTANTS.THRESHOLDS.NORMALIZATION_OFFSET;
   return getRating(normalized);
 }
 function getRatingDisplay(rating) {
@@ -4450,22 +4596,22 @@ function buildFactorsFromDimensions(dimensions, dimensionNames, rawData) {
 }
 function formatDimensionDescription(key, rawData) {
   if (key === "testCoverageRatio" && rawData.testFiles !== void 0) {
-    return `${rawData.testFiles} test files / ${rawData.sourceFiles} source files`;
+    return `${String(rawData.testFiles)} test files / ${String(rawData.sourceFiles)} source files`;
   }
   if (key === "purityScore" && rawData.pureFunctions !== void 0) {
-    return `${rawData.pureFunctions}/${rawData.totalFunctions} functions are pure`;
+    return `${String(rawData.pureFunctions)}/${String(rawData.totalFunctions)} functions are pure`;
   }
   if (key === "dependencyInjectionScore" && rawData.injectionPatterns !== void 0) {
-    return `${rawData.injectionPatterns}/${rawData.totalClasses} classes use DI`;
+    return `${String(rawData.injectionPatterns)}/${String(rawData.totalClasses)} classes use DI`;
   }
   if (key === "structureClarityScore" && rawData.deepDirectories !== void 0) {
-    return `${rawData.deepDirectories} of ${rawData.totalDirectories} dirs exceed recommended depth`;
+    return `${String(rawData.deepDirectories)} of ${String(rawData.totalDirectories)} dirs exceed recommended depth`;
   }
   if (key === "apiClarityScore" && rawData.untypedExports !== void 0) {
-    return `${rawData.untypedExports} of ${rawData.totalExports} exports lack type annotations`;
+    return `${String(rawData.untypedExports)} of ${String(rawData.totalExports)} exports lack type annotations`;
   }
   if (key === "graphStabilityScore") {
-    return `${rawData.score}/100`;
+    return `${String(rawData.score)}/100`;
   }
   return void 0;
 }
@@ -4503,7 +4649,7 @@ function buildStandardToolScore(params) {
     score,
     rawMetrics: {
       ...rawData,
-      rating: rating || rawData.rating
+      rating: rating || String(rawData.rating)
     },
     factors,
     recommendations: recs