@aiready/cli 0.9.45 → 0.9.46

package/dist/cli.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   __require,
-  analyzeUnified
-} from "./chunk-LLJMKNBI.mjs";
+  analyzeUnified,
+  scoreUnified
+} from "./chunk-6FOVC2OE.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -20,7 +21,6 @@ import {
   handleCLIError as handleCLIError2,
   getElapsedTime,
   resolveOutputPath,
-  calculateOverallScore,
   formatScore,
   formatToolScore,
   calculateTokenBudget,
@@ -28,7 +28,6 @@ import {
   getModelPreset,
   getRating,
   getRatingDisplay,
-  parseWeightString,
   getRepoMetadata
 } from "@aiready/core";
 
@@ -160,9 +159,7 @@ function truncateArray(arr, cap = 8) {
 import fs from "fs";
 import { resolve as resolvePath2 } from "path";
 import chalk2 from "chalk";
-import {
-  handleCLIError
-} from "@aiready/core";
+import { handleCLIError } from "@aiready/core";
 async function uploadAction(file, options) {
   const startTime = Date.now();
   const filePath = resolvePath2(process.cwd(), file);
@@ -170,8 +167,14 @@ async function uploadAction(file, options) {
   const apiKey = options.apiKey || process.env.AIREADY_API_KEY;
   if (!apiKey) {
     console.error(chalk2.red("\u274C API Key is required for upload."));
-    console.log(chalk2.dim("   Set AIREADY_API_KEY environment variable or use --api-key flag."));
-    console.log(chalk2.dim("   Get an API key from https://getaiready.dev/dashboard"));
+    console.log(
+      chalk2.dim(
+        "   Set AIREADY_API_KEY environment variable or use --api-key flag."
+      )
+    );
+    console.log(
+      chalk2.dim("   Get an API key from https://getaiready.dev/dashboard")
+    );
     process.exit(1);
   }
   if (!fs.existsSync(filePath)) {
@@ -180,13 +183,16 @@ async function uploadAction(file, options) {
   }
   try {
     console.log(chalk2.blue(`\u{1F680} Uploading report to ${serverUrl}...`));
-    const reportData = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    console.log(chalk2.dim(`   Reading report from ${filePath}...`));
+    const reportContent = fs.readFileSync(filePath, "utf-8");
+    const reportData = JSON.parse(reportContent);
+    console.log(chalk2.dim(`   Successfully parsed report JSON.`));
     const repoId = options.repoId || reportData.repository?.repoId;
     const res = await fetch(`${serverUrl}/api/analysis/upload`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
+        Authorization: `Bearer ${apiKey}`
       },
       body: JSON.stringify({
         data: reportData,
@@ -194,11 +200,36 @@ async function uploadAction(file, options) {
         // Might be null, server will handle mapping
       })
     });
-    const result = await res.json();
+    const contentType = res.headers.get("content-type");
+    let result = {};
+    if (contentType?.includes("application/json")) {
+      result = await res.json();
+    } else {
+      const text = await res.text();
+      result = { error: text || res.statusText };
+    }
     if (!res.ok) {
-      console.error(chalk2.red(`\u274C Upload failed: ${result.error || res.statusText}`));
+      console.error(
+        chalk2.red(`\u274C Upload failed: ${result.error || res.statusText}`)
+      );
+      if (contentType?.includes("text/html")) {
+        console.log(
+          chalk2.yellow(
+            "   Note: Received an HTML response. This often indicates a redirect (e.g., to a login page) or a server error."
+          )
+        );
+        if (result.error?.includes("Redirecting")) {
+          console.log(
+            chalk2.dim(
+              "   Detected redirect. Check if the API endpoint requires authentication or has changed."
+            )
+          );
+        }
+      }
       if (res.status === 401) {
-        console.log(chalk2.dim("   Hint: Your API key may be invalid or expired."));
+        console.log(
+          chalk2.dim("   Hint: Your API key may be invalid or expired.")
+        );
       }
       process.exit(1);
     }
@@ -606,246 +637,136 @@ async function scanAction(directory, options) {
     void elapsedTime;
     let scoringResult;
     if (options.score || finalOptions.scoring?.showBreakdown) {
-      const toolScores = /* @__PURE__ */ new Map();
-      if (results.duplicates) {
-        const { calculatePatternScore } = await import("@aiready/pattern-detect");
+      scoringResult = await scoreUnified(results, finalOptions);
+      console.log(chalk3.bold("\n\u{1F4CA} AI Readiness Overall Score"));
+      console.log(`  ${formatScore(scoringResult)}`);
+      if (options.compareTo) {
         try {
-          const patternScore = calculatePatternScore(
-            results.duplicates,
-            results.patterns?.length || 0
+          const prevReportStr = readFileSync2(
+            resolvePath3(process.cwd(), options.compareTo),
+            "utf8"
           );
-          const wastedTokens = results.duplicates.reduce((sum, d) => sum + (d.tokenCost || 0), 0);
-          patternScore.tokenBudget = calculateTokenBudget({
-            totalContextTokens: wastedTokens * 2,
-            // Estimated context
-            wastedTokens: {
-              duplication: wastedTokens,
-              fragmentation: 0,
-              chattiness: 0
-            }
-          });
-          toolScores.set("pattern-detect", patternScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.context) {
-        const { generateSummary: genContextSummary, calculateContextScore } = await import("@aiready/context-analyzer");
-        try {
-          const ctxSummary = genContextSummary(results.context);
-          const contextScore = calculateContextScore(ctxSummary);
-          contextScore.tokenBudget = calculateTokenBudget({
-            totalContextTokens: ctxSummary.totalTokens,
-            wastedTokens: {
-              duplication: 0,
-              fragmentation: ctxSummary.totalPotentialSavings || 0,
-              chattiness: 0
-            }
-          });
-          toolScores.set("context-analyzer", contextScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.consistency) {
-        const { calculateConsistencyScore } = await import("@aiready/consistency");
-        try {
-          const issues = results.consistency.results?.flatMap((r) => r.issues) || [];
-          const totalFiles = results.consistency.summary?.filesAnalyzed || 0;
-          const consistencyScore = calculateConsistencyScore(
-            issues,
-            totalFiles
-          );
-          toolScores.set("consistency", consistencyScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.aiSignalClarity) {
-        const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
-        try {
-          const hrScore = calculateAiSignalClarityScore(
-            results.aiSignalClarity
-          );
-          toolScores.set("ai-signal-clarity", hrScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.grounding) {
-        const { calculateGroundingScore } = await import("@aiready/agent-grounding");
-        try {
-          const agScore = calculateGroundingScore(results.grounding);
-          toolScores.set("agent-grounding", agScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.testability) {
-        const { calculateTestabilityScore } = await import("@aiready/testability");
-        try {
-          const tbScore = calculateTestabilityScore(results.testability);
-          toolScores.set("testability", tbScore);
-        } catch (err) {
-          void err;
-        }
-      }
-      if (results.docDrift) {
-        toolScores.set("doc-drift", {
-          toolName: "doc-drift",
-          score: results.docDrift.summary.score,
-          rawMetrics: results.docDrift.rawData,
-          factors: [],
-          recommendations: (results.docDrift.recommendations || []).map(
-            (action) => ({
-              action,
-              estimatedImpact: 5,
-              priority: "medium"
-            })
-          )
-        });
-      }
-      if (results.deps) {
-        toolScores.set("dependency-health", {
-          toolName: "dependency-health",
-          score: results.deps.summary.score,
-          rawMetrics: results.deps.rawData,
-          factors: [],
-          recommendations: (results.deps.recommendations || []).map(
-            (action) => ({
-              action,
-              estimatedImpact: 5,
-              priority: "medium"
-            })
-          )
-        });
-      }
-      if (results.changeAmplification) {
-        toolScores.set("change-amplification", {
-          toolName: "change-amplification",
-          score: results.changeAmplification.summary.score,
-          rawMetrics: results.changeAmplification.rawData,
-          factors: [],
-          recommendations: (results.changeAmplification.recommendations || []).map((action) => ({
-            action,
-            estimatedImpact: 5,
-            priority: "medium"
-          }))
-        });
-      }
-      const cliWeights = parseWeightString(options.weights);
-      if (toolScores.size > 0) {
-        scoringResult = calculateOverallScore(
-          toolScores,
-          finalOptions,
-          cliWeights.size ? cliWeights : void 0
-        );
-        console.log(chalk3.bold("\n\u{1F4CA} AI Readiness Overall Score"));
-        console.log(`  ${formatScore(scoringResult)}`);
-        if (options.compareTo) {
-          try {
-            const prevReportStr = readFileSync2(
-              resolvePath3(process.cwd(), options.compareTo),
-              "utf8"
-            );
-            const prevReport = JSON.parse(prevReportStr);
-            const prevScore = prevReport.scoring?.score || prevReport.scoring?.overallScore;
-            if (typeof prevScore === "number") {
-              const diff = scoringResult.overall - prevScore;
-              const diffStr = diff > 0 ? `+${diff}` : String(diff);
-              console.log();
-              if (diff > 0) {
-                console.log(
-                  chalk3.green(
-                    `  \u{1F4C8} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
-                  )
-                );
-              } else if (diff < 0) {
-                console.log(
-                  chalk3.red(
-                    `  \u{1F4C9} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
-                  )
-                );
-              } else {
-                console.log(
-                  chalk3.blue(
-                    `  \u2796 Trend: No change compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
-                  )
-                );
-              }
-              scoringResult.trend = {
-                previousScore: prevScore,
-                difference: diff
-              };
+          const prevReport = JSON.parse(prevReportStr);
+          const prevScore = prevReport.scoring?.score || prevReport.scoring?.overallScore;
+          if (typeof prevScore === "number") {
+            const diff = scoringResult.overall - prevScore;
+            const diffStr = diff > 0 ? `+${diff}` : String(diff);
+            console.log();
+            if (diff > 0) {
+              console.log(
+                chalk3.green(
+                  `  \u{1F4C8} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
+                )
+              );
+            } else if (diff < 0) {
+              console.log(
+                chalk3.red(
+                  `  \u{1F4C9} Trend: ${diffStr} compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
+                )
+              );
             } else {
               console.log(
-                chalk3.yellow(
-                  `
-  \u26A0\uFE0F  Previous report at ${options.compareTo} does not contain an overall score.`
+                chalk3.blue(
+                  `  \u2796 Trend: No change compared to ${options.compareTo} (${prevScore} \u2192 ${scoringResult.overall})`
                 )
               );
             }
-          } catch (e) {
-            void e;
+            scoringResult.trend = {
+              previousScore: prevScore,
+              difference: diff
+            };
+          } else {
             console.log(
               chalk3.yellow(
                 `
-  \u26A0\uFE0F  Could not read or parse previous report at ${options.compareTo}.`
+  \u26A0\uFE0F  Previous report at ${options.compareTo} does not contain an overall score.`
               )
             );
           }
+        } catch (e) {
+          void e;
+          console.log(
+            chalk3.yellow(
+              `
+  \u26A0\uFE0F  Could not read or parse previous report at ${options.compareTo}.`
+            )
+          );
         }
-        const totalWastedDuplication = Array.from(toolScores.values()).reduce((sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.duplication || 0), 0);
-        const totalWastedFragmentation = Array.from(toolScores.values()).reduce((sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.fragmentation || 0), 0);
-        const totalContext = Math.max(...Array.from(toolScores.values()).map((s) => s.tokenBudget?.totalContextTokens || 0));
-        if (totalContext > 0) {
-          const unifiedBudget = calculateTokenBudget({
-            totalContextTokens: totalContext,
-            wastedTokens: {
-              duplication: totalWastedDuplication,
-              fragmentation: totalWastedFragmentation,
-              chattiness: 0
-            }
-          });
-          const targetModel = options.model || "claude-4.6";
-          const modelPreset = getModelPreset(targetModel);
-          const costEstimate = estimateCostFromBudget(unifiedBudget, modelPreset);
-          const barWidth = 20;
-          const filled = Math.round(unifiedBudget.efficiencyRatio * barWidth);
-          const bar = chalk3.green("\u2588".repeat(filled)) + chalk3.dim("\u2591".repeat(barWidth - filled));
-          console.log(chalk3.bold("\n\u{1F4CA} AI Token Budget Analysis (v0.13)"));
-          console.log(`  Efficiency: [${bar}] ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`);
-          console.log(`  Total Context: ${chalk3.bold(unifiedBudget.totalContextTokens.toLocaleString())} tokens`);
-          console.log(`  Wasted Tokens: ${chalk3.red(unifiedBudget.wastedTokens.total.toLocaleString())} (${(unifiedBudget.wastedTokens.total / unifiedBudget.totalContextTokens * 100).toFixed(1)}%)`);
-          console.log(`  Waste Breakdown:`);
-          console.log(`    \u2022 Duplication:   ${unifiedBudget.wastedTokens.bySource.duplication.toLocaleString()} tokens`);
-          console.log(`    \u2022 Fragmentation: ${unifiedBudget.wastedTokens.bySource.fragmentation.toLocaleString()} tokens`);
-          console.log(`  Potential Savings: ${chalk3.green(unifiedBudget.potentialRetrievableTokens.toLocaleString())} tokens retrievable`);
-          console.log(`
-  Est. Monthly Cost (${modelPreset.name}): ${chalk3.bold("$" + costEstimate.total)} [range: $${costEstimate.range[0]}-$${costEstimate.range[1]}]`);
-          scoringResult.tokenBudget = unifiedBudget;
-          scoringResult.costEstimate = {
-            model: modelPreset.name,
-            ...costEstimate
-          };
-        }
-        if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
-          console.log(chalk3.bold("\nTool breakdown:"));
+      }
+      const totalWastedDuplication = (scoringResult.breakdown || []).reduce(
+        (sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.duplication || 0),
+        0
+      );
+      const totalWastedFragmentation = (scoringResult.breakdown || []).reduce(
+        (sum, s) => sum + (s.tokenBudget?.wastedTokens.bySource.fragmentation || 0),
+        0
+      );
+      const totalContext = Math.max(
+        ...(scoringResult.breakdown || []).map(
+          (s) => s.tokenBudget?.totalContextTokens || 0
+        )
+      );
+      if (totalContext > 0) {
+        const unifiedBudget = calculateTokenBudget({
+          totalContextTokens: totalContext,
+          wastedTokens: {
+            duplication: totalWastedDuplication,
+            fragmentation: totalWastedFragmentation,
+            chattiness: 0
+          }
+        });
+        const targetModel = options.model || "claude-4.6";
+        const modelPreset = getModelPreset(targetModel);
+        const costEstimate = estimateCostFromBudget(unifiedBudget, modelPreset);
+        const barWidth = 20;
+        const filled = Math.round(unifiedBudget.efficiencyRatio * barWidth);
+        const bar = chalk3.green("\u2588".repeat(filled)) + chalk3.dim("\u2591".repeat(barWidth - filled));
+        console.log(chalk3.bold("\n\u{1F4CA} AI Token Budget Analysis (v0.13)"));
+        console.log(
+          `  Efficiency: [${bar}] ${(unifiedBudget.efficiencyRatio * 100).toFixed(0)}%`
+        );
+        console.log(
+          `  Total Context: ${chalk3.bold(unifiedBudget.totalContextTokens.toLocaleString())} tokens`
+        );
+        console.log(
+          `  Wasted Tokens: ${chalk3.red(unifiedBudget.wastedTokens.total.toLocaleString())} (${(unifiedBudget.wastedTokens.total / unifiedBudget.totalContextTokens * 100).toFixed(1)}%)`
+        );
+        console.log(`  Waste Breakdown:`);
+        console.log(
+          `    \u2022 Duplication:   ${unifiedBudget.wastedTokens.bySource.duplication.toLocaleString()} tokens`
+        );
+        console.log(
+          `    \u2022 Fragmentation: ${unifiedBudget.wastedTokens.bySource.fragmentation.toLocaleString()} tokens`
+        );
+        console.log(
+          `  Potential Savings: ${chalk3.green(unifiedBudget.potentialRetrievableTokens.toLocaleString())} tokens retrievable`
+        );
+        console.log(
+          `
+  Est. Monthly Cost (${modelPreset.name}): ${chalk3.bold("$" + costEstimate.total)} [range: $${costEstimate.range[0]}-$${costEstimate.range[1]}]`
+        );
+        scoringResult.tokenBudget = unifiedBudget;
+        scoringResult.costEstimate = {
+          model: modelPreset.name,
+          ...costEstimate
+        };
+      }
+      if (scoringResult.breakdown && scoringResult.breakdown.length > 0) {
+        console.log(chalk3.bold("\nTool breakdown:"));
+        scoringResult.breakdown.forEach((tool) => {
+          const rating = getRating(tool.score);
+          const rd = getRatingDisplay(rating);
+          console.log(
+            `  - ${tool.toolName}: ${tool.score}/100 (${rating}) ${rd.emoji}`
+          );
+        });
+        console.log();
+        if (finalOptions.scoring?.showBreakdown) {
+          console.log(chalk3.bold("Detailed tool breakdown:"));
           scoringResult.breakdown.forEach((tool) => {
-            const rating = getRating(tool.score);
-            const rd = getRatingDisplay(rating);
-            console.log(
-              `  - ${tool.toolName}: ${tool.score}/100 (${rating}) ${rd.emoji}`
-            );
+            console.log(formatToolScore(tool));
           });
           console.log();
-          if (finalOptions.scoring?.showBreakdown) {
-            console.log(chalk3.bold("Detailed tool breakdown:"));
-            scoringResult.breakdown.forEach((tool) => {
-              console.log(formatToolScore(tool));
-            });
-            console.log();
-          }
         }
       }
     }

package/dist/index.js

@@ -31,12 +31,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   analyzeUnified: () => analyzeUnified,
-  generateUnifiedSummary: () => generateUnifiedSummary
+  generateUnifiedSummary: () => generateUnifiedSummary,
+  scoreUnified: () => scoreUnified
 });
 module.exports = __toCommonJS(index_exports);
 var import_pattern_detect = require("@aiready/pattern-detect");
 var import_context_analyzer = require("@aiready/context-analyzer");
 var import_consistency = require("@aiready/consistency");
+var import_core = require("@aiready/core");
 var severityOrder = {
   critical: 4,
   major: 3,
@@ -211,6 +213,150 @@ async function analyzeUnified(options) {
   result.summary.executionTime = Date.now() - startTime;
   return result;
 }
+async function scoreUnified(results, options) {
+  const toolScores = /* @__PURE__ */ new Map();
+  if (results.duplicates) {
+    const { calculatePatternScore } = await import("@aiready/pattern-detect");
+    try {
+      const patternScore = calculatePatternScore(
+        results.duplicates,
+        results.patterns?.length || 0
+      );
+      const wastedTokens = results.duplicates.reduce(
+        (sum, d) => sum + (d.tokenCost || 0),
+        0
+      );
+      patternScore.tokenBudget = (0, import_core.calculateTokenBudget)({
+        totalContextTokens: wastedTokens * 2,
+        // Estimated context
+        wastedTokens: {
+          duplication: wastedTokens,
+          fragmentation: 0,
+          chattiness: 0
+        }
+      });
+      toolScores.set("pattern-detect", patternScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.context) {
+    const { generateSummary: genContextSummary, calculateContextScore } = await import("@aiready/context-analyzer");
+    try {
+      const ctxSummary = genContextSummary(results.context);
+      const contextScore = calculateContextScore(ctxSummary);
+      contextScore.tokenBudget = (0, import_core.calculateTokenBudget)({
+        totalContextTokens: ctxSummary.totalTokens,
+        wastedTokens: {
+          duplication: 0,
+          fragmentation: ctxSummary.totalPotentialSavings || 0,
+          chattiness: 0
+        }
+      });
+      toolScores.set("context-analyzer", contextScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.consistency) {
+    const { calculateConsistencyScore } = await import("@aiready/consistency");
+    try {
+      const issues = results.consistency.results?.flatMap((r) => r.issues) || [];
+      const totalFiles = results.consistency.summary?.filesAnalyzed || 0;
+      const consistencyScore = calculateConsistencyScore(issues, totalFiles);
+      toolScores.set("consistency", consistencyScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.aiSignalClarity) {
+    const { calculateAiSignalClarityScore } = await import("@aiready/ai-signal-clarity");
+    try {
+      const hrScore = calculateAiSignalClarityScore(results.aiSignalClarity);
+      toolScores.set("ai-signal-clarity", hrScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.grounding) {
+    const { calculateGroundingScore } = await import("@aiready/agent-grounding");
+    try {
+      const agScore = calculateGroundingScore(results.grounding);
+      toolScores.set("agent-grounding", agScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.testability) {
+    const { calculateTestabilityScore } = await import("@aiready/testability");
+    try {
+      const tbScore = calculateTestabilityScore(results.testability);
+      toolScores.set("testability", tbScore);
+    } catch (err) {
+      void err;
+    }
+  }
+  if (results.docDrift) {
+    toolScores.set("doc-drift", {
+      toolName: "doc-drift",
+      score: results.docDrift.summary.score,
+      rawMetrics: results.docDrift.rawData,
+      factors: [],
+      recommendations: (results.docDrift.recommendations || []).map(
+        (action) => ({
+          action,
+          estimatedImpact: 5,
+          priority: "medium"
+        })
+      )
+    });
+  }
+  if (results.deps) {
+    toolScores.set("dependency-health", {
+      toolName: "dependency-health",
+      score: results.deps.summary.score,
+      rawMetrics: results.deps.rawData,
+      factors: [],
+      recommendations: (results.deps.recommendations || []).map(
+        (action) => ({
+          action,
+          estimatedImpact: 5,
+          priority: "medium"
+        })
+      )
+    });
+  }
+  if (results.changeAmplification) {
+    toolScores.set("change-amplification", {
+      toolName: "change-amplification",
+      score: results.changeAmplification.summary.score,
+      rawMetrics: results.changeAmplification.rawData,
+      factors: [],
+      recommendations: (results.changeAmplification.recommendations || []).map(
+        (action) => ({
+          action,
+          estimatedImpact: 5,
+          priority: "medium"
+        })
+      )
+    });
+  }
+  if (toolScores.size === 0) {
+    return {
+      overall: 0,
+      rating: "Critical",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      toolsUsed: [],
+      breakdown: [],
+      calculation: {
+        formula: "0 / 0 = 0",
+        weights: {},
+        normalized: "0 / 0 = 0"
+      }
+    };
+  }
+  return (0, import_core.calculateOverallScore)(toolScores, options, void 0);
+}
 function generateUnifiedSummary(result) {
   const { summary } = result;
   let output = `\u{1F680} AIReady Analysis Complete
@@ -266,5 +412,6 @@ function generateUnifiedSummary(result) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   analyzeUnified,
-  generateUnifiedSummary
+  generateUnifiedSummary,
+  scoreUnified
 });

package/dist/index.mjs

@@ -1,8 +1,10 @@
 import {
   analyzeUnified,
-  generateUnifiedSummary
-} from "./chunk-LLJMKNBI.mjs";
+  generateUnifiedSummary,
+  scoreUnified
+} from "./chunk-6FOVC2OE.mjs";
 export {
   analyzeUnified,
-  generateUnifiedSummary
+  generateUnifiedSummary,
+  scoreUnified
 };