@ipation/specbridge 1.1.1 → 1.2.0

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command16 } from "commander";
-import chalk14 from "chalk";
+import { Command as Command18 } from "commander";
+import chalk16 from "chalk";
 import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname4, join as join10 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname5, join as join12 } from "path";
 
 // src/core/errors/index.ts
 var SpecBridgeError = class extends Error {
@@ -3711,7 +3711,7 @@ var hookCommand = createHookCommand();
 import { Command as Command10 } from "commander";
 import chalk10 from "chalk";
 import ora6 from "ora";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/reporting/reporter.ts
 async function generateReport(config, options = {}) {
@@ -3941,8 +3941,293 @@ function formatProgressBar(percentage) {
   return `\`${filledChar.repeat(filled)}${emptyChar.repeat(empty)}\` ${percentage}%`;
 }
 
+// src/reporting/storage.ts
+import { join as join8 } from "path";
+var ReportStorage = class {
+  storageDir;
+  constructor(basePath) {
+    this.storageDir = join8(getSpecBridgeDir(basePath), "reports", "history");
+  }
+  /**
+   * Save a compliance report to storage
+   */
+  async save(report) {
+    await ensureDir(this.storageDir);
+    const date = new Date(report.timestamp).toISOString().split("T")[0];
+    const filename = `report-${date}.json`;
+    const filepath = join8(this.storageDir, filename);
+    await writeTextFile(filepath, JSON.stringify(report, null, 2));
+    return filepath;
+  }
+  /**
+   * Load the most recent report
+   */
+  async loadLatest() {
+    if (!await pathExists(this.storageDir)) {
+      return null;
+    }
+    const files = await readFilesInDir(this.storageDir);
+    if (files.length === 0) {
+      return null;
+    }
+    const sortedFiles = files.filter((f) => f.startsWith("report-") && f.endsWith(".json")).sort().reverse();
+    if (sortedFiles.length === 0) {
+      return null;
+    }
+    const latestFile = sortedFiles[0];
+    if (!latestFile) {
+      return null;
+    }
+    const content = await readTextFile(join8(this.storageDir, latestFile));
+    const report = JSON.parse(content);
+    return {
+      timestamp: latestFile.replace("report-", "").replace(".json", ""),
+      report
+    };
+  }
+  /**
+   * Load historical reports for the specified number of days
+   */
+  async loadHistory(days = 30) {
+    if (!await pathExists(this.storageDir)) {
+      return [];
+    }
+    const files = await readFilesInDir(this.storageDir);
+    const reportFiles = files.filter((f) => f.startsWith("report-") && f.endsWith(".json")).sort().reverse();
+    const recentFiles = reportFiles.slice(0, days);
+    const reports = [];
+    for (const file of recentFiles) {
+      try {
+        const content = await readTextFile(join8(this.storageDir, file));
+        const report = JSON.parse(content);
+        const timestamp = file.replace("report-", "").replace(".json", "");
+        reports.push({ timestamp, report });
+      } catch (error) {
+        console.warn(`Warning: Failed to load report ${file}:`, error);
+      }
+    }
+    return reports;
+  }
+  /**
+   * Load a specific report by date
+   */
+  async loadByDate(date) {
+    const filepath = join8(this.storageDir, `report-${date}.json`);
+    if (!await pathExists(filepath)) {
+      return null;
+    }
+    const content = await readTextFile(filepath);
+    return JSON.parse(content);
+  }
+  /**
+   * Get all available report dates
+   */
+  async getAvailableDates() {
+    if (!await pathExists(this.storageDir)) {
+      return [];
+    }
+    const files = await readFilesInDir(this.storageDir);
+    return files.filter((f) => f.startsWith("report-") && f.endsWith(".json")).map((f) => f.replace("report-", "").replace(".json", "")).sort().reverse();
+  }
+  /**
+   * Clear old reports (keep only the most recent N days)
+   */
+  async cleanup(keepDays = 90) {
+    if (!await pathExists(this.storageDir)) {
+      return 0;
+    }
+    const files = await readFilesInDir(this.storageDir);
+    const reportFiles = files.filter((f) => f.startsWith("report-") && f.endsWith(".json")).sort().reverse();
+    const filesToDelete = reportFiles.slice(keepDays);
+    for (const file of filesToDelete) {
+      try {
+        const filepath = join8(this.storageDir, file);
+        const fs = await import("fs/promises");
+        await fs.unlink(filepath);
+      } catch (error) {
+        console.warn(`Warning: Failed to delete old report ${file}:`, error);
+      }
+    }
+    return filesToDelete.length;
+  }
+};
+
+// src/reporting/drift.ts
+async function detectDrift(current, previous) {
+  const byDecision = [];
+  for (const currDecision of current.byDecision) {
+    const prevDecision = previous.byDecision.find(
+      (d) => d.decisionId === currDecision.decisionId
+    );
+    if (!prevDecision) {
+      byDecision.push({
+        decisionId: currDecision.decisionId,
+        title: currDecision.title,
+        trend: "stable",
+        complianceChange: 0,
+        newViolations: currDecision.violations,
+        fixedViolations: 0,
+        currentCompliance: currDecision.compliance,
+        previousCompliance: currDecision.compliance
+      });
+      continue;
+    }
+    const complianceChange = currDecision.compliance - prevDecision.compliance;
+    const violationDiff = currDecision.violations - prevDecision.violations;
+    let trend;
+    if (complianceChange > 5) {
+      trend = "improving";
+    } else if (complianceChange < -5) {
+      trend = "degrading";
+    } else {
+      trend = "stable";
+    }
+    byDecision.push({
+      decisionId: currDecision.decisionId,
+      title: currDecision.title,
+      trend,
+      complianceChange,
+      newViolations: Math.max(0, violationDiff),
+      fixedViolations: Math.max(0, -violationDiff),
+      currentCompliance: currDecision.compliance,
+      previousCompliance: prevDecision.compliance
+    });
+  }
+  const overallComplianceChange = current.summary.compliance - previous.summary.compliance;
+  let overallTrend;
+  if (overallComplianceChange > 5) {
+    overallTrend = "improving";
+  } else if (overallComplianceChange < -5) {
+    overallTrend = "degrading";
+  } else {
+    overallTrend = "stable";
+  }
+  const newViolations = {
+    critical: Math.max(
+      0,
+      current.summary.violations.critical - previous.summary.violations.critical
+    ),
+    high: Math.max(0, current.summary.violations.high - previous.summary.violations.high),
+    medium: Math.max(0, current.summary.violations.medium - previous.summary.violations.medium),
+    low: Math.max(0, current.summary.violations.low - previous.summary.violations.low),
+    total: 0
+  };
+  newViolations.total = newViolations.critical + newViolations.high + newViolations.medium + newViolations.low;
+  const fixedViolations = {
+    critical: Math.max(
+      0,
+      previous.summary.violations.critical - current.summary.violations.critical
+    ),
+    high: Math.max(0, previous.summary.violations.high - current.summary.violations.high),
+    medium: Math.max(0, previous.summary.violations.medium - current.summary.violations.medium),
+    low: Math.max(0, previous.summary.violations.low - current.summary.violations.low),
+    total: 0
+  };
+  fixedViolations.total = fixedViolations.critical + fixedViolations.high + fixedViolations.medium + fixedViolations.low;
+  const improving = byDecision.filter((d) => d.trend === "improving");
+  const degrading = byDecision.filter((d) => d.trend === "degrading");
+  const mostImproved = improving.sort((a, b) => b.complianceChange - a.complianceChange).slice(0, 5);
+  const mostDegraded = degrading.sort((a, b) => a.complianceChange - b.complianceChange).slice(0, 5);
+  return {
+    trend: overallTrend,
+    complianceChange: overallComplianceChange,
+    summary: {
+      newViolations,
+      fixedViolations
+    },
+    byDecision,
+    mostImproved,
+    mostDegraded
+  };
+}
+async function analyzeTrend(reports) {
+  if (reports.length === 0) {
+    throw new Error("No reports provided for trend analysis");
+  }
+  const sortedReports = reports.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  const firstReport = sortedReports[0]?.report;
+  const lastReport = sortedReports[sortedReports.length - 1]?.report;
+  if (!firstReport || !lastReport) {
+    throw new Error("Invalid reports data");
+  }
+  const overallChange = lastReport.summary.compliance - firstReport.summary.compliance;
+  let overallTrend;
+  if (overallChange > 5) {
+    overallTrend = "improving";
+  } else if (overallChange < -5) {
+    overallTrend = "degrading";
+  } else {
+    overallTrend = "stable";
+  }
+  const overallDataPoints = sortedReports.map((r) => ({
+    date: r.timestamp,
+    compliance: r.report.summary.compliance
+  }));
+  const decisionMap = /* @__PURE__ */ new Map();
+  for (const { report } of sortedReports) {
+    for (const decision of report.byDecision) {
+      if (!decisionMap.has(decision.decisionId)) {
+        decisionMap.set(decision.decisionId, []);
+      }
+      decisionMap.get(decision.decisionId).push(decision);
+    }
+  }
+  const decisions = Array.from(decisionMap.entries()).map(([decisionId, data]) => {
+    const first = data[0];
+    const last = data[data.length - 1];
+    if (!first || !last) {
+      throw new Error(`Invalid decision data for ${decisionId}`);
+    }
+    const change = last.compliance - first.compliance;
+    let trend;
+    if (change > 5) {
+      trend = "improving";
+    } else if (change < -5) {
+      trend = "degrading";
+    } else {
+      trend = "stable";
+    }
+    const dataPoints = sortedReports.map((r) => {
+      const decision = r.report.byDecision.find((d) => d.decisionId === decisionId);
+      return {
+        date: r.timestamp,
+        compliance: decision?.compliance ?? 0
+      };
+    });
+    return {
+      decisionId,
+      title: last.title,
+      startCompliance: first.compliance,
+      endCompliance: last.compliance,
+      change,
+      trend,
+      dataPoints
+    };
+  });
+  const firstTimestamp = sortedReports[0]?.timestamp;
+  const lastTimestamp = sortedReports[sortedReports.length - 1]?.timestamp;
+  if (!firstTimestamp || !lastTimestamp) {
+    throw new Error("Invalid report timestamps");
+  }
+  return {
+    period: {
+      start: firstTimestamp,
+      end: lastTimestamp,
+      days: sortedReports.length
+    },
+    overall: {
+      startCompliance: firstReport.summary.compliance,
+      endCompliance: lastReport.summary.compliance,
+      change: overallChange,
+      trend: overallTrend,
+      dataPoints: overallDataPoints
+    },
+    decisions
+  };
+}
+
 // src/cli/commands/report.ts
-var reportCommand = new Command10("report").description("Generate compliance report").option("-f, --format <format>", "Output format (console, json, markdown)", "console").option("-o, --output <file>", "Output file path").option("--save", "Save to .specbridge/reports/").option("-a, --all", "Include all decisions (not just active)").action(async (options) => {
+var reportCommand = new Command10("report").description("Generate compliance report").option("-f, --format <format>", "Output format (console, json, markdown)", "console").option("-o, --output <file>", "Output file path").option("--save", "Save to .specbridge/reports/").option("-a, --all", "Include all decisions (not just active)").option("--trend", "Show compliance trend over time").option("--drift", "Analyze drift since last report").option("--days <n>", "Number of days for trend analysis", "30").action(async (options) => {
   const cwd = process.cwd();
   if (!await pathExists(getSpecBridgeDir(cwd))) {
     throw new NotInitializedError();
@@ -3955,6 +4240,111 @@ var reportCommand = new Command10("report").description("Generate compliance rep
       cwd
     });
     spinner.succeed("Report generated");
+    const storage = new ReportStorage(cwd);
+    await storage.save(report);
+    if (options.trend) {
+      console.log("\n" + chalk10.blue.bold("=== Compliance Trend Analysis ===\n"));
+      const days = parseInt(options.days || "30", 10);
+      const history = await storage.loadHistory(days);
+      if (history.length < 2) {
+        console.log(chalk10.yellow(`Not enough data for trend analysis. Found ${history.length} report(s), need at least 2.`));
+      } else {
+        const trend = await analyzeTrend(history);
+        console.log(chalk10.bold(`Period: ${trend.period.start} to ${trend.period.end} (${trend.period.days} days)`));
+        console.log(`
+Overall Compliance: ${trend.overall.startCompliance}% \u2192 ${trend.overall.endCompliance}% (${trend.overall.change > 0 ? "+" : ""}${trend.overall.change.toFixed(1)}%)`);
+        const trendEmoji = trend.overall.trend === "improving" ? "\u{1F4C8}" : trend.overall.trend === "degrading" ? "\u{1F4C9}" : "\u27A1\uFE0F";
+        const trendColor = trend.overall.trend === "improving" ? chalk10.green : trend.overall.trend === "degrading" ? chalk10.red : chalk10.yellow;
+        console.log(trendColor(`${trendEmoji} Trend: ${trend.overall.trend.toUpperCase()}`));
+        const degrading = trend.decisions.filter((d) => d.trend === "degrading").slice(0, 3);
+        if (degrading.length > 0) {
+          console.log(chalk10.red("\n\u26A0\uFE0F  Most Degraded Decisions:"));
+          degrading.forEach((d) => {
+            console.log(`  \u2022 ${d.title}: ${d.startCompliance}% \u2192 ${d.endCompliance}% (${d.change.toFixed(1)}%)`);
+          });
+        }
+        const improving = trend.decisions.filter((d) => d.trend === "improving").slice(0, 3);
+        if (improving.length > 0) {
+          console.log(chalk10.green("\n\u2705 Most Improved Decisions:"));
+          improving.forEach((d) => {
+            console.log(`  \u2022 ${d.title}: ${d.startCompliance}% \u2192 ${d.endCompliance}% (+${d.change.toFixed(1)}%)`);
+          });
+        }
+      }
+      console.log("");
+    }
+    if (options.drift) {
+      console.log("\n" + chalk10.blue.bold("=== Drift Analysis ===\n"));
+      const history = await storage.loadHistory(2);
+      if (history.length < 2) {
+        console.log(chalk10.yellow("Not enough data for drift analysis. Need at least 2 reports."));
+      } else {
+        const currentEntry = history[0];
+        const previousEntry = history[1];
+        if (!currentEntry || !previousEntry) {
+          console.log(chalk10.yellow("Invalid history data."));
+          return;
+        }
+        const drift = await detectDrift(currentEntry.report, previousEntry.report);
+        console.log(chalk10.bold(`Comparing: ${previousEntry.timestamp} vs ${currentEntry.timestamp}`));
+        console.log(`
+Compliance Change: ${drift.complianceChange > 0 ? "+" : ""}${drift.complianceChange.toFixed(1)}%`);
+        const driftEmoji = drift.trend === "improving" ? "\u{1F4C8}" : drift.trend === "degrading" ? "\u{1F4C9}" : "\u27A1\uFE0F";
+        const driftColor = drift.trend === "improving" ? chalk10.green : drift.trend === "degrading" ? chalk10.red : chalk10.yellow;
+        console.log(driftColor(`${driftEmoji} Overall Trend: ${drift.trend.toUpperCase()}`));
+        if (drift.summary.newViolations.total > 0) {
+          console.log(chalk10.red(`
+\u26A0\uFE0F  New Violations: ${drift.summary.newViolations.total}`));
+          if (drift.summary.newViolations.critical > 0) {
+            console.log(`  \u2022 Critical: ${drift.summary.newViolations.critical}`);
+          }
+          if (drift.summary.newViolations.high > 0) {
+            console.log(`  \u2022 High: ${drift.summary.newViolations.high}`);
+          }
+          if (drift.summary.newViolations.medium > 0) {
+            console.log(`  \u2022 Medium: ${drift.summary.newViolations.medium}`);
+          }
+          if (drift.summary.newViolations.low > 0) {
+            console.log(`  \u2022 Low: ${drift.summary.newViolations.low}`);
+          }
+        }
+        if (drift.summary.fixedViolations.total > 0) {
+          console.log(chalk10.green(`
+\u2705 Fixed Violations: ${drift.summary.fixedViolations.total}`));
+          if (drift.summary.fixedViolations.critical > 0) {
+            console.log(`  \u2022 Critical: ${drift.summary.fixedViolations.critical}`);
+          }
+          if (drift.summary.fixedViolations.high > 0) {
+            console.log(`  \u2022 High: ${drift.summary.fixedViolations.high}`);
+          }
+          if (drift.summary.fixedViolations.medium > 0) {
+            console.log(`  \u2022 Medium: ${drift.summary.fixedViolations.medium}`);
+          }
+          if (drift.summary.fixedViolations.low > 0) {
+            console.log(`  \u2022 Low: ${drift.summary.fixedViolations.low}`);
+          }
+        }
+        if (drift.mostDegraded.length > 0) {
+          console.log(chalk10.red("\n\u{1F4C9} Most Degraded:"));
+          drift.mostDegraded.forEach((d) => {
+            console.log(`  \u2022 ${d.title}: ${d.previousCompliance}% \u2192 ${d.currentCompliance}% (${d.complianceChange.toFixed(1)}%)`);
+            if (d.newViolations > 0) {
+              console.log(`    +${d.newViolations} new violation(s)`);
+            }
+          });
+        }
+        if (drift.mostImproved.length > 0) {
+          console.log(chalk10.green("\n\u{1F4C8} Most Improved:"));
+          drift.mostImproved.forEach((d) => {
+            console.log(`  \u2022 ${d.title}: ${d.previousCompliance}% \u2192 ${d.currentCompliance}% (+${d.complianceChange.toFixed(1)}%)`);
+            if (d.fixedViolations > 0) {
+              console.log(`    -${d.fixedViolations} fixed violation(s)`);
+            }
+          });
+        }
+      }
+      console.log("");
+    }
     let output;
     let extension;
     switch (options.format) {
@@ -3973,11 +4363,13 @@ var reportCommand = new Command10("report").description("Generate compliance rep
         extension = "txt";
         break;
     }
-    if (options.format !== "json" || !options.output) {
-      console.log(output);
+    if (!options.trend && !options.drift) {
+      if (options.format !== "json" || !options.output) {
+        console.log(output);
+      }
     }
     if (options.output || options.save) {
-      const outputPath = options.output || join8(
+      const outputPath = options.output || join9(
         getReportsDir(cwd),
         `health-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${extension}`
       );
@@ -3985,7 +4377,7 @@ var reportCommand = new Command10("report").description("Generate compliance rep
       console.log(chalk10.green(`
 Report saved to: ${outputPath}`));
       if (options.save && !options.output) {
-        const latestPath = join8(getReportsDir(cwd), `health-latest.${extension}`);
+        const latestPath = join9(getReportsDir(cwd), `health-latest.${extension}`);
         await writeTextFile(latestPath, output);
       }
     }
@@ -4389,7 +4781,7 @@ var watchCommand = new Command13("watch").description("Watch for changes and ver
 import { Command as Command14 } from "commander";
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname3, join as join10 } from "path";
 
 // src/mcp/server.ts
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -4572,8 +4964,8 @@ var SpecBridgeMcpServer = class {
 // src/cli/commands/mcp-server.ts
 function getCliVersion() {
   try {
-    const __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-    const packageJsonPath2 = join9(__dirname2, "../package.json");
+    const __dirname3 = dirname3(fileURLToPath2(import.meta.url));
+    const packageJsonPath2 = join10(__dirname3, "../package.json");
     const pkg = JSON.parse(readFileSync(packageJsonPath2, "utf-8"));
     return String(pkg.version || "0.0.0");
   } catch {
@@ -4663,11 +5055,598 @@ var promptCommand = new Command15("prompt").description("Generate AI agent promp
   console.log(prompt);
 });
 
-// src/cli/index.ts
+// src/cli/commands/analytics.ts
+import { Command as Command16 } from "commander";
+import chalk14 from "chalk";
+import ora7 from "ora";
+
+// src/analytics/engine.ts
+var AnalyticsEngine = class {
+  /**
+   * Analyze a specific decision across historical reports
+   */
+  async analyzeDecision(decisionId, history) {
+    if (history.length === 0) {
+      throw new Error("No historical reports provided");
+    }
+    const decisionHistory = [];
+    for (const { timestamp, report } of history) {
+      const decision = report.byDecision.find((d) => d.decisionId === decisionId);
+      if (decision) {
+        decisionHistory.push({ date: timestamp, data: decision });
+      }
+    }
+    if (decisionHistory.length === 0) {
+      throw new Error(`Decision ${decisionId} not found in any report`);
+    }
+    const latestEntry = decisionHistory[decisionHistory.length - 1];
+    if (!latestEntry) {
+      throw new Error(`No data found for decision ${decisionId}`);
+    }
+    const latest = latestEntry.data;
+    const averageCompliance = decisionHistory.reduce((sum, h) => sum + h.data.compliance, 0) / decisionHistory.length;
+    let trendDirection = "stable";
+    if (decisionHistory.length >= 2) {
+      const firstEntry = decisionHistory[0];
+      if (!firstEntry) {
+        throw new Error("Invalid decision history");
+      }
+      const first = firstEntry.data.compliance;
+      const last = latest.compliance;
+      const change = last - first;
+      if (change > 5) {
+        trendDirection = "up";
+      } else if (change < -5) {
+        trendDirection = "down";
+      }
+    }
+    const historyData = decisionHistory.map((h) => ({
+      date: h.date,
+      compliance: h.data.compliance,
+      violations: h.data.violations
+    }));
+    return {
+      decisionId,
+      title: latest.title,
+      totalViolations: latest.violations,
+      violationsByFile: /* @__PURE__ */ new Map(),
+      // Would need violation details to populate
+      violationsBySeverity: {
+        critical: 0,
+        high: 0,
+        medium: 0,
+        low: 0
+      },
+      // Would need violation details to populate
+      mostViolatedConstraint: null,
+      // Would need constraint details to populate
+      averageComplianceScore: averageCompliance,
+      trendDirection,
+      history: historyData
+    };
+  }
+  /**
+   * Generate insights from historical data
+   */
+  async generateInsights(history) {
+    if (history.length === 0) {
+      return [];
+    }
+    const insights = [];
+    const sorted = history.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const latestEntry = sorted[sorted.length - 1];
+    if (!latestEntry) {
+      throw new Error("No reports in history");
+    }
+    const latest = latestEntry.report;
+    if (sorted.length >= 2) {
+      const firstEntry = sorted[0];
+      if (!firstEntry) {
+        return insights;
+      }
+      const first = firstEntry.report;
+      const complianceChange = latest.summary.compliance - first.summary.compliance;
+      if (complianceChange > 10) {
+        insights.push({
+          type: "success",
+          category: "trend",
+          message: `Compliance has improved by ${complianceChange.toFixed(1)}% over the past ${sorted.length} days`,
+          details: `From ${first.summary.compliance}% to ${latest.summary.compliance}%`
+        });
+      } else if (complianceChange < -10) {
+        insights.push({
+          type: "warning",
+          category: "trend",
+          message: `Compliance has dropped by ${Math.abs(complianceChange).toFixed(1)}% over the past ${sorted.length} days`,
+          details: `From ${first.summary.compliance}% to ${latest.summary.compliance}%`
+        });
+      }
+    }
+    if (latest.summary.violations.critical > 0) {
+      insights.push({
+        type: "warning",
+        category: "compliance",
+        message: `${latest.summary.violations.critical} critical violation(s) require immediate attention`,
+        details: "Critical violations block deployments and should be resolved as soon as possible"
+      });
+    }
+    const problematicDecisions = latest.byDecision.filter((d) => d.compliance < 50);
+    if (problematicDecisions.length > 0) {
+      insights.push({
+        type: "warning",
+        category: "hotspot",
+        message: `${problematicDecisions.length} decision(s) have less than 50% compliance`,
+        details: problematicDecisions.map((d) => `${d.title} (${d.compliance}%)`).join(", ")
+      });
+    }
+    const excellentDecisions = latest.byDecision.filter((d) => d.compliance === 100);
+    if (excellentDecisions.length > 0) {
+      insights.push({
+        type: "success",
+        category: "compliance",
+        message: `${excellentDecisions.length} decision(s) have 100% compliance`,
+        details: excellentDecisions.map((d) => d.title).join(", ")
+      });
+    }
+    const avgCompliance = latest.summary.compliance;
+    const decisionsAboveAvg = latest.byDecision.filter((d) => d.compliance > avgCompliance);
+    const decisionsBelowAvg = latest.byDecision.filter((d) => d.compliance < avgCompliance);
+    if (decisionsBelowAvg.length > decisionsAboveAvg.length) {
+      insights.push({
+        type: "info",
+        category: "suggestion",
+        message: `${decisionsBelowAvg.length} decisions are below average compliance`,
+        details: "Consider focusing improvement efforts on these lower-performing decisions"
+      });
+    }
+    const totalViolations = latest.summary.violations.critical + latest.summary.violations.high + latest.summary.violations.medium + latest.summary.violations.low;
+    if (totalViolations > 0) {
+      const criticalPercent = latest.summary.violations.critical / totalViolations * 100;
+      const highPercent = latest.summary.violations.high / totalViolations * 100;
+      if (criticalPercent + highPercent > 60) {
+        insights.push({
+          type: "warning",
+          category: "suggestion",
+          message: "Most violations are high severity",
+          details: `${criticalPercent.toFixed(0)}% critical, ${highPercent.toFixed(0)}% high. Prioritize these for the biggest impact.`
+        });
+      } else {
+        insights.push({
+          type: "info",
+          category: "suggestion",
+          message: "Most violations are lower severity",
+          details: "Consider addressing high-severity issues first for maximum impact"
+        });
+      }
+    }
+    return insights;
+  }
+  /**
+   * Generate analytics summary
+   */
+  async generateSummary(history) {
+    if (history.length === 0) {
+      throw new Error("No historical reports provided");
+    }
+    const latestEntry = history[history.length - 1];
+    if (!latestEntry) {
+      throw new Error("Invalid history data");
+    }
+    const latest = latestEntry.report;
+    let overallTrend = "stable";
+    if (history.length >= 2) {
+      const firstEntry = history[0];
+      if (!firstEntry) {
+        throw new Error("Invalid history data");
+      }
+      const first = firstEntry.report;
+      const change = latest.summary.compliance - first.summary.compliance;
+      if (change > 5) {
+        overallTrend = "up";
+      } else if (change < -5) {
+        overallTrend = "down";
+      }
+    }
+    const sortedByCompliance = [...latest.byDecision].sort(
+      (a, b) => b.compliance - a.compliance
+    );
+    const topDecisions = sortedByCompliance.slice(0, 5).map((d) => ({
+      decisionId: d.decisionId,
+      title: d.title,
+      compliance: d.compliance
+    }));
+    const bottomDecisions = sortedByCompliance.slice(-5).reverse().map((d) => ({
+      decisionId: d.decisionId,
+      title: d.title,
+      compliance: d.compliance
+    }));
+    const insights = await this.generateInsights(history);
+    return {
+      totalDecisions: latest.byDecision.length,
+      averageCompliance: latest.summary.compliance,
+      overallTrend,
+      criticalIssues: latest.summary.violations.critical,
+      topDecisions,
+      bottomDecisions,
+      insights
+    };
+  }
+};
+
+// src/cli/commands/analytics.ts
+var analyticsCommand = new Command16("analytics").description("Analyze compliance trends and decision impact").argument("[decision-id]", "Specific decision to analyze").option("--insights", "Show AI-generated insights").option("--days <n>", "Number of days of history to analyze", "90").option("-f, --format <format>", "Output format (console, json)", "console").action(async (decisionId, options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const spinner = ora7("Analyzing compliance data...").start();
+  try {
+    const storage = new ReportStorage(cwd);
+    const days = parseInt(options.days || "90", 10);
+    const history = await storage.loadHistory(days);
+    if (history.length === 0) {
+      spinner.fail("No historical reports found");
+      console.log(chalk14.yellow("\nGenerate reports with: specbridge report"));
+      return;
+    }
+    spinner.succeed(`Loaded ${history.length} historical report(s)`);
+    const engine = new AnalyticsEngine();
+    if (options.format === "json") {
+      if (decisionId) {
+        const metrics = await engine.analyzeDecision(decisionId, history);
+        console.log(JSON.stringify(metrics, null, 2));
+      } else {
+        const summary = await engine.generateSummary(history);
+        console.log(JSON.stringify(summary, null, 2));
+      }
+      return;
+    }
+    if (decisionId) {
+      const metrics = await engine.analyzeDecision(decisionId, history);
+      console.log("\n" + chalk14.blue.bold(`=== Decision Analytics: ${metrics.title} ===
+`));
+      console.log(chalk14.bold("Overview:"));
+      console.log(`  ID: ${metrics.decisionId}`);
+      console.log(`  Current Violations: ${metrics.totalViolations}`);
+      console.log(`  Average Compliance: ${metrics.averageComplianceScore.toFixed(1)}%`);
+      const trendEmoji = metrics.trendDirection === "up" ? "\u{1F4C8}" : metrics.trendDirection === "down" ? "\u{1F4C9}" : "\u27A1\uFE0F";
+      const trendColor = metrics.trendDirection === "up" ? chalk14.green : metrics.trendDirection === "down" ? chalk14.red : chalk14.yellow;
+      console.log(`  ${trendColor(`${trendEmoji} Trend: ${metrics.trendDirection.toUpperCase()}`)}`);
+      if (metrics.history.length > 0) {
+        console.log(chalk14.bold("\nCompliance History:"));
+        const recentHistory = metrics.history.slice(-10);
+        recentHistory.forEach((h) => {
+          const icon = h.violations === 0 ? "\u2705" : "\u26A0\uFE0F";
+          console.log(`  ${icon} ${h.date}: ${h.compliance}% (${h.violations} violations)`);
+        });
+      }
+    } else {
+      const summary = await engine.generateSummary(history);
+      console.log("\n" + chalk14.blue.bold("=== Overall Analytics ===\n"));
+      console.log(chalk14.bold("Summary:"));
+      console.log(`  Total Decisions: ${summary.totalDecisions}`);
+      console.log(`  Average Compliance: ${summary.averageCompliance}%`);
+      console.log(`  Critical Issues: ${summary.criticalIssues}`);
+      const trendEmoji = summary.overallTrend === "up" ? "\u{1F4C8}" : summary.overallTrend === "down" ? "\u{1F4C9}" : "\u27A1\uFE0F";
+      const trendColor = summary.overallTrend === "up" ? chalk14.green : summary.overallTrend === "down" ? chalk14.red : chalk14.yellow;
+      console.log(`  ${trendColor(`${trendEmoji} Overall Trend: ${summary.overallTrend.toUpperCase()}`)}`);
+      if (summary.topDecisions.length > 0) {
+        console.log(chalk14.green("\n\u2705 Top Performing Decisions:"));
+        summary.topDecisions.forEach((d, i) => {
+          console.log(`  ${i + 1}. ${d.title}: ${d.compliance}%`);
+        });
+      }
+      if (summary.bottomDecisions.length > 0) {
+        console.log(chalk14.red("\n\u26A0\uFE0F  Decisions Needing Attention:"));
+        summary.bottomDecisions.forEach((d, i) => {
+          console.log(`  ${i + 1}. ${d.title}: ${d.compliance}%`);
+        });
+      }
+      if (options.insights || summary.criticalIssues > 0) {
+        console.log(chalk14.blue.bold("\n=== Insights ===\n"));
+        const insights = summary.insights;
+        const warnings = insights.filter((i) => i.type === "warning");
+        const successes = insights.filter((i) => i.type === "success");
+        const infos = insights.filter((i) => i.type === "info");
+        if (warnings.length > 0) {
+          console.log(chalk14.red("\u26A0\uFE0F  Warnings:"));
+          warnings.forEach((i) => {
+            console.log(`  \u2022 ${i.message}`);
+            if (i.details) {
+              console.log(chalk14.gray(`    ${i.details}`));
+            }
+          });
+          console.log("");
+        }
+        if (successes.length > 0) {
+          console.log(chalk14.green("\u2705 Positive Trends:"));
+          successes.forEach((i) => {
+            console.log(`  \u2022 ${i.message}`);
+            if (i.details) {
+              console.log(chalk14.gray(`    ${i.details}`));
+            }
+          });
+          console.log("");
+        }
+        if (infos.length > 0) {
+          console.log(chalk14.blue("\u{1F4A1} Suggestions:"));
+          infos.forEach((i) => {
+            console.log(`  \u2022 ${i.message}`);
+            if (i.details) {
+              console.log(chalk14.gray(`    ${i.details}`));
+            }
+          });
+          console.log("");
+        }
+      }
+    }
+    const latestEntry = history[history.length - 1];
+    const oldestEntry = history[0];
+    if (latestEntry && oldestEntry) {
+      console.log(chalk14.gray(`
+Data range: ${latestEntry.timestamp} to ${oldestEntry.timestamp}`));
+    }
+    console.log(chalk14.gray(`Analyzing ${history.length} report(s) over ${days} days
+`));
+  } catch (error) {
+    spinner.fail("Analytics failed");
+    throw error;
+  }
+});
+
+// src/cli/commands/dashboard.ts
+import { Command as Command17 } from "commander";
+import chalk15 from "chalk";
+
+// src/dashboard/server.ts
+import express from "express";
+import { join as join11, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname = dirname4(fileURLToPath3(import.meta.url));
-var packageJsonPath = join10(__dirname, "../package.json");
+function createDashboardServer(options) {
+  const { cwd, config } = options;
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    next();
+  });
+  app.get("/api/report/latest", async (_req, res) => {
+    try {
+      const report = await generateReport(config, { cwd });
+      res.json(report);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to generate report",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/report/history", async (req, res) => {
+    try {
+      const days = parseInt(req.query.days) || 30;
+      const storage = new ReportStorage(cwd);
+      const history = await storage.loadHistory(days);
+      res.json(history);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to load history",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/report/dates", async (_req, res) => {
+    try {
+      const storage = new ReportStorage(cwd);
+      const dates = await storage.getAvailableDates();
+      res.json(dates);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to load dates",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/report/:date", async (req, res) => {
+    try {
+      const date = req.params.date;
+      if (!date) {
+        res.status(400).json({ error: "Date parameter required" });
+        return;
+      }
+      const storage = new ReportStorage(cwd);
+      const report = await storage.loadByDate(date);
+      if (!report) {
+        res.status(404).json({ error: "Report not found" });
+        return;
+      }
+      res.json(report);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to load report",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/decisions", async (_req, res) => {
+    try {
+      const registry = createRegistry({ basePath: cwd });
+      await registry.load();
+      const decisions = registry.getAll();
+      res.json(decisions);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to load decisions",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/decisions/:id", async (req, res) => {
+    try {
+      const id = req.params.id;
+      if (!id) {
+        res.status(400).json({ error: "Decision ID required" });
+        return;
+      }
+      const registry = createRegistry({ basePath: cwd });
+      await registry.load();
+      const decision = registry.get(id);
+      if (!decision) {
+        res.status(404).json({ error: "Decision not found" });
+        return;
+      }
+      res.json(decision);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to load decision",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/analytics/summary", async (req, res) => {
+    try {
+      const days = parseInt(req.query.days) || 90;
+      const storage = new ReportStorage(cwd);
+      const history = await storage.loadHistory(days);
+      if (history.length === 0) {
+        res.status(404).json({ error: "No historical data available" });
+        return;
+      }
+      const engine = new AnalyticsEngine();
+      const summary = await engine.generateSummary(history);
+      res.json(summary);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to generate analytics",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/analytics/decision/:id", async (req, res) => {
+    try {
+      const id = req.params.id;
+      if (!id) {
+        res.status(400).json({ error: "Decision ID required" });
+        return;
+      }
+      const days = parseInt(req.query.days) || 90;
+      const storage = new ReportStorage(cwd);
+      const history = await storage.loadHistory(days);
+      if (history.length === 0) {
+        res.status(404).json({ error: "No historical data available" });
+        return;
+      }
+      const engine = new AnalyticsEngine();
+      const metrics = await engine.analyzeDecision(id, history);
+      res.json(metrics);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to analyze decision",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/drift", async (req, res) => {
+    try {
+      const days = parseInt(req.query.days) || 2;
+      const storage = new ReportStorage(cwd);
+      const history = await storage.loadHistory(days);
+      if (history.length < 2) {
+        res.status(404).json({ error: "Need at least 2 reports for drift analysis" });
+        return;
+      }
+      const currentEntry = history[0];
+      const previousEntry = history[1];
+      if (!currentEntry || !previousEntry) {
+        res.status(400).json({ error: "Invalid history data" });
+        return;
+      }
+      const drift = await detectDrift(currentEntry.report, previousEntry.report);
+      res.json(drift);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to analyze drift",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/trend", async (req, res) => {
+    try {
+      const days = parseInt(req.query.days) || 30;
+      const storage = new ReportStorage(cwd);
+      const history = await storage.loadHistory(days);
+      if (history.length < 2) {
+        res.status(404).json({ error: "Need at least 2 reports for trend analysis" });
+        return;
+      }
+      const trend = await analyzeTrend(history);
+      res.json(trend);
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to analyze trend",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  });
+  app.get("/api/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      project: config.project.name
+    });
+  });
+  const publicDir = join11(__dirname, "public");
+  app.use(express.static(publicDir));
+  app.get("*", (_req, res) => {
+    res.sendFile(join11(publicDir, "index.html"));
+  });
+  return app;
+}
+
+// src/cli/commands/dashboard.ts
+var dashboardCommand = new Command17("dashboard").description("Start compliance dashboard web server").option("-p, --port <port>", "Port to listen on", "3000").option("-h, --host <host>", "Host to bind to", "localhost").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  console.log(chalk15.blue("Starting SpecBridge dashboard..."));
+  try {
+    const config = await loadConfig(cwd);
+    const app = createDashboardServer({ cwd, config });
+    const port = parseInt(options.port || "3000", 10);
+    const host = options.host || "localhost";
+    app.listen(port, host, () => {
+      console.log(chalk15.green(`
+\u2713 Dashboard running at http://${host}:${port}`));
+      console.log(chalk15.gray("  Press Ctrl+C to stop\n"));
+      console.log(chalk15.bold("API Endpoints:"));
+      console.log(`  ${chalk15.cyan(`http://${host}:${port}/api/health`)} - Health check`);
+      console.log(`  ${chalk15.cyan(`http://${host}:${port}/api/report/latest`)} - Latest report`);
+      console.log(`  ${chalk15.cyan(`http://${host}:${port}/api/decisions`)} - All decisions`);
+      console.log(`  ${chalk15.cyan(`http://${host}:${port}/api/analytics/summary`)} - Analytics`);
+      console.log("");
+    });
+    process.on("SIGINT", () => {
+      console.log(chalk15.yellow("\n\nShutting down dashboard..."));
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      console.log(chalk15.yellow("\n\nShutting down dashboard..."));
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error(chalk15.red("Failed to start dashboard:"), error);
+    throw error;
+  }
+});
+
+// src/cli/index.ts
+var __dirname2 = dirname5(fileURLToPath4(import.meta.url));
+var packageJsonPath = join12(__dirname2, "../package.json");
 var packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
-var program = new Command16();
+var program = new Command18();
 program.name("specbridge").description("Architecture Decision Runtime - Transform architectural decisions into executable, verifiable constraints").version(packageJson.version);
 program.addCommand(initCommand);
 program.addCommand(inferCommand);
@@ -4680,6 +5659,8 @@ program.addCommand(lspCommand);
 program.addCommand(watchCommand);
 program.addCommand(mcpServerCommand);
 program.addCommand(promptCommand);
+program.addCommand(analyticsCommand);
+program.addCommand(dashboardCommand);
 program.exitOverride((err) => {
   if (err.code === "commander.help" || err.code === "commander.helpDisplayed") {
     process.exit(0);
@@ -4687,11 +5668,11 @@ program.exitOverride((err) => {
   if (err.code === "commander.version") {
     process.exit(0);
   }
-  console.error(chalk14.red(formatError(err)));
+  console.error(chalk16.red(formatError(err)));
   process.exit(1);
 });
 program.parseAsync(process.argv).catch((error) => {
-  console.error(chalk14.red(formatError(error)));
+  console.error(chalk16.red(formatError(error)));
   process.exit(1);
 });
 //# sourceMappingURL=cli.js.map