@decantr/cli 2.5.1 → 2.6.0

package/dist/{chunk-OD46PCR6.js → chunk-PAF4PBD3.js}

@@ -1,15 +1,17 @@
 import {
   collectCheckIssues
-} from "./chunk-NBJCO4G5.js";
+} from "./chunk-3TH5PLFO.js";
 import {
   sendProjectHealthCiFailedTelemetry,
   sendProjectHealthPromptTelemetry,
   sendProjectHealthReportTelemetry
-} from "./chunk-IEW2QFYI.js";
+} from "./chunk-KT2ROK2D.js";
 
 // src/commands/health.ts
-import { createRequire } from "module";
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { createRequire } from "module";
 import { dirname, isAbsolute, join, resolve } from "path";
 import { fileURLToPath } from "url";
 import {
@@ -228,12 +230,32 @@ function sourceFromCheckIssue(issue) {
 function slugify(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
 }
+function hashFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return createHash("sha256").update(readFileSync(path)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function readJsonFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
 function commandsForFinding(source) {
   switch (source) {
     case "brownfield":
       return ["decantr analyze", "decantr init --existing --merge-proposal", "decantr health"];
     case "pack":
-      return ["decantr refresh", "decantr registry get-pack review --write-context", "decantr health"];
+      return [
+        "decantr refresh",
+        "decantr registry get-pack review --write-context",
+        "decantr health"
+      ];
     case "runtime":
       return ["npm run build", "decantr health"];
     case "interaction":
@@ -317,7 +339,10 @@ function statusFromCounts(counts) {
   return "healthy";
 }
 function scoreFromCounts(counts) {
-  return Math.max(0, Math.min(100, 100 - counts.errorCount * 15 - counts.warnCount * 5 - counts.infoCount));
+  return Math.max(
+    0,
+    Math.min(100, 100 - counts.errorCount * 15 - counts.warnCount * 5 - counts.infoCount)
+  );
 }
 function routeIssuesFromFindings(findings) {
   const issues = findings.filter(
@@ -440,6 +465,7 @@ async function collectBrowserVerification(projectRoot, options, declaredRoutes)
   const routes = (declaredRoutes.length > 0 ? declaredRoutes : ["/"]).slice(0, 12);
   const screenshots = [];
   const browserFindings = [];
+  const visualRoutes = [];
   const screenshotDir = join(projectRoot, ".decantr", "evidence", "screenshots");
   mkdirSync(screenshotDir, { recursive: true });
   let browser = null;
@@ -451,10 +477,27 @@ async function collectBrowserVerification(projectRoot, options, declaredRoutes)
       const relativePath = browserScreenshotRelativePath(route);
       try {
         await page.goto(url, { waitUntil: "networkidle", timeout: 15e3 });
-        await page.screenshot({ path: join(projectRoot, relativePath), fullPage: true });
+        const absoluteScreenshotPath = join(projectRoot, relativePath);
+        await page.screenshot({ path: absoluteScreenshotPath, fullPage: true });
         screenshots.push(relativePath);
+        visualRoutes.push({
+          route,
+          url,
+          screenshot: relativePath,
+          screenshotHash: hashFile(absoluteScreenshotPath),
+          status: "captured"
+        });
       } catch (error) {
-        browserFindings.push(`${route}: ${error.message}`);
+        const message = error.message;
+        browserFindings.push(`${route}: ${message}`);
+        visualRoutes.push({
+          route,
+          url,
+          screenshot: null,
+          screenshotHash: null,
+          status: "failed",
+          error: message
+        });
       }
     }
   } catch (error) {
@@ -462,6 +505,16 @@ async function collectBrowserVerification(projectRoot, options, declaredRoutes)
   } finally {
     if (browser) await browser.close();
   }
+  const visualManifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    localOnly: true,
+    baseUrl: options.browserBaseUrl,
+    routes: visualRoutes
+  };
+  const visualManifestPath = join(projectRoot, ".decantr", "evidence", "visual-manifest.json");
+  mkdirSync(dirname(visualManifestPath), { recursive: true });
+  writeFileSync(visualManifestPath, JSON.stringify(visualManifest, null, 2) + "\n", "utf-8");
   if (browserFindings.length > 0) {
     const finding = createHealthFinding({
       source: "browser",
@@ -575,6 +628,139 @@ function collectDesignTokenFinding(projectRoot, designTokensPath) {
     baseId: "coverage-missing"
   });
 }
+function baselinePath(projectRoot) {
+  return join(projectRoot, ".decantr", "health-baseline.json");
+}
+function baselineDiffPath(projectRoot) {
+  return join(projectRoot, ".decantr", "health-baseline-diff.json");
+}
+function screenshotHashes(projectRoot) {
+  const manifest = readJsonFile(
+    join(projectRoot, ".decantr", "evidence", "visual-manifest.json")
+  );
+  if (manifest?.routes) {
+    return manifest.routes.filter((route) => typeof route.screenshot === "string").map((route) => ({
+      path: route.screenshot,
+      hash: route.screenshotHash ?? hashFile(join(projectRoot, route.screenshot))
+    }));
+  }
+  return [];
+}
+function changedFilesSinceBaseline(projectRoot) {
+  const changed = /* @__PURE__ */ new Set();
+  try {
+    for (const args of [
+      ["diff", "--name-only"],
+      ["diff", "--name-only", "--cached"]
+    ]) {
+      const output = execFileSync("git", args, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      for (const entry of output.split(/\r?\n/)) {
+        const file = entry.trim();
+        if (file) changed.add(file);
+      }
+    }
+  } catch {
+  }
+  return [...changed].sort();
+}
+function routeImpactsFromChangedFiles(report, changedFiles) {
+  const analysis = readJsonFile(
+    join(report.projectRoot, ".decantr", "analysis.json")
+  );
+  const routeEntries = analysis?.routes?.routes ?? [];
+  const impacted = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    for (const route of routeEntries) {
+      if (route.file && (file === route.file || file.endsWith(route.file))) {
+        if (route.path) impacted.add(route.path);
+      }
+    }
+  }
+  return [...impacted].sort();
+}
+function createHealthBaseline(projectRoot, report) {
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: report.status,
+    score: report.score,
+    findings: report.findings.map((finding) => ({
+      id: finding.id,
+      severity: finding.severity,
+      source: finding.source,
+      message: finding.message
+    })),
+    routes: report.routes.declared,
+    packs: report.packs,
+    screenshots: screenshotHashes(projectRoot),
+    changedFilesCommand: "git diff --name-only + --cached"
+  };
+}
+function saveHealthBaseline(projectRoot, report) {
+  const path = baselinePath(projectRoot);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(
+    path,
+    JSON.stringify(createHealthBaseline(projectRoot, report), null, 2) + "\n",
+    "utf-8"
+  );
+  return path;
+}
+function compareHealthBaseline(projectRoot, report) {
+  const path = baselinePath(projectRoot);
+  const baseline = readJsonFile(path);
+  const currentFindingIds = new Set(report.findings.map((finding) => finding.id));
+  const baselineFindingIds = new Set(baseline?.findings.map((finding) => finding.id) ?? []);
+  const changedFiles = changedFilesSinceBaseline(projectRoot);
+  const currentScreenshots = new Map(
+    screenshotHashes(projectRoot).map((entry) => [entry.path, entry.hash])
+  );
+  const changedScreenshots = baseline?.screenshots.filter(
+    (entry) => currentScreenshots.has(entry.path) && currentScreenshots.get(entry.path) !== entry.hash
+  ).map((entry) => entry.path) ?? [];
+  const contractDrift = [
+    baseline && baseline.routes.join("\n") !== report.routes.declared.join("\n") ? "Declared route set changed since baseline." : null,
+    baseline && baseline.packs.generatedAt !== report.packs.generatedAt ? "Execution-pack generation timestamp changed since baseline." : null
+  ].filter((entry) => Boolean(entry));
+  return {
+    baselinePath: path,
+    savedAt: baseline?.generatedAt ?? null,
+    statusChanged: baseline ? baseline.status !== report.status : false,
+    scoreDelta: baseline ? report.score - baseline.score : null,
+    addedFindings: [...currentFindingIds].filter((id) => !baselineFindingIds.has(id)).sort(),
+    resolvedFindings: [...baselineFindingIds].filter((id) => !currentFindingIds.has(id)).sort(),
+    changedFiles,
+    changedRoutes: routeImpactsFromChangedFiles(report, changedFiles),
+    changedScreenshots,
+    contractDrift
+  };
+}
+function saveHealthBaselineComparison(projectRoot, comparison) {
+  const path = baselineDiffPath(projectRoot);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(comparison, null, 2) + "\n", "utf-8");
+  return path;
+}
+function formatBaselineComparisonText(comparison) {
+  const lines = [
+    "",
+    `${BOLD}Continuity:${RESET}`,
+    `  Baseline: ${comparison.savedAt ?? "missing"} (${comparison.baselinePath})`,
+    `  Score delta: ${comparison.scoreDelta == null ? "n/a" : comparison.scoreDelta >= 0 ? `+${comparison.scoreDelta}` : String(comparison.scoreDelta)}`,
+    `  Added findings: ${comparison.addedFindings.length}`,
+    `  Resolved findings: ${comparison.resolvedFindings.length}`,
+    `  Changed files: ${comparison.changedFiles.length}`,
+    `  Route impact: ${comparison.changedRoutes.length > 0 ? comparison.changedRoutes.join(", ") : "none detected"}`,
+    `  Screenshot drift: ${comparison.changedScreenshots.length}`,
+    `  Contract drift: ${comparison.contractDrift.length > 0 ? comparison.contractDrift.join(" ") : "none detected"}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
 async function browserEvidenceFromOptions(projectRoot, options, declaredRoutes) {
   if (!options.browser) return void 0;
   const result = await collectBrowserVerification(projectRoot, options, declaredRoutes);
@@ -663,7 +849,11 @@ async function createProjectHealthReport(projectRoot = process.cwd(), options =
   }
   const declaredRoutes = collectDeclaredRoutes(audit.essence);
   const manifest = audit.packManifest;
-  const browserVerification = await collectBrowserVerification(projectRoot, options, declaredRoutes);
+  const browserVerification = await collectBrowserVerification(
+    projectRoot,
+    options,
+    declaredRoutes
+  );
   if (browserVerification?.finding && !isDuplicateFinding(seen, browserVerification.finding)) {
     findings.push(browserVerification.finding);
   }
@@ -850,6 +1040,8 @@ async function cmdHealth(projectRoot = process.cwd(), options = {}) {
     designTokensPath: options.designTokensPath
   };
   const report = await createProjectHealthReport(projectRoot, reportOptions);
+  const baselineComparison = options.sinceBaseline ? compareHealthBaseline(projectRoot, report) : null;
+  const baselineComparisonPath = baselineComparison ? saveHealthBaselineComparison(projectRoot, baselineComparison) : null;
   if (options.promptId) {
     const finding = report.findings.find((entry) => entry.id === options.promptId);
     await sendProjectHealthReportTelemetry({
@@ -874,8 +1066,9 @@ async function cmdHealth(projectRoot = process.cwd(), options = {}) {
   }
   const format = resolveFormat(options);
   const failOn = options.failOn ?? "error";
-  const payload = options.evidence ? `${JSON.stringify(await createProjectEvidenceBundle(projectRoot, report, reportOptions), null, 2)}
+  const basePayload = options.evidence ? `${JSON.stringify(await createProjectEvidenceBundle(projectRoot, report, reportOptions), null, 2)}
 ` : format === "json" ? formatProjectHealthJson(report) : format === "markdown" ? formatProjectHealthMarkdown(report) : formatProjectHealthText(report);
+  const payload = baselineComparison && !options.evidence && format === "text" ? `${basePayload}${formatBaselineComparisonText(baselineComparison)}` : basePayload;
   if (options.output) {
     const outputPath = isAbsolute(options.output) ? options.output : join(projectRoot, options.output);
     mkdirSync(dirname(outputPath), { recursive: true });
@@ -897,6 +1090,19 @@ async function cmdHealth(projectRoot = process.cwd(), options = {}) {
     projectRoot,
     report
   });
+  if (options.saveBaseline) {
+    const path = saveHealthBaseline(projectRoot, report);
+    if (!options.ci && !options.output && format !== "json" && !options.evidence) {
+      console.log(`${GREEN}Saved Decantr health baseline:${RESET} ${path}`);
+    } else if (!options.ci && options.output) {
+      console.log(`${GREEN}Saved Decantr health baseline:${RESET} ${path}`);
+    }
+  }
+  if (baselineComparisonPath && !options.ci && options.output) {
+    console.log(
+      `${GREEN}Wrote Decantr health baseline comparison:${RESET} ${baselineComparisonPath}`
+    );
+  }
   if (options.ci && shouldFailHealth(report, failOn)) {
     if (failOn !== "none") {
       await sendProjectHealthCiFailedTelemetry({
@@ -968,6 +1174,10 @@ function parseHealthArgs(args) {
     } else if (arg === "--require-browser") {
       options.browser = true;
       options.requireBrowser = true;
+    } else if (arg === "--save-baseline") {
+      options.saveBaseline = true;
+    } else if (arg === "--since-baseline") {
+      options.sinceBaseline = true;
     } else if (arg === "--base-url" && args[index + 1]) {
       options.browserBaseUrl = args[++index];
     } else if (arg.startsWith("--base-url=")) {