@aiready/core 0.23.15 → 0.23.20

package/dist/index.js

@@ -91,6 +91,7 @@ __export(index_exports, {
   calculateConceptCohesion: () => calculateConceptCohesion,
   calculateDebtInterest: () => calculateDebtInterest,
   calculateDependencyHealth: () => calculateDependencyHealth,
+  calculateDetailedTokenROI: () => calculateDetailedTokenROI,
   calculateDocDrift: () => calculateDocDrift,
   calculateExtendedFutureProofScore: () => calculateExtendedFutureProofScore,
   calculateFutureProofScore: () => calculateFutureProofScore,
@@ -119,7 +120,12 @@ __export(index_exports, {
   formatHours: () => formatHours,
   formatScore: () => formatScore,
   formatToolScore: () => formatToolScore,
+  generateCompleteReport: () => generateCompleteReport,
   generateHTML: () => generateHTML,
+  generateReportFooter: () => generateReportFooter,
+  generateReportHead: () => generateReportHead,
+  generateStatCards: () => generateStatCards,
+  generateTable: () => generateTable,
   generateValueChain: () => generateValueChain,
   getElapsedTime: () => getElapsedTime,
   getFileCommitTimestamps: () => getFileCommitTimestamps,
@@ -128,9 +134,12 @@ __export(index_exports, {
   getLineRangeLastModifiedCached: () => getLineRangeLastModifiedCached,
   getModelPreset: () => getModelPreset,
   getParser: () => getParser,
+  getPriorityIcon: () => getPriorityIcon,
   getProjectSizeTier: () => getProjectSizeTier,
   getRating: () => getRating,
   getRatingDisplay: () => getRatingDisplay,
+  getRatingEmoji: () => getRatingEmoji,
+  getRatingLabel: () => getRatingLabel,
   getRatingSlug: () => getRatingSlug,
   getRatingWithContext: () => getRatingWithContext,
   getRecommendedThreshold: () => getRecommendedThreshold,
@@ -143,6 +152,7 @@ __export(index_exports, {
   getSeverityLevel: () => getSeverityLevel,
   getSeverityValue: () => getSeverityValue,
   getSupportedLanguages: () => getSupportedLanguages,
+  getToolEmoji: () => getToolEmoji,
   getToolWeight: () => getToolWeight,
   getWasmPath: () => getWasmPath,
   groupIssuesByFile: () => groupIssuesByFile,
@@ -172,12 +182,71 @@ __export(index_exports, {
   setupParser: () => setupParser,
   severityToAnnotationLevel: () => severityToAnnotationLevel,
   validateSpokeOutput: () => validateSpokeOutput,
-  validateWithSchema: () => validateWithSchema
+  validateWithSchema: () => validateWithSchema,
+  wrapInCard: () => wrapInCard
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/types/schema.ts
+// src/types/business.ts
 var import_zod = require("zod");
+var LeadSource = /* @__PURE__ */ ((LeadSource2) => {
+  LeadSource2["ClawMoreHero"] = "clawmore-hero";
+  LeadSource2["ClawMoreWaitlist"] = "clawmore-waitlist";
+  LeadSource2["ClawMoreBeta"] = "clawmore-beta";
+  LeadSource2["AiReadyPlatform"] = "aiready-platform";
+  return LeadSource2;
+})(LeadSource || {});
+var LeadSourceSchema = import_zod.z.nativeEnum(LeadSource);
+var LeadSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  email: import_zod.z.string().email(),
+  name: import_zod.z.string().min(1),
+  interest: import_zod.z.string().default("General"),
+  notes: import_zod.z.string().optional(),
+  timestamp: import_zod.z.string().datetime(),
+  source: LeadSourceSchema,
+  status: import_zod.z.enum(["new", "contacted", "qualified", "converted", "archived"]).default("new")
+});
+var LeadSubmissionSchema = LeadSchema.omit({
+  id: true,
+  timestamp: true,
+  status: true
+});
+var ManagedAccountSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  // Internal UUID
+  accountId: import_zod.z.string(),
+  // AWS Account ID
+  userId: import_zod.z.string(),
+  // Owner (caopengau@gmail.com)
+  stripeSubscriptionId: import_zod.z.string(),
+  // AI Token Management
+  tokenStrategy: import_zod.z.enum(["managed", "byok"]).default("managed"),
+  byokConfig: import_zod.z.object({
+    openaiKey: import_zod.z.string().optional(),
+    anthropicKey: import_zod.z.string().optional(),
+    openrouterKey: import_zod.z.string().optional()
+  }).optional(),
+  // Financials (in cents)
+  baseFeeCents: import_zod.z.number().default(2900),
+  includedComputeCents: import_zod.z.number().default(1500),
+  // $15.00 AWS included
+  includedTokenCents: import_zod.z.number().default(500),
+  // $5.00 Managed Tokens included
+  // Pre-paid Balance (credits)
+  prepaidTokenBalanceCents: import_zod.z.number().default(0),
+  // Users buy these in $10 packs
+  currentMonthlyTokenSpendCents: import_zod.z.number().default(0),
+  // Governance
+  status: import_zod.z.enum(["provisioning", "active", "warning", "quarantined", "suspended"]).default("provisioning"),
+  lastCostSyncAt: import_zod.z.string().datetime().optional(),
+  region: import_zod.z.string().default("ap-southeast-2"),
+  // Alerting thresholds (percentage of includedComputeCents)
+  alertThresholds: import_zod.z.array(import_zod.z.number()).default([50, 80, 100, 150])
+});
+
+// src/types/enums.ts
+var import_zod2 = require("zod");
 var Severity = /* @__PURE__ */ ((Severity2) => {
   Severity2["Critical"] = "critical";
   Severity2["Major"] = "major";
@@ -185,7 +254,7 @@ var Severity = /* @__PURE__ */ ((Severity2) => {
   Severity2["Info"] = "info";
   return Severity2;
 })(Severity || {});
-var SeveritySchema = import_zod.z.nativeEnum(Severity);
+var SeveritySchema = import_zod2.z.nativeEnum(Severity);
 var ToolName = /* @__PURE__ */ ((ToolName3) => {
   ToolName3["PatternDetect"] = "pattern-detect";
   ToolName3["ContextAnalyzer"] = "context-analyzer";
@@ -202,7 +271,7 @@ var ToolName = /* @__PURE__ */ ((ToolName3) => {
   ToolName3["SemanticDistance"] = "semantic-distance";
   return ToolName3;
 })(ToolName || {});
-var ToolNameSchema = import_zod.z.nativeEnum(ToolName);
+var ToolNameSchema = import_zod2.z.nativeEnum(ToolName);
 var FRIENDLY_TOOL_NAMES = {
   ["pattern-detect" /* PatternDetect */]: "Semantic Duplicates",
   ["context-analyzer" /* ContextAnalyzer */]: "Context Fragmentation",
@@ -239,14 +308,14 @@ var IssueType = /* @__PURE__ */ ((IssueType2) => {
   IssueType2["ChangeAmplification"] = "change-amplification";
   return IssueType2;
 })(IssueType || {});
-var IssueTypeSchema = import_zod.z.nativeEnum(IssueType);
+var IssueTypeSchema = import_zod2.z.nativeEnum(IssueType);
 var AnalysisStatus = /* @__PURE__ */ ((AnalysisStatus2) => {
   AnalysisStatus2["Processing"] = "processing";
   AnalysisStatus2["Completed"] = "completed";
   AnalysisStatus2["Failed"] = "failed";
   return AnalysisStatus2;
 })(AnalysisStatus || {});
-var AnalysisStatusSchema = import_zod.z.nativeEnum(AnalysisStatus);
+var AnalysisStatusSchema = import_zod2.z.nativeEnum(AnalysisStatus);
 var ModelTier = /* @__PURE__ */ ((ModelTier2) => {
   ModelTier2["Compact"] = "compact";
   ModelTier2["Standard"] = "standard";
@@ -254,192 +323,149 @@ var ModelTier = /* @__PURE__ */ ((ModelTier2) => {
   ModelTier2["Frontier"] = "frontier";
   return ModelTier2;
 })(ModelTier || {});
-var ModelTierSchema = import_zod.z.nativeEnum(ModelTier);
-var LocationSchema = import_zod.z.object({
-  file: import_zod.z.string(),
-  line: import_zod.z.number(),
-  column: import_zod.z.number().optional(),
-  endLine: import_zod.z.number().optional(),
-  endColumn: import_zod.z.number().optional()
+var ModelTierSchema = import_zod2.z.nativeEnum(ModelTier);
+
+// src/types/common.ts
+var import_zod3 = require("zod");
+var LocationSchema = import_zod3.z.object({
+  file: import_zod3.z.string(),
+  line: import_zod3.z.number(),
+  column: import_zod3.z.number().optional(),
+  endLine: import_zod3.z.number().optional(),
+  endColumn: import_zod3.z.number().optional()
 });
-var IssueSchema = import_zod.z.object({
+
+// src/types/schemas/issue.ts
+var import_zod4 = require("zod");
+var IssueSchema = import_zod4.z.object({
   type: IssueTypeSchema,
   severity: SeveritySchema,
-  message: import_zod.z.string(),
+  message: import_zod4.z.string(),
   location: LocationSchema,
-  suggestion: import_zod.z.string().optional()
+  suggestion: import_zod4.z.string().optional()
 });
-var MetricsSchema = import_zod.z.object({
-  tokenCost: import_zod.z.number().optional(),
-  complexityScore: import_zod.z.number().optional(),
-  consistencyScore: import_zod.z.number().optional(),
-  docFreshnessScore: import_zod.z.number().optional(),
+
+// src/types/schemas/metrics.ts
+var import_zod5 = require("zod");
+var MetricsSchema = import_zod5.z.object({
+  tokenCost: import_zod5.z.number().optional(),
+  complexityScore: import_zod5.z.number().optional(),
+  consistencyScore: import_zod5.z.number().optional(),
+  docFreshnessScore: import_zod5.z.number().optional(),
   // AI agent readiness metrics (v0.12+)
-  aiSignalClarityScore: import_zod.z.number().optional(),
-  agentGroundingScore: import_zod.z.number().optional(),
-  testabilityScore: import_zod.z.number().optional(),
-  docDriftScore: import_zod.z.number().optional(),
-  dependencyHealthScore: import_zod.z.number().optional(),
+  aiSignalClarityScore: import_zod5.z.number().optional(),
+  agentGroundingScore: import_zod5.z.number().optional(),
+  testabilityScore: import_zod5.z.number().optional(),
+  docDriftScore: import_zod5.z.number().optional(),
+  dependencyHealthScore: import_zod5.z.number().optional(),
   modelContextTier: ModelTierSchema.optional(),
   // Business value metrics
-  estimatedMonthlyCost: import_zod.z.number().optional(),
-  estimatedDeveloperHours: import_zod.z.number().optional(),
-  comprehensionDifficultyIndex: import_zod.z.number().optional(),
+  estimatedMonthlyCost: import_zod5.z.number().optional(),
+  estimatedDeveloperHours: import_zod5.z.number().optional(),
+  comprehensionDifficultyIndex: import_zod5.z.number().optional(),
   // Extended metrics for specific spokes
-  totalSymbols: import_zod.z.number().optional(),
-  totalExports: import_zod.z.number().optional()
+  totalSymbols: import_zod5.z.number().optional(),
+  totalExports: import_zod5.z.number().optional()
 });
-var AnalysisResultSchema = import_zod.z.object({
-  fileName: import_zod.z.string(),
-  issues: import_zod.z.array(IssueSchema),
+
+// src/types/schemas/report.ts
+var import_zod6 = require("zod");
+var AnalysisResultSchema = import_zod6.z.object({
+  fileName: import_zod6.z.string(),
+  issues: import_zod6.z.array(IssueSchema),
   metrics: MetricsSchema
 });
-var SpokeSummarySchema = import_zod.z.object({
-  totalFiles: import_zod.z.number().optional(),
-  totalIssues: import_zod.z.number().optional(),
-  criticalIssues: import_zod.z.number().optional(),
-  majorIssues: import_zod.z.number().optional(),
-  score: import_zod.z.number().optional()
-}).catchall(import_zod.z.any());
-var SpokeOutputSchema = import_zod.z.object({
-  results: import_zod.z.array(AnalysisResultSchema),
+var SpokeSummarySchema = import_zod6.z.object({
+  totalFiles: import_zod6.z.number().optional(),
+  totalIssues: import_zod6.z.number().optional(),
+  criticalIssues: import_zod6.z.number().optional(),
+  majorIssues: import_zod6.z.number().optional(),
+  score: import_zod6.z.number().optional()
+}).catchall(import_zod6.z.any());
+var SpokeOutputSchema = import_zod6.z.object({
+  results: import_zod6.z.array(AnalysisResultSchema),
   summary: SpokeSummarySchema,
-  metadata: import_zod.z.object({
-    toolName: import_zod.z.string(),
-    version: import_zod.z.string().optional(),
-    timestamp: import_zod.z.string().optional(),
-    config: import_zod.z.any().optional()
-  }).catchall(import_zod.z.any()).optional()
+  metadata: import_zod6.z.object({
+    toolName: import_zod6.z.string(),
+    version: import_zod6.z.string().optional(),
+    timestamp: import_zod6.z.string().optional(),
+    config: import_zod6.z.any().optional()
+  }).catchall(import_zod6.z.any()).optional()
 });
-var UnifiedReportSchema = import_zod.z.object({
-  summary: import_zod.z.object({
-    totalFiles: import_zod.z.number(),
-    totalIssues: import_zod.z.number(),
-    criticalIssues: import_zod.z.number(),
-    majorIssues: import_zod.z.number(),
-    businessImpact: import_zod.z.object({
-      estimatedMonthlyWaste: import_zod.z.number().optional(),
-      potentialSavings: import_zod.z.number().optional(),
-      productivityHours: import_zod.z.number().optional()
+var UnifiedReportSchema = import_zod6.z.object({
+  summary: import_zod6.z.object({
+    totalFiles: import_zod6.z.number(),
+    totalIssues: import_zod6.z.number(),
+    criticalIssues: import_zod6.z.number(),
+    majorIssues: import_zod6.z.number(),
+    businessImpact: import_zod6.z.object({
+      estimatedMonthlyWaste: import_zod6.z.number().optional(),
+      potentialSavings: import_zod6.z.number().optional(),
+      productivityHours: import_zod6.z.number().optional()
     }).optional()
   }),
-  results: import_zod.z.array(AnalysisResultSchema),
-  scoring: import_zod.z.object({
-    overall: import_zod.z.number(),
-    rating: import_zod.z.string(),
-    timestamp: import_zod.z.string(),
-    breakdown: import_zod.z.array(
-      import_zod.z.object({
-        toolName: import_zod.z.union([ToolNameSchema, import_zod.z.string()]),
-        score: import_zod.z.number()
-      }).catchall(import_zod.z.any())
+  results: import_zod6.z.array(AnalysisResultSchema),
+  scoring: import_zod6.z.object({
+    overall: import_zod6.z.number(),
+    rating: import_zod6.z.string(),
+    timestamp: import_zod6.z.string(),
+    breakdown: import_zod6.z.array(
+      import_zod6.z.object({
+        toolName: import_zod6.z.union([ToolNameSchema, import_zod6.z.string()]),
+        score: import_zod6.z.number()
+      }).catchall(import_zod6.z.any())
     )
   }).optional()
-}).catchall(import_zod.z.any());
-var AIReadyConfigSchema = import_zod.z.object({
+}).catchall(import_zod6.z.any());
+
+// src/types/schemas/config.ts
+var import_zod7 = require("zod");
+var AIReadyConfigSchema = import_zod7.z.object({
   /** Target score threshold (0-100) */
-  threshold: import_zod.z.number().optional(),
+  threshold: import_zod7.z.number().optional(),
   /** Files or directories to include in scan */
-  include: import_zod.z.array(import_zod.z.string()).optional(),
+  include: import_zod7.z.array(import_zod7.z.string()).optional(),
   /** Files or directories to exclude from scan */
-  exclude: import_zod.z.array(import_zod.z.string()).optional(),
+  exclude: import_zod7.z.array(import_zod7.z.string()).optional(),
   /** Scan-specific configuration */
-  scan: import_zod.z.object({
-    include: import_zod.z.array(import_zod.z.string()).optional(),
-    exclude: import_zod.z.array(import_zod.z.string()).optional(),
-    parallel: import_zod.z.boolean().optional(),
-    deep: import_zod.z.boolean().optional(),
-    tools: import_zod.z.array(import_zod.z.string()).optional()
+  scan: import_zod7.z.object({
+    include: import_zod7.z.array(import_zod7.z.string()).optional(),
+    exclude: import_zod7.z.array(import_zod7.z.string()).optional(),
+    parallel: import_zod7.z.boolean().optional(),
+    deep: import_zod7.z.boolean().optional(),
+    tools: import_zod7.z.array(import_zod7.z.string()).optional()
   }).optional(),
   /** Output-specific configuration */
-  output: import_zod.z.object({
+  output: import_zod7.z.object({
     /** Output format (json, console, html) */
-    format: import_zod.z.enum(["json", "console", "html"]).optional(),
+    format: import_zod7.z.enum(["json", "console", "html"]).optional(),
     /** Output file path */
-    path: import_zod.z.string().optional(),
+    path: import_zod7.z.string().optional(),
     /** Output directory */
-    saveTo: import_zod.z.string().optional(),
+    saveTo: import_zod7.z.string().optional(),
     /** Whether to show score breakdown in console */
-    showBreakdown: import_zod.z.boolean().optional(),
+    showBreakdown: import_zod7.z.boolean().optional(),
     /** Baseline report to compare against */
-    compareBaseline: import_zod.z.string().optional()
+    compareBaseline: import_zod7.z.string().optional()
   }).optional(),
   /** Tool-specific configuration overrides (Strictly ToolName -> Config) */
-  tools: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
+  tools: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.any()).optional(),
   /** Scoring profile and weights */
-  scoring: import_zod.z.object({
+  scoring: import_zod7.z.object({
     /** Name of the scoring profile (e.g. "strict", "balanced") */
-    profile: import_zod.z.string().optional(),
+    profile: import_zod7.z.string().optional(),
     /** Custom weights for tools and metrics */
-    weights: import_zod.z.record(import_zod.z.string(), import_zod.z.number()).optional()
+    weights: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.number()).optional()
   }).optional(),
   /** Visualizer settings (interactive graph) */
-  visualizer: import_zod.z.object({
-    groupingDirs: import_zod.z.array(import_zod.z.string()).optional(),
-    graph: import_zod.z.object({
-      maxNodes: import_zod.z.number().optional(),
-      maxEdges: import_zod.z.number().optional()
+  visualizer: import_zod7.z.object({
+    groupingDirs: import_zod7.z.array(import_zod7.z.string()).optional(),
+    graph: import_zod7.z.object({
+      maxNodes: import_zod7.z.number().optional(),
+      maxEdges: import_zod7.z.number().optional()
     }).optional()
   }).optional()
-}).catchall(import_zod.z.any());
-
-// src/types/business.ts
-var import_zod2 = require("zod");
-var LeadSource = /* @__PURE__ */ ((LeadSource2) => {
-  LeadSource2["ClawMoreHero"] = "clawmore-hero";
-  LeadSource2["ClawMoreWaitlist"] = "clawmore-waitlist";
-  LeadSource2["ClawMoreBeta"] = "clawmore-beta";
-  LeadSource2["AiReadyPlatform"] = "aiready-platform";
-  return LeadSource2;
-})(LeadSource || {});
-var LeadSourceSchema = import_zod2.z.nativeEnum(LeadSource);
-var LeadSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  email: import_zod2.z.string().email(),
-  name: import_zod2.z.string().min(1),
-  interest: import_zod2.z.string().default("General"),
-  notes: import_zod2.z.string().optional(),
-  timestamp: import_zod2.z.string().datetime(),
-  source: LeadSourceSchema,
-  status: import_zod2.z.enum(["new", "contacted", "qualified", "converted", "archived"]).default("new")
-});
-var LeadSubmissionSchema = LeadSchema.omit({
-  id: true,
-  timestamp: true,
-  status: true
-});
-var ManagedAccountSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  // Internal UUID
-  accountId: import_zod2.z.string(),
-  // AWS Account ID
-  userId: import_zod2.z.string(),
-  // Owner (caopengau@gmail.com)
-  stripeSubscriptionId: import_zod2.z.string(),
-  // AI Token Management
-  tokenStrategy: import_zod2.z.enum(["managed", "byok"]).default("managed"),
-  byokConfig: import_zod2.z.object({
-    openaiKey: import_zod2.z.string().optional(),
-    anthropicKey: import_zod2.z.string().optional(),
-    openrouterKey: import_zod2.z.string().optional()
-  }).optional(),
-  // Financials (in cents)
-  baseFeeCents: import_zod2.z.number().default(2900),
-  includedComputeCents: import_zod2.z.number().default(1500),
-  // $15.00 AWS included
-  includedTokenCents: import_zod2.z.number().default(500),
-  // $5.00 Managed Tokens included
-  // Pre-paid Balance (credits)
-  prepaidTokenBalanceCents: import_zod2.z.number().default(0),
-  // Users buy these in $10 packs
-  currentMonthlyTokenSpendCents: import_zod2.z.number().default(0),
-  // Governance
-  status: import_zod2.z.enum(["provisioning", "active", "warning", "quarantined", "suspended"]).default("provisioning"),
-  lastCostSyncAt: import_zod2.z.string().datetime().optional(),
-  region: import_zod2.z.string().default("ap-southeast-2"),
-  // Alerting thresholds (percentage of includedComputeCents)
-  alertThresholds: import_zod2.z.array(import_zod2.z.number()).default([50, 80, 100, 150])
-});
+}).catchall(import_zod7.z.any());
 
 // src/types.ts
 var GLOBAL_INFRA_OPTIONS = [
@@ -3553,13 +3579,84 @@ function generateHTML(graph) {
 </html>`;
 }
 
-// src/scoring.ts
-var RecommendationPriority = /* @__PURE__ */ ((RecommendationPriority2) => {
-  RecommendationPriority2["High"] = "high";
-  RecommendationPriority2["Medium"] = "medium";
-  RecommendationPriority2["Low"] = "low";
-  return RecommendationPriority2;
-})(RecommendationPriority || {});
+// src/utils/html-report-builder.ts
+function generateReportHead(title) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 2rem; background-color: #f9f9f9; }
+    h1, h2, h3 { color: #1a1a1a; border-bottom: 2px solid #eaeaea; padding-bottom: 0.5rem; }
+    .card { background: white; padding: 1.5rem; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); margin-bottom: 2rem; border: 1px solid #eaeaea; }
+    .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+    .stat-card { background: #fff; padding: 1rem; border-radius: 6px; text-align: center; border: 1px solid #eaeaea; }
+    .stat-value { font-size: 1.8rem; font-weight: bold; color: #2563eb; }
+    .stat-label { font-size: 0.875rem; color: #666; text-transform: uppercase; }
+    table { width: 100%; border-collapse: collapse; margin-top: 1rem; background: white; border-radius: 4px; overflow: hidden; }
+    th, td { text-align: left; padding: 0.875rem 1rem; border-bottom: 1px solid #eaeaea; }
+    th { background-color: #f8fafc; font-weight: 600; color: #475569; }
+    tr:last-child td { border-bottom: none; }
+    .critical { color: #dc2626; font-weight: bold; }
+    .major { color: #ea580c; font-weight: bold; }
+    .minor { color: #2563eb; }
+    code { background: #f1f5f9; padding: 0.2rem 0.4rem; border-radius: 4px; font-size: 0.875rem; color: #334155; }
+    .footer { margin-top: 4rem; text-align: center; color: #94a3b8; font-size: 0.875rem; }
+  </style>
+</head>`;
+}
+function generateStatCards(cards) {
+  const cardsHtml = cards.map(
+    (card) => `
+    <div class="stat-card">
+      <div class="stat-value"${card.color ? ` style="color: ${card.color}"` : ""}>${card.value}</div>
+      <div class="stat-label">${card.label}</div>
+    </div>`
+  ).join("");
+  return `<div class="stats">${cardsHtml}</div>`;
+}
+function generateTable(config) {
+  const headersHtml = config.headers.map((h) => `<th>${h}</th>`).join("");
+  const rowsHtml = config.rows.map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join("")}</tr>`).join("");
+  return `<table>
+    <thead><tr>${headersHtml}</tr></thead>
+    <tbody>${rowsHtml}</tbody>
+  </table>`;
+}
+function generateReportFooter(options) {
+  const versionText = options.version ? ` v${options.version}` : "";
+  const links = [];
+  if (options.packageUrl) {
+    links.push(`<a href="${options.packageUrl}">Star us on GitHub</a>`);
+  }
+  if (options.bugUrl) {
+    links.push(`<a href="${options.bugUrl}">Report it here</a>`);
+  }
+  const linksHtml = links.length ? links.map((l) => `<p>Like AIReady? ${l}</p>`).join("\n    ") : "";
+  return `<div class="footer">
+    <p>Generated by <strong>@aiready/${options.packageName}</strong>${versionText}</p>
+    ${linksHtml}
+  </div>`;
+}
+function wrapInCard(content, title) {
+  const titleHtml = title ? `<h2>${title}</h2>` : "";
+  return `<div class="card">
+    ${titleHtml}
+    ${content}
+  </div>`;
+}
+function generateCompleteReport(options, bodyContent) {
+  return `${generateReportHead(options.title)}
+<body>
+  ${bodyContent}
+  ${generateReportFooter(options)}
+</body>
+</html>`;
+}
+
+// src/utils/rating-helpers.ts
 var ReadinessRating = /* @__PURE__ */ ((ReadinessRating2) => {
   ReadinessRating2["Excellent"] = "Excellent";
   ReadinessRating2["Good"] = "Good";
@@ -3568,6 +3665,59 @@ var ReadinessRating = /* @__PURE__ */ ((ReadinessRating2) => {
   ReadinessRating2["Critical"] = "Critical";
   return ReadinessRating2;
 })(ReadinessRating || {});
+function getRatingLabel(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 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 getRatingEmoji(score) {
+  if (score >= 90) return "\u2705";
+  if (score >= 75) return "\u{1F44D}";
+  if (score >= 60) return "\u{1F44C}";
+  if (score >= 40) return "\u{1F528}";
+  return "\u{1F6A8}";
+}
+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) {
+  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 */;
+}
+
+// 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,
@@ -3746,20 +3896,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;
@@ -3882,20 +4018,52 @@ var DEFAULT_COST_CONFIG = {
   developerCount: 5,
   daysPerMonth: 30
 };
-function calculateMonthlyCost(tokenWaste, config = {}) {
-  const multiplier = tokenWaste > 5e4 ? 5 : tokenWaste > 1e4 ? 3.5 : 2.5;
+function calculateMonthlyCost(tokenWaste, config = {}, options) {
+  const baseMultiplier = tokenWaste > 5e4 ? 5 : tokenWaste > 1e4 ? 3.5 : 2.5;
+  const contextMultiplier = options?.avgContextBudget ? options.avgContextBudget / Math.max(1, tokenWaste) : baseMultiplier;
+  const fragRatio = options?.fragmentationScore ?? 0.3;
+  const dupRatio = 1 - fragRatio;
   const budget = calculateTokenBudget({
-    totalContextTokens: tokenWaste * multiplier,
+    totalContextTokens: tokenWaste * contextMultiplier,
     wastedTokens: {
-      duplication: tokenWaste * 0.7,
-      fragmentation: tokenWaste * 0.3,
+      duplication: tokenWaste * dupRatio * (options?.potentialSavings ? 1.2 : 1),
+      fragmentation: tokenWaste * fragRatio,
       chattiness: 0.1 * tokenWaste
-      // Added baseline chattiness
     }
   });
-  const preset = getModelPreset("gpt-5.4-mini");
+  const preset = getModelPreset("claude-3.5-sonnet");
   return estimateCostFromBudget(budget, preset, config);
 }
+function calculateDetailedTokenROI(params) {
+  const {
+    totalTokens,
+    avgContextBudget,
+    potentialSavings,
+    fragmentationScore,
+    developerCount,
+    queriesPerDevPerDay = 60
+  } = params;
+  const budget = calculateTokenBudget({
+    totalContextTokens: avgContextBudget,
+    wastedTokens: {
+      duplication: potentialSavings * 0.8,
+      // 80% of potential savings are duplication-based
+      fragmentation: totalTokens * fragmentationScore * 0.5,
+      // fragmentation impact
+      chattiness: totalTokens * 0.1
+    }
+  });
+  const model = getModelPreset("claude-3.5-sonnet");
+  const cost = estimateCostFromBudget(budget, model, {
+    developerCount,
+    queriesPerDevPerDay
+  });
+  return {
+    monthlySavings: Math.round(cost.total),
+    contextTaxPerDev: Math.round(cost.total / (developerCount || 1) * 100) / 100,
+    efficiencyGain: Math.round(budget.efficiencyRatio * 100) / 100
+  };
+}
 function calculateTokenBudget(params) {
   const { totalContextTokens, wastedTokens } = params;
   const estimatedResponseTokens = params.estimatedResponseTokens ?? totalContextTokens * 0.2;
@@ -5423,6 +5591,7 @@ function emitIssuesAsAnnotations(issues) {
   calculateConceptCohesion,
   calculateDebtInterest,
   calculateDependencyHealth,
+  calculateDetailedTokenROI,
   calculateDocDrift,
   calculateExtendedFutureProofScore,
   calculateFutureProofScore,
@@ -5451,7 +5620,12 @@ function emitIssuesAsAnnotations(issues) {
   formatHours,
   formatScore,
   formatToolScore,
+  generateCompleteReport,
   generateHTML,
+  generateReportFooter,
+  generateReportHead,
+  generateStatCards,
+  generateTable,
   generateValueChain,
   getElapsedTime,
   getFileCommitTimestamps,
@@ -5460,9 +5634,12 @@ function emitIssuesAsAnnotations(issues) {
   getLineRangeLastModifiedCached,
   getModelPreset,
   getParser,
+  getPriorityIcon,
   getProjectSizeTier,
   getRating,
   getRatingDisplay,
+  getRatingEmoji,
+  getRatingLabel,
   getRatingSlug,
   getRatingWithContext,
   getRecommendedThreshold,
@@ -5475,6 +5652,7 @@ function emitIssuesAsAnnotations(issues) {
   getSeverityLevel,
   getSeverityValue,
   getSupportedLanguages,
+  getToolEmoji,
   getToolWeight,
   getWasmPath,
   groupIssuesByFile,
@@ -5504,5 +5682,6 @@ function emitIssuesAsAnnotations(issues) {
   setupParser,
   severityToAnnotationLevel,
   validateSpokeOutput,
-  validateWithSchema
+  validateWithSchema,
+  wrapInCard
 });