@aiready/cli 0.10.6 → 0.12.1

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/cli@0.10.5 build /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.12.0 build /Users/pengcao/projects/aiready/packages/cli
 > tsup src/index.ts src/cli.ts --format cjs,esm
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -10,7 +10,7 @@
 CJS Build start
 ESM Build start
 
- WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]                9:38:48 pm
+ WARN  ▲ [WARNING] "import.meta" is not available with the "cjs" output format and will be empty [empty-import-meta]               10:34:27 am
 
     src/cli.ts:25:31:
       25 │   return dirname(fileURLToPath(import.meta.url));
@@ -20,10 +20,10 @@
 
 
 
-CJS dist/index.js 16.55 KB
-CJS dist/cli.js   95.60 KB
-CJS ⚡️ Build success in 31ms
+CJS dist/cli.js   66.96 KB
+CJS dist/index.js 8.21 KB
+CJS ⚡️ Build success in 87ms
 ESM dist/index.mjs          170.00 B
-ESM dist/cli.mjs            77.38 KB
-ESM dist/chunk-VQCWYJYJ.mjs 14.49 KB
-ESM ⚡️ Build success in 31ms
+ESM dist/cli.mjs            56.79 KB
+ESM dist/chunk-LTUQDJPO.mjs 7.08 KB
+ESM ⚡️ Build success in 87ms

package/.turbo/turbo-lint.log

@@ -1,5 +1,13 @@
 
 
-> @aiready/cli@0.9.41 lint /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.10.6 lint /Users/pengcao/projects/aiready/packages/cli
 > eslint src
 
+
+/Users/pengcao/projects/aiready/packages/cli/src/commands/scan.ts
+  15:3  warning  'calculateOverallScore' is defined but never used  @typescript-eslint/no-unused-vars
+  23:3  warning  'parseWeightString' is defined but never used      @typescript-eslint/no-unused-vars
+  28:8  warning  'ToolScoringOutput' is defined but never used      @typescript-eslint/no-unused-vars
+
+✖ 3 problems (0 errors, 3 warnings)
+

package/.turbo/turbo-test.log

@@ -1,16 +1,55 @@
 
 
-> @aiready/cli@0.10.5 test /Users/pengcao/projects/aiready/packages/cli
+> @aiready/cli@0.12.0 test /Users/pengcao/projects/aiready/packages/cli
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/cli
 
- ✓ src/__tests__/cli.test.ts (3 tests) 2ms
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: pattern-detect (patterns, duplicates, duplication)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: context-analyzer (context, fragmentation, budget)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: naming-consistency (consistency, naming, standards)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: ai-signal-clarity (ai-signal, clarity, hallucination)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: agent-grounding (agent-grounding, grounding, navigation)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: testability-index (testability, tests, verification)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: doc-drift (doc-drift, docs, jsdoc)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: dependency-health (deps, deps-health, packages)
+
+stdout | src/__tests__/cli.test.ts
+[ToolRegistry#0.43273800284035346] Registering tool: change-amplification (change-amp, change-amplification, coupling)
+
+stdout | src/__tests__/cli.test.ts > CLI Unified Analysis > should run unified analysis with both tools
+[ToolRegistry#0.43273800284035346] Registering tool: pattern-detect (patterns)
+[ToolRegistry#0.43273800284035346] Registering tool: context-analyzer (context)
+
+stdout | src/__tests__/cli.test.ts > CLI Unified Analysis > should run analysis with only patterns tool
+[ToolRegistry#0.43273800284035346] Registering tool: pattern-detect (patterns)
+[ToolRegistry#0.43273800284035346] Registering tool: context-analyzer (context)
+
+stdout | src/__tests__/cli.test.ts > CLI Unified Analysis > should run analysis with only context tool
+[ToolRegistry#0.43273800284035346] Registering tool: pattern-detect (patterns)
+[ToolRegistry#0.43273800284035346] Registering tool: context-analyzer (context)
+
+ ✓ src/__tests__/cli.test.ts (3 tests) 3ms
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  21:39:06
-   Duration  411ms (transform 80ms, setup 0ms, import 280ms, tests 2ms, environment 0ms)
+   Start at  10:34:45
+   Duration  536ms (transform 205ms, setup 0ms, import 411ms, tests 3ms, environment 0ms)
 
 [?25h

package/dist/chunk-LTUQDJPO.mjs

@@ -0,0 +1,229 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import {
+  ToolRegistry,
+  ToolName,
+  calculateOverallScore,
+  calculateTokenBudget
+} from "@aiready/core";
+import "@aiready/pattern-detect";
+import "@aiready/context-analyzer";
+import "@aiready/consistency";
+import "@aiready/ai-signal-clarity";
+import "@aiready/agent-grounding";
+import "@aiready/testability";
+import "@aiready/doc-drift";
+import "@aiready/deps";
+import "@aiready/change-amplification";
+var TOOL_PACKAGE_MAP = {
+  [ToolName.PatternDetect]: "@aiready/pattern-detect",
+  [ToolName.ContextAnalyzer]: "@aiready/context-analyzer",
+  [ToolName.NamingConsistency]: "@aiready/consistency",
+  [ToolName.AiSignalClarity]: "@aiready/ai-signal-clarity",
+  [ToolName.AgentGrounding]: "@aiready/agent-grounding",
+  [ToolName.TestabilityIndex]: "@aiready/testability",
+  [ToolName.DocDrift]: "@aiready/doc-drift",
+  [ToolName.DependencyHealth]: "@aiready/deps",
+  [ToolName.ChangeAmplification]: "@aiready/change-amplification",
+  // Aliases handled by registry
+  patterns: "@aiready/pattern-detect",
+  duplicates: "@aiready/pattern-detect",
+  context: "@aiready/context-analyzer",
+  fragmentation: "@aiready/context-analyzer",
+  consistency: "@aiready/consistency",
+  "naming-consistency": "@aiready/consistency",
+  "ai-signal": "@aiready/ai-signal-clarity",
+  "ai-signal-clarity": "@aiready/ai-signal-clarity",
+  grounding: "@aiready/agent-grounding",
+  "agent-grounding": "@aiready/agent-grounding",
+  testability: "@aiready/testability",
+  "testability-index": "@aiready/testability",
+  "doc-drift": "@aiready/doc-drift",
+  "deps-health": "@aiready/deps",
+  "dependency-health": "@aiready/deps",
+  "change-amp": "@aiready/change-amplification",
+  "change-amplification": "@aiready/change-amplification"
+};
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const requestedTools = options.tools || [
+    "patterns",
+    "context",
+    "consistency"
+  ];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: [],
+      executionTime: 0
+    }
+  };
+  for (const toolName of requestedTools) {
+    let provider = ToolRegistry.find(toolName);
+    if (!provider) {
+      const packageName = TOOL_PACKAGE_MAP[toolName] || (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
+      try {
+        await import(packageName);
+        provider = ToolRegistry.find(toolName);
+        if (provider) {
+          console.log(
+            `\u2705 Successfully loaded tool provider: ${toolName} from ${packageName}`
+          );
+        } else {
+          console.log(
+            `\u26A0\uFE0F Loaded ${packageName} but provider ${toolName} still not found in registry.`
+          );
+        }
+      } catch (err) {
+        console.log(
+          `\u274C Failed to dynamically load tool ${toolName} (${packageName}):`,
+          err.message
+        );
+      }
+    }
+    if (!provider) {
+      console.warn(
+        `\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`
+      );
+      continue;
+    }
+    try {
+      const output = await provider.analyze({
+        ...options,
+        onProgress: (processed, total, message) => {
+          if (options.progressCallback) {
+            options.progressCallback({
+              tool: provider.id,
+              processed,
+              total,
+              message
+            });
+          }
+        }
+      });
+      if (options.progressCallback) {
+        options.progressCallback({ tool: provider.id, data: output });
+      }
+      result[provider.id] = output;
+      result.summary.toolsRun.push(provider.id);
+      const issueCount = output.results.reduce(
+        (sum, file) => sum + (file.issues?.length || 0),
+        0
+      );
+      result.summary.totalIssues += issueCount;
+      if (provider.alias && Array.isArray(provider.alias)) {
+        for (const alias of provider.alias) {
+          if (!result[alias]) {
+            result[alias] = output;
+          }
+        }
+      }
+      const camelCaseId = provider.id.replace(
+        /-([a-z])/g,
+        (g) => g[1].toUpperCase()
+      );
+      if (camelCaseId !== provider.id && !result[camelCaseId]) {
+        result[camelCaseId] = output;
+      }
+    } catch (err) {
+      console.error(`\u274C Error running tool '${provider.id}':`, err);
+    }
+  }
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+async function scoreUnified(results, options) {
+  const toolScores = /* @__PURE__ */ new Map();
+  for (const toolId of results.summary.toolsRun) {
+    const provider = ToolRegistry.get(toolId);
+    if (!provider) continue;
+    const output = results[toolId];
+    if (!output) continue;
+    try {
+      const toolScore = provider.score(output, options);
+      if (!toolScore.tokenBudget) {
+        if (toolId === ToolName.PatternDetect && output.duplicates) {
+          const wastedTokens = output.duplicates.reduce(
+            (sum, d) => sum + (d.tokenCost || 0),
+            0
+          );
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: wastedTokens * 2,
+            wastedTokens: {
+              duplication: wastedTokens,
+              fragmentation: 0,
+              chattiness: 0
+            }
+          });
+        } else if (toolId === ToolName.ContextAnalyzer && output.summary) {
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: output.summary.totalTokens,
+            wastedTokens: {
+              duplication: 0,
+              fragmentation: output.summary.totalPotentialSavings || 0,
+              chattiness: 0
+            }
+          });
+        }
+      }
+      toolScores.set(toolId, toolScore);
+    } catch (err) {
+      console.error(`\u274C Error scoring tool '${toolId}':`, err);
+    }
+  }
+  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 calculateOverallScore(toolScores, options, void 0);
+}
+function generateUnifiedSummary(result) {
+  const { summary } = result;
+  let output = `\u{1F680} AIReady Analysis Complete
+
+`;
+  output += `\u{1F4CA} Summary:
+`;
+  output += `   Tools run: ${summary.toolsRun.join(", ")}
+`;
+  output += `   Total issues found: ${summary.totalIssues}
+`;
+  output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
+
+`;
+  for (const provider of ToolRegistry.getAll()) {
+    const toolResult = result[provider.id];
+    if (toolResult) {
+      const issueCount = toolResult.results.reduce(
+        (sum, r) => sum + (r.issues?.length || 0),
+        0
+      );
+      output += `\u2022 ${provider.id}: ${issueCount} issues
+`;
+    }
+  }
+  return output;
+}
+
+export {
+  __require,
+  analyzeUnified,
+  scoreUnified,
+  generateUnifiedSummary
+};

package/dist/chunk-N56YAZVN.mjs

@@ -0,0 +1,194 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import {
+  ToolRegistry,
+  ToolName,
+  calculateOverallScore,
+  calculateTokenBudget
+} from "@aiready/core";
+var TOOL_PACKAGE_MAP = {
+  [ToolName.PatternDetect]: "@aiready/pattern-detect",
+  [ToolName.ContextAnalyzer]: "@aiready/context-analyzer",
+  [ToolName.NamingConsistency]: "@aiready/consistency",
+  [ToolName.AiSignalClarity]: "@aiready/ai-signal-clarity",
+  [ToolName.AgentGrounding]: "@aiready/agent-grounding",
+  [ToolName.TestabilityIndex]: "@aiready/testability",
+  [ToolName.DocDrift]: "@aiready/doc-drift",
+  [ToolName.DependencyHealth]: "@aiready/deps",
+  [ToolName.ChangeAmplification]: "@aiready/change-amplification",
+  // Aliases handled by registry
+  patterns: "@aiready/pattern-detect",
+  context: "@aiready/context-analyzer",
+  consistency: "@aiready/consistency"
+};
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const requestedTools = options.tools || [
+    "patterns",
+    "context",
+    "consistency"
+  ];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: [],
+      executionTime: 0
+    }
+  };
+  for (const toolName of requestedTools) {
+    let provider = ToolRegistry.find(toolName);
+    if (!provider) {
+      const packageName = TOOL_PACKAGE_MAP[toolName] || (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
+      try {
+        await import(packageName);
+        provider = ToolRegistry.find(toolName);
+        if (provider) {
+          console.log(
+            `\u2705 Successfully loaded tool provider: ${toolName} from ${packageName}`
+          );
+        } else {
+          console.log(
+            `\u26A0\uFE0F Loaded ${packageName} but provider ${toolName} still not found in registry.`
+          );
+        }
+      } catch (err) {
+        console.log(
+          `\u274C Failed to dynamically load tool ${toolName} (${packageName}):`,
+          err.message
+        );
+      }
+    }
+    if (!provider) {
+      console.warn(
+        `\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`
+      );
+      continue;
+    }
+    try {
+      const output = await provider.analyze(options);
+      if (options.progressCallback) {
+        options.progressCallback({ tool: provider.id, data: output });
+      }
+      result[provider.id] = output;
+      result.summary.toolsRun.push(provider.id);
+      const issueCount = output.results.reduce(
+        (sum, file) => sum + (file.issues?.length || 0),
+        0
+      );
+      result.summary.totalIssues += issueCount;
+      if (provider.alias && Array.isArray(provider.alias)) {
+        for (const alias of provider.alias) {
+          if (!result[alias]) {
+            result[alias] = output;
+          }
+        }
+      }
+      const camelCaseId = provider.id.replace(
+        /-([a-z])/g,
+        (g) => g[1].toUpperCase()
+      );
+      if (camelCaseId !== provider.id && !result[camelCaseId]) {
+        result[camelCaseId] = output;
+      }
+    } catch (err) {
+      console.error(`\u274C Error running tool '${provider.id}':`, err);
+    }
+  }
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+async function scoreUnified(results, options) {
+  const toolScores = /* @__PURE__ */ new Map();
+  for (const toolId of results.summary.toolsRun) {
+    const provider = ToolRegistry.get(toolId);
+    if (!provider) continue;
+    const output = results[toolId];
+    if (!output) continue;
+    try {
+      const toolScore = provider.score(output, options);
+      if (!toolScore.tokenBudget) {
+        if (toolId === ToolName.PatternDetect && output.duplicates) {
+          const wastedTokens = output.duplicates.reduce(
+            (sum, d) => sum + (d.tokenCost || 0),
+            0
+          );
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: wastedTokens * 2,
+            wastedTokens: {
+              duplication: wastedTokens,
+              fragmentation: 0,
+              chattiness: 0
+            }
+          });
+        } else if (toolId === ToolName.ContextAnalyzer && output.summary) {
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: output.summary.totalTokens,
+            wastedTokens: {
+              duplication: 0,
+              fragmentation: output.summary.totalPotentialSavings || 0,
+              chattiness: 0
+            }
+          });
+        }
+      }
+      toolScores.set(toolId, toolScore);
+    } catch (err) {
+      console.error(`\u274C Error scoring tool '${toolId}':`, err);
+    }
+  }
+  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 calculateOverallScore(toolScores, options, void 0);
+}
+function generateUnifiedSummary(result) {
+  const { summary } = result;
+  let output = `\u{1F680} AIReady Analysis Complete
+
+`;
+  output += `\u{1F4CA} Summary:
+`;
+  output += `   Tools run: ${summary.toolsRun.join(", ")}
+`;
+  output += `   Total issues found: ${summary.totalIssues}
+`;
+  output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
+
+`;
+  for (const provider of ToolRegistry.getAll()) {
+    const toolResult = result[provider.id];
+    if (toolResult) {
+      const issueCount = toolResult.results.reduce(
+        (sum, r) => sum + (r.issues?.length || 0),
+        0
+      );
+      output += `\u2022 ${provider.id}: ${issueCount} issues
+`;
+    }
+  }
+  return output;
+}
+
+export {
+  __require,
+  analyzeUnified,
+  scoreUnified,
+  generateUnifiedSummary
+};

package/dist/chunk-YBZKPKW3.mjs

@@ -0,0 +1,161 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import {
+  ToolRegistry,
+  ToolName,
+  calculateOverallScore,
+  calculateTokenBudget
+} from "@aiready/core";
+var TOOL_PACKAGE_MAP = {
+  [ToolName.PatternDetect]: "@aiready/pattern-detect",
+  [ToolName.ContextAnalyzer]: "@aiready/context-analyzer",
+  [ToolName.NamingConsistency]: "@aiready/consistency",
+  [ToolName.AiSignalClarity]: "@aiready/ai-signal-clarity",
+  [ToolName.AgentGrounding]: "@aiready/agent-grounding",
+  [ToolName.TestabilityIndex]: "@aiready/testability",
+  [ToolName.DocDrift]: "@aiready/doc-drift",
+  [ToolName.DependencyHealth]: "@aiready/deps",
+  [ToolName.ChangeAmplification]: "@aiready/change-amplification",
+  // Aliases handled by registry
+  "patterns": "@aiready/pattern-detect",
+  "context": "@aiready/context-analyzer",
+  "consistency": "@aiready/consistency"
+};
+async function analyzeUnified(options) {
+  const startTime = Date.now();
+  const requestedTools = options.tools || ["patterns", "context", "consistency"];
+  const result = {
+    summary: {
+      totalIssues: 0,
+      toolsRun: [],
+      executionTime: 0
+    }
+  };
+  for (const toolName of requestedTools) {
+    let provider = ToolRegistry.find(toolName);
+    if (!provider) {
+      const packageName = TOOL_PACKAGE_MAP[toolName] || (toolName.startsWith("@aiready/") ? toolName : `@aiready/${toolName}`);
+      try {
+        await import(packageName);
+        provider = ToolRegistry.find(toolName);
+        if (provider) {
+          console.log(`\u2705 Successfully loaded tool provider: ${toolName} from ${packageName}`);
+        } else {
+          console.log(`\u26A0\uFE0F Loaded ${packageName} but provider ${toolName} still not found in registry.`);
+        }
+      } catch (err) {
+        console.log(`\u274C Failed to dynamically load tool ${toolName} (${packageName}):`, err.message);
+      }
+    }
+    if (!provider) {
+      console.warn(`\u26A0\uFE0F  Warning: Tool provider for '${toolName}' not found. Skipping.`);
+      continue;
+    }
+    try {
+      const output = await provider.analyze(options);
+      if (options.progressCallback) {
+        options.progressCallback({ tool: provider.id, data: output });
+      }
+      result[provider.id] = output;
+      result.summary.toolsRun.push(provider.id);
+      const issueCount = output.results.reduce(
+        (sum, file) => sum + (file.issues?.length || 0),
+        0
+      );
+      result.summary.totalIssues += issueCount;
+      if (provider.id === ToolName.PatternDetect) result.patternDetect = output;
+      if (provider.id === ToolName.ContextAnalyzer) result.contextAnalyzer = output;
+    } catch (err) {
+      console.error(`\u274C Error running tool '${provider.id}':`, err);
+    }
+  }
+  result.summary.executionTime = Date.now() - startTime;
+  return result;
+}
+async function scoreUnified(results, options) {
+  const toolScores = /* @__PURE__ */ new Map();
+  for (const toolId of results.summary.toolsRun) {
+    const provider = ToolRegistry.get(toolId);
+    if (!provider) continue;
+    const output = results[toolId];
+    if (!output) continue;
+    try {
+      const toolScore = provider.score(output, options);
+      if (!toolScore.tokenBudget) {
+        if (toolId === ToolName.PatternDetect && output.duplicates) {
+          const wastedTokens = output.duplicates.reduce(
+            (sum, d) => sum + (d.tokenCost || 0),
+            0
+          );
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: wastedTokens * 2,
+            wastedTokens: { duplication: wastedTokens, fragmentation: 0, chattiness: 0 }
+          });
+        } else if (toolId === ToolName.ContextAnalyzer && output.summary) {
+          toolScore.tokenBudget = calculateTokenBudget({
+            totalContextTokens: output.summary.totalTokens,
+            wastedTokens: { duplication: 0, fragmentation: output.summary.totalPotentialSavings || 0, chattiness: 0 }
+          });
+        }
+      }
+      toolScores.set(toolId, toolScore);
+    } catch (err) {
+      console.error(`\u274C Error scoring tool '${toolId}':`, err);
+    }
+  }
+  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 calculateOverallScore(toolScores, options, void 0);
+}
+function generateUnifiedSummary(result) {
+  const { summary } = result;
+  let output = `\u{1F680} AIReady Analysis Complete
+
+`;
+  output += `\u{1F4CA} Summary:
+`;
+  output += `   Tools run: ${summary.toolsRun.join(", ")}
+`;
+  output += `   Total issues found: ${summary.totalIssues}
+`;
+  output += `   Execution time: ${(summary.executionTime / 1e3).toFixed(2)}s
+
+`;
+  for (const provider of ToolRegistry.getAll()) {
+    const toolResult = result[provider.id];
+    if (toolResult) {
+      const issueCount = toolResult.results.reduce(
+        (sum, r) => sum + (r.issues?.length || 0),
+        0
+      );
+      output += `\u2022 ${provider.id}: ${issueCount} issues
+`;
+    }
+  }
+  return output;
+}
+
+export {
+  __require,
+  analyzeUnified,
+  scoreUnified,
+  generateUnifiedSummary
+};