@chemx/starter-kit 26.9.9-786 → 26.9.11-362

package/cli/audit/metrics.js

@@ -0,0 +1,179 @@
+import { PILLARS } from './rules.js';
+
+export const calculateMolecularHealthScore = (violations, totalFiles) => {
+  if (totalFiles === 0) {
+    return { score: 100, grade: 'A+', label: 'Crystalline Molecular' };
+  }
+
+  let penalty = 0;
+  for (const v of violations) {
+    if (v.severity === 'CRITICAL') penalty += 8;
+    else if (v.severity === 'HIGH') penalty += 4;
+    else if (v.severity === 'MEDIUM') penalty += 2;
+    else if (v.severity === 'LOW') penalty += 1;
+  }
+
+  // Normalize penalty against codebase size
+  const scale = Math.max(1, Math.log10(totalFiles + 1));
+  const adjustedPenalty = penalty / scale;
+  const score = Math.max(0, Math.min(100, Math.round(100 - adjustedPenalty)));
+
+  let grade = 'F';
+  let label = 'Severe Context Rot';
+
+  if (score >= 95) {
+    grade = 'A+';
+    label = 'Crystalline Molecular';
+  } else if (score >= 90) {
+    grade = 'A';
+    label = 'Highly Modular';
+  } else if (score >= 80) {
+    grade = 'B';
+    label = 'Moderately Modular';
+  } else if (score >= 70) {
+    grade = 'C';
+    label = 'Monolithic Drift';
+  } else if (score >= 60) {
+    grade = 'D';
+    label = 'High Context Hazard';
+  }
+
+  return { score, grade, label };
+};
+
+export const calculatePillarBreakdown = (violations) => {
+  const breakdown = {};
+  for (const [key, name] of Object.entries(PILLARS)) {
+    breakdown[name] = {
+      pillarKey: key,
+      violations: 0,
+      critical: 0,
+      high: 0,
+      medium: 0,
+      low: 0,
+      status: 'PASSED'
+    };
+  }
+
+  for (const v of violations) {
+    const pillarName = v.pillar || PILLARS.PILLAR_1;
+    if (!breakdown[pillarName]) {
+      breakdown[pillarName] = {
+        pillarKey: 'UNKNOWN',
+        violations: 0,
+        critical: 0,
+        high: 0,
+        medium: 0,
+        low: 0,
+        status: 'PASSED'
+      };
+    }
+    const item = breakdown[pillarName];
+    item.violations += 1;
+    if (v.severity === 'CRITICAL') item.critical += 1;
+    else if (v.severity === 'HIGH') item.high += 1;
+    else if (v.severity === 'MEDIUM') item.medium += 1;
+    else if (v.severity === 'LOW') item.low += 1;
+  }
+
+  for (const item of Object.values(breakdown)) {
+    if (item.critical > 0) {
+      item.status = 'FAILED';
+    } else if (item.high > 0 || item.medium > 1) {
+      item.status = 'WARN';
+    } else {
+      item.status = 'PASSED';
+    }
+  }
+
+  return breakdown;
+};
+
+export const MODEL_PRICING_RATES = {
+  blended: { name: 'Frontier Blended ($3.00/1M)', costPerMillion: 3.0 },
+  claude: { name: 'Claude 3.5 Sonnet ($3.00/1M)', costPerMillion: 3.0 },
+  gpt4o: { name: 'GPT-4o ($2.50/1M)', costPerMillion: 2.5 }
+};
+
+export const calculateTokenBurnAnalytics = (fileStats, options = {}) => {
+  let totalRawChars = 0;
+  let excessChars = 0;
+
+  for (const f of fileStats) {
+    totalRawChars += f.charCount;
+    // Budget: 500 lines max for files (~18,000 chars), 100 lines for molecules (~3,600 chars)
+    const maxChars = f.isMolecule ? 3600 : 18000;
+    if (f.charCount > maxChars) {
+      excessChars += f.charCount - maxChars;
+    }
+  }
+
+  const estimatedTokens = Math.round(totalRawChars / 3.8);
+  const estimatedExcessTokens = Math.round(excessChars / 3.8);
+  const potentialSavingsPct = totalRawChars > 0
+    ? Math.min(85, Math.round((excessChars / totalRawChars) * 100))
+    : 0;
+
+  const resolveRiskLevel = (pct) => {
+    if (pct > 40) return 'HIGH';
+    if (pct > 15) return 'MODERATE';
+    return 'LOW';
+  };
+
+  const selectedModel = options?.model?.toLowerCase() || 'blended';
+  const modelConfig = MODEL_PRICING_RATES[selectedModel] || MODEL_PRICING_RATES.blended;
+  const costPerMillion = options?.costPerMillion ? Number(options.costPerMillion) : modelConfig.costPerMillion;
+
+  const excessCostPerPass = Number(((estimatedExcessTokens / 1000000) * costPerMillion).toFixed(3));
+  const weeklyWastePerDev = Number((excessCostPerPass * 20 * 5).toFixed(2));
+  const monthlyWastePerDev = Number((weeklyWastePerDev * 4).toFixed(2));
+
+  return {
+    estimatedTokens,
+    estimatedExcessTokens,
+    potentialSavingsPct,
+    riskLevel: resolveRiskLevel(potentialSavingsPct),
+    pricingModel: modelConfig.name,
+    costPerMillion,
+    excessCostPerPass,
+    weeklyWastePerDev,
+    monthlyWastePerDev
+  };
+};
+
+const resolveMonolithTierName = (lineCount) => {
+  if (lineCount >= 2000) return 'CRITICAL';
+  if (lineCount >= 1000) return 'SEVERE';
+  if (lineCount > 500) return 'WARNING';
+  return null;
+};
+
+export const calculateHotspots = (violations, fileStats, limit = 5) => {
+  const violationCountsByFile = {};
+  for (const v of violations) {
+    violationCountsByFile[v.filePath] = (violationCountsByFile[v.filePath] || 0) + 1;
+  }
+
+  const fileMap = {};
+  for (const f of fileStats) {
+    fileMap[f.relativePath] = f;
+  }
+
+  const scoredFiles = Object.entries(violationCountsByFile).map(([filePath, count]) => {
+    const stats = fileMap[filePath] || { lineCount: 0 };
+    const monolithTier = resolveMonolithTierName(stats.lineCount);
+
+    return {
+      filePath,
+      violationCount: count,
+      lineCount: stats.lineCount,
+      isMonolith: stats.lineCount > 500,
+      monolithTier
+    };
+  });
+
+  scoredFiles.sort((a, b) => b.violationCount - a.violationCount || b.lineCount - a.lineCount);
+  return scoredFiles.slice(0, limit);
+};
+
+export const calculateQuantumHealthScore = calculateMolecularHealthScore;

package/cli/audit/prompts.js

@@ -0,0 +1,174 @@
+const CYAN = '\x1b[38;2;98;201;255m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+export const buildGradeFPrompt = (report) => {
+  const { violations, hotspots } = report;
+  const critical = violations.filter((v) => v.severity === 'CRITICAL');
+  const extremeMonoliths = hotspots.filter((h) => h.lineCount >= 2000);
+
+  if (critical.length === 0 && extremeMonoliths.length === 0) return '';
+
+  const lines = [];
+  lines.push('Act as a Principal Systems Architect. Surgically refactor the following Grade F Critical Context Hazards in our codebase according to Chemical X Molecular Architecture Standards:\n');
+
+  if (extremeMonoliths.length > 0) {
+    lines.push('### EXTREME MONOLITHS (>= 2,000 LOC) : MONOLITH DECOMPOSITION');
+    extremeMonoliths.forEach((h, i) => {
+      lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines)`);
+      lines.push('   Action: Decompose this monolith into crystalline single-responsibility capsules (< 100 lines per molecule). Convert top-level view into a declarative Table-of-Contents view.');
+    });
+    lines.push('');
+  }
+
+  if (critical.length > 0) {
+    lines.push('### CRITICAL AST VIOLATIONS');
+    critical.forEach((v, i) => {
+      lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
+      lines.push(`   Hazard: ${v.hazard}`);
+      lines.push(`   Directive: ${v.directive}`);
+    });
+    lines.push('');
+  }
+
+  lines.push('### STRICT EXECUTION RULES:');
+  lines.push('1. Every new molecule component must stay under 100 lines.');
+  lines.push('2. Top-level page views must be 10-20 line declarative Table-of-Contents templates assembling components via named slots.');
+  lines.push('3. Zero synthetic or mock data: return live data or explicit empty states.');
+  lines.push('4. Zero render-hack setTimeout: replace with await nextTick() or flush: post.');
+  lines.push('5. Output surgical diffs or modular replacements. Preserve existing external exports.');
+
+  return lines.join('\n');
+};
+
+export const buildGradeDPrompt = (report) => {
+  const { violations, hotspots } = report;
+  const high = violations.filter((v) => v.severity === 'HIGH');
+  const severeMonoliths = hotspots.filter((h) => h.lineCount >= 1000 && h.lineCount < 2000);
+
+  if (high.length === 0 && severeMonoliths.length === 0) return '';
+
+  const lines = [];
+  lines.push('Act as a Principal Systems Architect. Refactor the following Grade D High-Severity Architectural Debts according to Chemical X Molecular Architecture Standards:\n');
+
+  if (severeMonoliths.length > 0) {
+    lines.push('### SEVERE MONOLITHS (1,000 - 1,999 LOC)');
+    severeMonoliths.forEach((h, i) => {
+      lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines)`);
+      lines.push('   Action: Extract sub-features into isolated molecule capsules (< 100 LOC) and domain composables.');
+    });
+    lines.push('');
+  }
+
+  if (high.length > 0) {
+    lines.push('### HIGH SEVERITY VIOLATIONS');
+    high.forEach((v, i) => {
+      lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
+      lines.push(`   Hazard: ${v.hazard}`);
+      lines.push(`   Directive: ${v.directive}`);
+    });
+    lines.push('');
+  }
+
+  lines.push('### STRICT EXECUTION RULES:');
+  lines.push('1. Hook Saturation: Extract component hooks into dedicated domain composables adhering to the 3-5 property return limit (State + Status + Actions).');
+  lines.push('2. Complex Control Flow: Break multi-clause conditionals into 2-stage atomic boolean variables with early-return guard clauses.');
+  lines.push('3. Zero breaking changes to caller APIs or existing props.');
+
+  return lines.join('\n');
+};
+
+export const buildGradeCPrompt = (report) => {
+  const { violations, hotspots } = report;
+  const medium = violations.filter((v) => v.severity === 'MEDIUM');
+  const warningMonoliths = hotspots.filter((h) => h.lineCount >= 500 && h.lineCount < 1000);
+
+  if (medium.length === 0 && warningMonoliths.length === 0) return '';
+
+  const lines = [];
+  lines.push('Act as a Senior Frontend Engineer. Refactor the following Grade C Medium-Severity Technical Debts according to Chemical X Molecular Architecture Standards:\n');
+
+  if (warningMonoliths.length > 0) {
+    lines.push('### WARNING MONOLITHS (500 - 999 LOC)');
+    warningMonoliths.forEach((h, i) => {
+      lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines)`);
+      lines.push('   Action: Bring file under 500 line budget by extracting helper functions, types, and child molecules.');
+    });
+    lines.push('');
+  }
+
+  if (medium.length > 0) {
+    lines.push('### MEDIUM SEVERITY VIOLATIONS');
+    medium.forEach((v, i) => {
+      lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
+      lines.push(`   Hazard: ${v.hazard}`);
+      lines.push(`   Directive: ${v.directive}`);
+    });
+    lines.push('');
+  }
+
+  lines.push('### STRICT EXECUTION RULES:');
+  lines.push('1. Zero raw inline styles: Replace style={{...}} with atom props, SCSS mixins (@include glass), or scoped BEM classes.');
+  lines.push('2. Extract anonymous inline callbacks into named functions before passing as props.');
+  lines.push('3. Co-locate granular types (*.d.ts) inside feature capsules (< 100 LOC). Avoid type monoliths.');
+
+  return lines.join('\n');
+};
+
+export const buildGradeBPrompt = (report) => {
+  const { violations } = report;
+  const low = violations.filter((v) => v.severity === 'LOW');
+
+  if (low.length === 0) return '';
+
+  const lines = [];
+  lines.push('Act as a Clean Code Specialist. Clean up the following Grade B Low-Severity Hygiene Issues according to Chemical X standards:\n');
+
+  lines.push('### LOW HYGIENE VIOLATIONS');
+  low.forEach((v, i) => {
+    lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
+    lines.push(`   Hazard: ${v.hazard}`);
+    lines.push(`   Directive: ${v.directive}`);
+  });
+  lines.push('');
+
+  lines.push('### STRICT EXECUTION RULES:');
+  lines.push('1. Typography Hygiene: Replace all em dashes with standard hyphens (-) or colons (:).');
+  lines.push('2. Logging Hygiene: Remove unguarded console.log calls or route through central debug proxy.');
+  lines.push('3. FontAwesome Compliance: Remove text-* utility classes from icons; use :color prop or inline CSS.');
+
+  return lines.join('\n');
+};
+
+export const buildMasterPrompt = (report) => {
+  const sections = [
+    buildGradeFPrompt(report),
+    buildGradeDPrompt(report),
+    buildGradeCPrompt(report),
+    buildGradeBPrompt(report)
+  ].filter(Boolean);
+
+  if (sections.length === 0) return '';
+
+  const header = `Act as a Principal Systems Architect. Execute a phased architectural refactoring of our codebase according to Chemical X Molecular Architecture Standards.\n\n`;
+  return header + sections.join('\n\n---\n\n');
+};
+
+export const formatPromptBox = (title, promptText) => {
+  if (!promptText) return '';
+
+  const lines = [];
+  lines.push(`\n   ${CYAN}┌────────────────────────────────────────────────────────────────────────┐${RESET}`);
+  lines.push(`   ${CYAN}│${RESET} ${BOLD}${title}${RESET}`);
+  lines.push(`   ${CYAN}│${RESET} ${DIM}Copy and paste the block below directly into Cursor / Claude / Windsurf:${RESET}`);
+  lines.push(`   ${CYAN}├────────────────────────────────────────────────────────────────────────┤${RESET}`);
+
+  const promptLines = promptText.split('\n');
+  for (const pl of promptLines) {
+    lines.push(`   ${CYAN}│${RESET} ${pl}`);
+  }
+
+  lines.push(`   ${CYAN}└────────────────────────────────────────────────────────────────────────┘${RESET}\n`);
+  return lines.join('\n');
+};

package/cli/audit/reporter-grades.js

@@ -0,0 +1,259 @@
+import {
+  buildGradeFPrompt,
+  buildGradeDPrompt,
+  buildGradeCPrompt,
+  buildGradeBPrompt,
+  formatPromptBox
+} from './prompts.js';
+import {
+  CYAN,
+  GREEN,
+  YELLOW,
+  RED,
+  ORANGE,
+  DIM,
+  BOLD,
+  RESET,
+  groupViolationsBySeverity
+} from './reporter-utils.js';
+
+export const formatGradeFSection = (report) => {
+  const { violations, hotspots, pillars } = report;
+  const { critical } = groupViolationsBySeverity(violations);
+  const extremeMonoliths = hotspots.filter((h) => h.lineCount >= 2000);
+  const failedPillars = Object.entries(pillars || {}).filter(([_, p]) => p.status === 'FAILED');
+  const lines = [];
+
+  lines.push('');
+  lines.push(`${RED}======================================================================${RESET}`);
+  lines.push(`${BOLD}${RED}   GRADE F : CRITICAL ARCHITECTURAL HAZARDS & EXTREME MONOLITHS${RESET}`);
+  lines.push(`${DIM}   Immediate action required: >2,000 LOC monoliths, render hacks, mock data${RESET}`);
+  lines.push(`${RED}======================================================================${RESET}`);
+  lines.push(`   Critical Violations:  ${critical.length > 0 ? `${RED}${BOLD}${critical.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`   Extreme Monoliths:    ${extremeMonoliths.length > 0 ? `${RED}${BOLD}${extremeMonoliths.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`   Failed Pillars:       ${failedPillars.length > 0 ? `${RED}${BOLD}${failedPillars.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`${RED}----------------------------------------------------------------------${RESET}`);
+
+  const totalGradeFItems = critical.length + extremeMonoliths.length + failedPillars.length;
+  if (totalGradeFItems === 0) {
+    lines.push(`\n   ${GREEN}✔ Outstanding! Zero Grade F hazards detected.${RESET}`);
+    lines.push(`   ${DIM}Codebase is free of extreme monoliths (>2k LOC) and critical violations.${RESET}`);
+  } else {
+    if (critical.length > 0) {
+      lines.push(`\n   ${BOLD}${RED}🚨 CRITICAL AST VIOLATIONS (${critical.length}):${RESET}`);
+      critical.forEach((v, idx) => {
+        lines.push(`   ${RED}[#${idx + 1} CRITICAL]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
+        lines.push(`      Hazard:    ${v.hazard}`);
+        lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
+      });
+    }
+
+    if (extremeMonoliths.length > 0) {
+      lines.push(`   ${BOLD}${RED}💣 EXTREME MONOLITHS (>= 2,000 LINES):${RESET}`);
+      lines.push(`   ${DIM}Massive token burn files causing severe context rot and agent hallucination.${RESET}`);
+      extremeMonoliths.forEach((h, idx) => {
+        lines.push(`   [#${idx + 1}] ${YELLOW}${h.filePath}${RESET} (${h.lineCount} lines, ${h.violationCount} hazards) ${RED}[EXTREME MONOLITH]${RESET}`);
+      });
+      lines.push('');
+    }
+
+    if (failedPillars.length > 0) {
+      lines.push(`   ${BOLD}${RED}🏛️  FAILED PILLARS (CRITICAL INFECTIONS):${RESET}`);
+      for (const [name, p] of failedPillars) {
+        lines.push(`   ✕ ${YELLOW}${name}${RESET}: ${p.violations} violations (${p.critical} Critical, ${p.high} High, ${p.medium} Med)`);
+      }
+      lines.push('');
+    }
+  }
+
+  const promptF = buildGradeFPrompt(report);
+  if (promptF) {
+    lines.push(formatPromptBox('🤖 AI AGENT REFACTORING PROMPT (GRADE F HAZARDS)', promptF));
+  }
+
+  lines.push(`${RED}======================================================================${RESET}\n`);
+  return lines.join('\n');
+};
+
+export const formatGradeDSection = (report) => {
+  const { violations, hotspots, pillars } = report;
+  const { high } = groupViolationsBySeverity(violations);
+  const severeMonoliths = hotspots.filter((h) => h.lineCount >= 1000 && h.lineCount < 2000);
+  const warnPillars = Object.entries(pillars || {}).filter(([_, p]) => p.status === 'WARN');
+  const lines = [];
+
+  lines.push('');
+  lines.push(`${ORANGE}======================================================================${RESET}`);
+  lines.push(`${BOLD}${ORANGE}   GRADE D : HIGH SEVERITY DEBTS & SEVERE MONOLITHS${RESET}`);
+  lines.push(`${DIM}   Refactoring priorities: 1,000 to 1,999 LOC files and hook saturation > 5${RESET}`);
+  lines.push(`${ORANGE}======================================================================${RESET}`);
+  lines.push(`   High Severity Debts:  ${high.length > 0 ? `${ORANGE}${BOLD}${high.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`   Severe Monoliths:     ${severeMonoliths.length > 0 ? `${ORANGE}${BOLD}${severeMonoliths.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`   Degraded Pillars:     ${warnPillars.length > 0 ? `${ORANGE}${BOLD}${warnPillars.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`${ORANGE}----------------------------------------------------------------------${RESET}`);
+
+  const totalGradeDItems = high.length + severeMonoliths.length + warnPillars.length;
+  if (totalGradeDItems === 0) {
+    lines.push(`\n   ${GREEN}✔ Zero Grade D debts detected.${RESET}`);
+    lines.push(`   ${DIM}No severe monoliths (1k-2k LOC) or saturated hook anti-patterns.${RESET}`);
+  } else {
+    if (high.length > 0) {
+      lines.push(`\n   ${BOLD}${ORANGE}⚠️  HIGH SEVERITY VIOLATIONS (${high.length}):${RESET}`);
+      high.forEach((v, idx) => {
+        lines.push(`   ${ORANGE}[#${idx + 1} HIGH]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
+        lines.push(`      Hazard:    ${v.hazard}`);
+        lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
+      });
+    }
+
+    if (severeMonoliths.length > 0) {
+      lines.push(`   ${BOLD}${ORANGE}🔥 SEVERE MONOLITHS (1,000 - 1,999 LINES):${RESET}`);
+      severeMonoliths.forEach((h, idx) => {
+        lines.push(`   [#${idx + 1}] ${YELLOW}${h.filePath}${RESET} (${h.lineCount} lines, ${h.violationCount} hazards) ${ORANGE}[SEVERE MONOLITH]${RESET}`);
+      });
+      lines.push('');
+    }
+
+    if (warnPillars.length > 0) {
+      lines.push(`   ${BOLD}${ORANGE}🏛️  DEGRADED PILLARS (MULTIPLE HIGH/MED DEBTS):${RESET}`);
+      for (const [name, p] of warnPillars) {
+        lines.push(`   ⚠ ${YELLOW}${name}${RESET}: ${p.violations} violations (${p.high} High, ${p.medium} Med)`);
+      }
+      lines.push('');
+    }
+  }
+
+  const promptD = buildGradeDPrompt(report);
+  if (promptD) {
+    lines.push(formatPromptBox('🤖 AI AGENT REFACTORING PROMPT (GRADE D DEBTS)', promptD));
+  }
+
+  lines.push(`${ORANGE}======================================================================${RESET}\n`);
+  return lines.join('\n');
+};
+
+export const formatGradeCSection = (report) => {
+  const { violations, hotspots } = report;
+  const { medium } = groupViolationsBySeverity(violations);
+  const warningMonoliths = hotspots.filter((h) => h.lineCount >= 500 && h.lineCount < 1000);
+  const lines = [];
+
+  lines.push('');
+  lines.push(`${CYAN}======================================================================${RESET}`);
+  lines.push(`${BOLD}${CYAN}   GRADE C : MEDIUM SEVERITY DEBTS & MONOLITHIC DRIFT${RESET}`);
+  lines.push(`${DIM}   Architecture debts: 500 to 999 LOC files and raw inline style attributes${RESET}`);
+  lines.push(`${CYAN}======================================================================${RESET}`);
+  lines.push(`   Medium Debts:         ${medium.length > 0 ? `${YELLOW}${BOLD}${medium.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`   Warning Monoliths:    ${warningMonoliths.length > 0 ? `${YELLOW}${BOLD}${warningMonoliths.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`${CYAN}----------------------------------------------------------------------${RESET}`);
+
+  const totalGradeCItems = medium.length + warningMonoliths.length;
+  if (totalGradeCItems === 0) {
+    lines.push(`\n   ${GREEN}✔ Zero Grade C debts detected.${RESET}`);
+    lines.push(`   ${DIM}All files remain under 500 lines with clean styling and handlers.${RESET}`);
+  } else {
+    if (medium.length > 0) {
+      lines.push(`\n   ${BOLD}${CYAN}⚡ MEDIUM SEVERITY VIOLATIONS (${medium.length}):${RESET}`);
+      medium.forEach((v, idx) => {
+        lines.push(`   ${YELLOW}[#${idx + 1} MED]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
+        lines.push(`      Hazard:    ${v.hazard}`);
+        lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
+      });
+    }
+
+    if (warningMonoliths.length > 0) {
+      lines.push(`   ${BOLD}${CYAN}⚠️  WARNING MONOLITHS (500 - 999 LINES):${RESET}`);
+      warningMonoliths.forEach((h, idx) => {
+        lines.push(`   [#${idx + 1}] ${YELLOW}${h.filePath}${RESET} (${h.lineCount} lines, ${h.violationCount} hazards) ${DIM}[MONOLITH WARNING]${RESET}`);
+      });
+      lines.push('');
+    }
+  }
+
+  const promptC = buildGradeCPrompt(report);
+  if (promptC) {
+    lines.push(formatPromptBox('🤖 AI AGENT REFACTORING PROMPT (GRADE C DEBTS)', promptC));
+  }
+
+  lines.push(`${CYAN}======================================================================${RESET}\n`);
+  return lines.join('\n');
+};
+
+export const formatGradeBSection = (report) => {
+  const { violations } = report;
+  const { low } = groupViolationsBySeverity(violations);
+  const lines = [];
+
+  lines.push('');
+  lines.push(`${YELLOW}======================================================================${RESET}`);
+  lines.push(`${BOLD}${YELLOW}   GRADE B : LOW SEVERITY HYGIENE & MINOR CODE SMELLS${RESET}`);
+  lines.push(`${DIM}   Hygiene & polish: Em dash typography leaks and unguarded console logging${RESET}`);
+  lines.push(`${YELLOW}======================================================================${RESET}`);
+  lines.push(`   Low Hygiene Issues:   ${low.length > 0 ? `${YELLOW}${BOLD}${low.length}${RESET}` : `${GREEN}0${RESET}`}`);
+  lines.push(`${YELLOW}----------------------------------------------------------------------${RESET}`);
+
+  if (low.length === 0) {
+    lines.push(`\n   ${GREEN}✔ Outstanding hygiene! Zero Grade B issues detected.${RESET}`);
+    lines.push(`   ${DIM}Zero em dashes and zero unguarded console statements found.${RESET}`);
+  } else {
+    lines.push(`\n   ${BOLD}${YELLOW}ℹ️  LOW HYGIENE VIOLATIONS (${low.length}):${RESET}`);
+    low.forEach((v, idx) => {
+      lines.push(`   ${YELLOW}[#${idx + 1} LOW]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
+      lines.push(`      Hazard:    ${v.hazard}`);
+      lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
+    });
+  }
+
+  const promptB = buildGradeBPrompt(report);
+  if (promptB) {
+    lines.push(formatPromptBox('🤖 AI AGENT REFACTORING PROMPT (GRADE B HYGIENE)', promptB));
+  }
+
+  lines.push(`${YELLOW}======================================================================${RESET}\n`);
+  return lines.join('\n');
+};
+
+export const formatGradeASection = (report) => {
+  const { metrics, health, pillars, hotspots, contextAnalysis } = report;
+  const passedPillars = Object.entries(pillars || {}).filter(([_, p]) => p.status === 'PASSED');
+  const lines = [];
+
+  lines.push('');
+  lines.push(`${GREEN}======================================================================${RESET}`);
+  lines.push(`${BOLD}${GREEN}   GRADE A : COMPLIANT ARCHITECTURE & PASSING PILLARS${RESET}`);
+  lines.push(`${DIM}   Molecular Architecture verified clean areas and crystalline modules${RESET}`);
+  lines.push(`${GREEN}======================================================================${RESET}`);
+  lines.push(`   Molecular Health Score:  ${BOLD}${GREEN}${health.score}/100${RESET} [Grade: ${BOLD}${GREEN}${health.grade}${RESET}]`);
+  lines.push(`   Passing Pillars:       ${BOLD}${GREEN}${passedPillars.length} / 7 Pillars PASSED${RESET}`);
+  lines.push(`   Capsule Compliance:    ${BOLD}${GREEN}${metrics.moleculeCompliantPct}%${RESET} compliant (< 100 LOC)`);
+  lines.push(`${GREEN}----------------------------------------------------------------------${RESET}`);
+
+  lines.push(`\n   ${BOLD}${GREEN}✔ COMPLIANT PILLARS (${passedPillars.length} / 7):${RESET}`);
+  if (passedPillars.length === 0) {
+    lines.push(`   ${YELLOW}No pillars are currently 100% compliant.${RESET}\n`);
+  } else {
+    for (const [name] of passedPillars) {
+      lines.push(`   ${GREEN}✔${RESET} ${name} ${DIM}(0 violations)${RESET}`);
+    }
+    lines.push('');
+  }
+
+  lines.push(`   ${BOLD}${CYAN}STANDARDS MET & CLEAN CODEBASE ASSETS:${RESET}`);
+  if (metrics.moleculeCompliantPct === 100) {
+    lines.push(`   ${GREEN}✔${RESET} 100% Molecule Capsule Limit (< 100 lines per molecule)`);
+  }
+  const hasExtremeMonolith = hotspots.some((h) => h.lineCount >= 2000);
+  if (!hasExtremeMonolith) {
+    lines.push(`   ${GREEN}✔${RESET} Zero Extreme Monoliths (0 files >= 2,000 LOC)`);
+  }
+  const hasSevereMonolith = hotspots.some((h) => h.lineCount >= 1000);
+  if (!hasSevereMonolith) {
+    lines.push(`   ${GREEN}✔${RESET} Zero Severe Monoliths (0 files >= 1,000 LOC)`);
+  }
+  if (contextAnalysis.riskLevel === 'LOW') {
+    lines.push(`   ${GREEN}✔${RESET} Low Context Hazard & Token Burn Risk`);
+  }
+
+  lines.push(`\n${GREEN}======================================================================${RESET}\n`);
+  return lines.join('\n');
+};