openuispec 0.2.19 → 0.2.21

package/dist/status/index.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+/**
+ * Cross-target status summary for OpenUISpec projects.
+ *
+ * Usage:
+ *   openuispec status             # summarize every target
+ *   openuispec status --json      # machine-readable output
+ */
+import { existsSync } from "node:fs";
+import { computeDrift, computeSharedDrift, discoverTargets, explainDrift, findProjectDir, formatBaseline, hasDriftChanges, readOutputDirs, readProjectName, readSharedLayers, readSharedLayerState, resolveOutputDir, stateFilePath, } from "../drift/index.js";
+import { readFileSync } from "node:fs";
+function configuredTargets(projectDir) {
+    try {
+        const manifest = readOutputDirs(projectDir);
+        const keys = Object.keys(manifest);
+        if (keys.length > 0)
+            return keys.sort();
+    }
+    catch {
+        // ignore
+    }
+    // Fallback to common targets when manifest output_dir is absent.
+    return ["android", "ios", "web"];
+}
+function allTargets(projectDir, projectName) {
+    const seen = new Set(configuredTargets(projectDir));
+    for (const target of discoverTargets(projectDir, projectName)) {
+        seen.add(target);
+    }
+    return Array.from(seen).sort();
+}
+function readState(statePath) {
+    return JSON.parse(readFileSync(statePath, "utf-8"));
+}
+function buildTargetStatus(cwd, projectDir, projectName, target) {
+    const outputDir = resolveOutputDir(projectDir, projectName, target);
+    const outputExists = existsSync(outputDir);
+    const path = stateFilePath(projectDir, projectName, target);
+    if (!existsSync(path)) {
+        return {
+            target,
+            output_dir: outputDir,
+            output_exists: outputExists,
+            snapshot: false,
+            snapshot_at: null,
+            baseline: {
+                kind: null,
+                commit: null,
+                branch: null,
+                label: null,
+            },
+            changed: 0,
+            added: 0,
+            removed: 0,
+            behind: false,
+            explain_available: false,
+            status: outputExists ? "needs baseline" : "needs generation",
+            recommended_next_step: outputExists
+                ? `Review the generated output, then run \`openuispec drift --snapshot --target ${target}\` to create the baseline.`
+                : `Run code generation for "${target}", then \`openuispec prepare --target ${target}\` to build the target work bundle.`,
+            note: outputExists
+                ? "Baseline pending — generated code exists but user has not yet confirmed it with a snapshot."
+                : `Output directory not found. Run code generation for "${target}" first.`,
+        };
+    }
+    const state = readState(path);
+    const result = computeDrift(projectDir, state, false);
+    const explanation = explainDrift(projectDir, result);
+    const changed = result.drift.changed.length;
+    const added = result.drift.added.length;
+    const removed = result.drift.removed.length;
+    return {
+        target,
+        output_dir: outputDir,
+        output_exists: outputExists,
+        snapshot: true,
+        snapshot_at: state.snapshot_at,
+        baseline: {
+            kind: state.baseline?.kind ?? null,
+            commit: state.baseline?.commit ?? null,
+            branch: state.baseline?.branch ?? null,
+            label: formatBaseline(state.baseline),
+        },
+        changed,
+        added,
+        removed,
+        behind: changed + added + removed > 0,
+        explain_available: explanation.available,
+        status: changed + added + removed > 0 ? "behind" : "up to date",
+        recommended_next_step: changed + added + removed > 0
+            ? `Run \`openuispec prepare --target ${target}\` to build the target work bundle for the pending spec changes.`
+            : `No immediate action required for "${target}". Re-run \`openuispec status\` after spec changes or after re-baselining.`,
+        note: explanation.available ? undefined : explanation.note,
+    };
+}
+function buildSharedLayerStatus(projectDir, layer) {
+    const state = readSharedLayerState(layer);
+    if (!state) {
+        return {
+            name: layer.name,
+            platforms: layer.platforms,
+            root: layer.root,
+            snapshot: false,
+            snapshot_at: null,
+            generated_by_target: null,
+            has_drift: false,
+            status: "needs generation",
+        };
+    }
+    let hasDrift = false;
+    if (layer.tracks.length > 0) {
+        hasDrift = hasDriftChanges(computeSharedDrift(projectDir, layer).drift);
+    }
+    return {
+        name: layer.name,
+        platforms: layer.platforms,
+        root: layer.root,
+        snapshot: true,
+        snapshot_at: state.snapshot_at,
+        generated_by_target: state.generated_by_target,
+        has_drift: hasDrift,
+        status: hasDrift ? "behind" : "up to date",
+    };
+}
+export function buildStatusResult(cwd = process.cwd()) {
+    const projectDir = findProjectDir(cwd);
+    const projectName = readProjectName(projectDir);
+    const targets = allTargets(projectDir, projectName).map((target) => buildTargetStatus(cwd, projectDir, projectName, target));
+    const sharedLayers = readSharedLayers(projectDir);
+    const sharedLayerStatuses = sharedLayers.length > 0
+        ? sharedLayers.map((layer) => buildSharedLayerStatus(projectDir, layer))
+        : undefined;
+    return {
+        project: projectName,
+        targets,
+        ...(sharedLayerStatuses ? { shared_layers: sharedLayerStatuses } : {}),
+    };
+}
+function printReport(result) {
+    console.log("OpenUISpec Status");
+    console.log("=================");
+    console.log(`Project: ${result.project}`);
+    console.log("");
+    for (const target of result.targets) {
+        const summary = target.snapshot
+            ? `${target.changed} changed, ${target.added} added, ${target.removed} removed`
+            : target.output_exists
+                ? "no snapshot"
+                : "output missing";
+        console.log(`${target.target}`);
+        console.log(`  output: ${target.output_dir}`);
+        console.log(`  output exists: ${target.output_exists ? "yes" : "no"}`);
+        console.log(`  snapshot: ${target.snapshot ? target.snapshot_at : "missing"}`);
+        if (target.baseline.label) {
+            console.log(`  baseline: ${target.baseline.label}`);
+        }
+        console.log(`  drift: ${summary}`);
+        console.log(`  status: ${target.status}`);
+        console.log(`  explain: ${target.explain_available ? "available" : "unavailable"}`);
+        if (target.note) {
+            console.log(`  note: ${target.note}`);
+        }
+        console.log(`  next: ${target.recommended_next_step}`);
+        console.log("");
+    }
+    if (result.shared_layers && result.shared_layers.length > 0) {
+        console.log("Shared Layers");
+        console.log("─────────────");
+        for (const layer of result.shared_layers) {
+            console.log(`${layer.name} (${layer.platforms.join(", ")})`);
+            console.log(`  root: ${layer.root}`);
+            console.log(`  snapshot: ${layer.snapshot ? layer.snapshot_at : "missing"}`);
+            if (layer.generated_by_target) {
+                console.log(`  generated by: ${layer.generated_by_target}`);
+            }
+            console.log(`  status: ${layer.status}`);
+            console.log("");
+        }
+    }
+}
+export function runStatus(argv) {
+    const isJson = argv.includes("--json");
+    const result = buildStatusResult(process.cwd());
+    if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    printReport(result);
+}
+const isDirectRun = process.argv[1]?.endsWith("status/index.ts") ||
+    process.argv[1]?.endsWith("status/index.js");
+if (isDirectRun) {
+    runStatus(process.argv.slice(2));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openuispec",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "license": "MIT",
   "type": "module",
   "description": "A semantic UI specification format for AI-native, platform-native app development",
@@ -10,27 +10,23 @@
     "url": "https://github.com/rsktash/openuispec.git"
   },
   "files": [
-    "cli/",
-    "check/",
-    "drift/",
-    "mcp-server/",
-    "prepare/",
-    "status/",
-    "schema/",
+    "dist/",
+    "cli/target-presets.json",
+    "schema/**/*.json",
     "spec/",
     "docs/",
     "examples/*/openuispec/**",
     "examples/*/openuispec.yaml",
     "examples/*/README.md",
-    "scripts/",
     "README.md",
     "LICENSE"
   ],
   "bin": {
-    "openuispec": "./cli/index.ts",
-    "openuispec-mcp": "./mcp-server/index.ts"
+    "openuispec": "./dist/cli/index.js",
+    "openuispec-mcp": "./dist/mcp-server/index.js"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/fix-dist-bins.mjs",
     "test": "node --import tsx --test tests/check.test.ts tests/configure-target.test.ts tests/drift-prepare.test.ts tests/init.test.ts tests/mcp-tools.test.ts tests/semantic-lint.test.ts tests/status.test.ts",
     "test:screenshot": "node --import tsx --test tests/mcp-screenshot.test.ts",
     "test:all": "node --import tsx --test tests/*.test.ts",
@@ -45,6 +41,8 @@
     "drift:snapshot": "tsx drift/index.ts --snapshot --target",
     "prepare:target": "tsx prepare/index.ts",
     "status": "tsx status/index.ts",
+    "prepare": "npm run build",
+    "prepack": "npm run build",
     "postinstall": "echo \"\\n  ✓ openuispec installed — if upgrading, run: openuispec update-rules\\n\"",
     "cloc": "cloc --exclude-dir=$(tr '\n' ',' < .cloc-ignore) ."
   },
@@ -52,14 +50,15 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "tsx": "^4.19.4",
-    "yaml": "^2.7.1"
+    "yaml": "^2.7.1",
+    "zod": "^3.25.76"
   },
   "optionalDependencies": {
-    "puppeteer": "^24.39.1"
+    "playwright": "^1.52.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
+    "tsx": "^4.19.4",
     "typescript": "^5.8.3"
   }
 }

package/check/audit.ts

@@ -1,426 +0,0 @@
-/**
- * Design quality audit for OpenUISpec projects.
- *
- * Checks token patterns and contract completeness to produce a numeric quality score.
- * Score formula: max(0, 100 - errors × 10 - warnings × 3)
- *
- * Usage:
- *   openuispec check --target web --audit
- *   openuispec check --target ios --audit --min-score 70
- *   openuispec check --target web --audit --format json
- */
-
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join, resolve } from "node:path";
-import YAML from "yaml";
-
-export interface AuditFinding {
-  domain: string;
-  rule: string;
-  severity: "error" | "warning";
-  message: string;
-}
-
-export interface AuditResult {
-  score: number;
-  errors: number;
-  warnings: number;
-  findings: AuditFinding[];
-  passed: boolean;
-  threshold: number;
-}
-
-const AI_DEFAULT_FONTS = new Set(["Inter", "Roboto", "Arial", "Open Sans"]);
-const REQUIRED_TOKEN_FILES = [
-  "color.yaml",
-  "typography.yaml",
-  "spacing.yaml",
-  "elevation.yaml",
-  "motion.yaml",
-  "layout.yaml",
-  "themes.yaml",
-  "icons.yaml",
-];
-
-function readYaml(path: string): any {
-  try {
-    return YAML.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-function readYamlForAudit(path: string, domain: string, findings: AuditFinding[]): any {
-  try {
-    return YAML.parse(readFileSync(path, "utf-8"));
-  } catch (err: any) {
-    if (err?.code === "ENOENT") return null;
-    findings.push({
-      domain,
-      rule: "unreadable_file",
-      severity: "error",
-      message: `Could not parse "${path}". Fix malformed YAML before relying on this audit.`,
-    });
-    return null;
-  }
-}
-
-function checkRequiredTokenFiles(tokensDir: string, findings: AuditFinding[]): void {
-  for (const filename of REQUIRED_TOKEN_FILES) {
-    if (!existsSync(join(tokensDir, filename))) {
-      findings.push({
-        domain: "tokens",
-        rule: "missing_file",
-        severity: "error",
-        message: `Required token file "${filename}" is missing.`,
-      });
-    }
-  }
-}
-
-function checkTypography(tokensDir: string, findings: AuditFinding[]): void {
-  const doc = readYamlForAudit(join(tokensDir, "typography.yaml"), "typography", findings);
-  if (!doc?.typography) return;
-
-  // Font diversity: primary must NOT be a common AI default
-  const primaryFont = doc.typography.font_family?.primary?.value;
-  if (typeof primaryFont === "string" && AI_DEFAULT_FONTS.has(primaryFont)) {
-    findings.push({
-      domain: "typography",
-      rule: "font_diversity",
-      severity: "error",
-      message: `Primary font "${primaryFont}" is an AI-default choice. Use a distinctive brand font.`,
-    });
-  }
-
-  // Scale usage: at least 4 distinct scale levels defined
-  const scaleKeys = Object.keys(doc.typography.scale ?? {});
-  if (scaleKeys.length > 0 && scaleKeys.length < 4) {
-    findings.push({
-      domain: "typography",
-      rule: "scale_usage",
-      severity: "warning",
-      message: `Only ${scaleKeys.length} type scale level(s) defined. Use ≥4 distinct levels for clear hierarchy.`,
-    });
-  }
-
-  // Weight hierarchy: at least 2 distinct weights
-  if (doc.typography.scale) {
-    const weights = new Set<number>();
-    for (const level of Object.values(doc.typography.scale)) {
-      if (typeof (level as any)?.weight === "number") {
-        weights.add((level as any).weight);
-      }
-    }
-    if (weights.size > 0 && weights.size < 2) {
-      findings.push({
-        domain: "typography",
-        rule: "weight_hierarchy",
-        severity: "warning",
-        message: "Only 1 distinct font weight used across the type scale. Use ≥2 weights (e.g. 400 + 700) for clear hierarchy.",
-      });
-    }
-  }
-}
-
-function checkColor(tokensDir: string, findings: AuditFinding[]): void {
-  const doc = readYamlForAudit(join(tokensDir, "color.yaml"), "color", findings);
-  if (!doc?.color) return;
-
-  // Pure black/white check
-  function scanForPure(obj: any, path: string): void {
-    if (typeof obj !== "object" || obj === null) return;
-    if (typeof obj.reference === "string") {
-      const ref = obj.reference.toUpperCase();
-      if (ref === "#000000" || ref === "#000") {
-        findings.push({
-          domain: "color",
-          rule: "pure_black",
-          severity: "error",
-          message: `Token at ${path} uses pure black (#000000). Use a near-black with hue instead.`,
-        });
-      }
-      if (ref === "#FFFFFF" || ref === "#FFF") {
-        findings.push({
-          domain: "color",
-          rule: "pure_white",
-          severity: "error",
-          message: `Token at ${path} uses pure white (#FFFFFF). Use a slightly tinted white instead.`,
-        });
-      }
-    }
-    for (const [key, value] of Object.entries(obj)) {
-      if (key !== "reference" && typeof value === "object") {
-        scanForPure(value, `${path}.${key}`);
-      }
-    }
-  }
-  scanForPure(doc.color, "color");
-
-  // Semantic color completeness: success, warning, danger, info
-  if (doc.color.semantic) {
-    const required = ["success", "warning", "danger", "info"];
-    const defined = Object.keys(doc.color.semantic);
-    for (const name of required) {
-      if (!defined.includes(name)) {
-        findings.push({
-          domain: "color",
-          rule: "semantic_completeness",
-          severity: "warning",
-          message: `Semantic color "${name}" is missing. Define all four (success, warning, danger, info) for complete state coverage.`,
-        });
-      }
-    }
-  }
-
-  // Theme coverage: check themes.yaml for both light + dark
-  {
-    const themes = readYamlForAudit(join(tokensDir, "themes.yaml"), "color", findings);
-    if (!themes?.themes) return;
-    const themeKeys = Object.keys(themes.themes);
-    const hasLight = themeKeys.some((k) => k.includes("light"));
-    const hasDark = themeKeys.some((k) => k.includes("dark"));
-    if (!hasLight || !hasDark) {
-      findings.push({
-        domain: "color",
-        rule: "theme_coverage",
-        severity: "warning",
-        message: "Both light and dark themes should be defined in tokens/themes.yaml.",
-      });
-    }
-  }
-}
-
-function checkSpacing(tokensDir: string, findings: AuditFinding[]): void {
-  const doc = readYamlForAudit(join(tokensDir, "spacing.yaml"), "spacing", findings);
-  if (!doc?.spacing) return;
-
-  // Scale usage: at least 4 distinct values
-  const scale = doc.spacing.scale ?? {};
-  const scaleCount = Object.keys(scale).length;
-  if (scaleCount > 0 && scaleCount < 4) {
-    findings.push({
-      domain: "spacing",
-      rule: "scale_usage",
-      severity: "warning",
-      message: `Only ${scaleCount} spacing scale value(s) defined. Define ≥4 for meaningful spatial rhythm.`,
-    });
-  }
-
-  // Alias usage: page_margin and card_padding should exist
-  const aliases = doc.spacing.aliases ?? {};
-  const aliasKeys = Object.keys(aliases).map((k) => k.toLowerCase());
-  if (!aliasKeys.some((k) => k.includes("page_margin") || k.includes("page"))) {
-    findings.push({
-      domain: "spacing",
-      rule: "alias_page_margin",
-      severity: "warning",
-      message: "No page_margin alias found in spacing tokens. Define it for consistent screen padding.",
-    });
-  }
-  if (!aliasKeys.some((k) => k.includes("card_padding") || k.includes("card"))) {
-    findings.push({
-      domain: "spacing",
-      rule: "alias_card_padding",
-      severity: "warning",
-      message: "No card_padding alias found in spacing tokens. Define it for consistent card spacing.",
-    });
-  }
-}
-
-function checkMotion(tokensDir: string, findings: AuditFinding[]): void {
-  const doc = readYamlForAudit(join(tokensDir, "motion.yaml"), "motion", findings);
-  if (!doc?.motion) return;
-
-  // Duration variety: at least 2 distinct durations
-  const durations = doc.motion.duration ?? {};
-  const distinctDurations = new Set(Object.values(durations));
-  if (Object.keys(durations).length > 0 && distinctDurations.size < 2) {
-    findings.push({
-      domain: "motion",
-      rule: "duration_variety",
-      severity: "warning",
-      message: "Only 1 distinct duration value found. Use ≥2 distinct durations (e.g. quick + normal).",
-    });
-  }
-
-  // Reduced motion: must be defined
-  if (!doc.motion.reduced_motion) {
-    findings.push({
-      domain: "motion",
-      rule: "reduced_motion",
-      severity: "error",
-      message: "motion.reduced_motion is not defined. Must specify policy for prefers-reduced-motion.",
-    });
-  }
-
-  // Easing quality: enter + exit curves, at least one cubic-bezier
-  if (doc.motion.easing) {
-    const easings = doc.motion.easing;
-    const keys = Object.keys(easings);
-    if (!keys.includes("enter") || !keys.includes("exit")) {
-      findings.push({
-        domain: "motion",
-        rule: "easing_quality",
-        severity: "warning",
-        message: "Motion easing should define at least 'enter' and 'exit' curves for asymmetric transitions.",
-      });
-    }
-    const hasCubicBezier = Object.values(easings).some(
-      (v) => typeof v === "string" && v.includes("cubic-bezier"),
-    );
-    if (!hasCubicBezier) {
-      findings.push({
-        domain: "motion",
-        rule: "easing_quality",
-        severity: "warning",
-        message: "All easing curves are generic keywords. Use at least one cubic-bezier() for nuanced motion.",
-      });
-    }
-  }
-}
-
-function checkElevationProgression(tokensDir: string, findings: AuditFinding[]): void {
-  const doc = readYamlForAudit(join(tokensDir, "elevation.yaml"), "elevation", findings);
-  if (!doc?.elevation) return;
-  const levels = Object.keys(doc.elevation).filter((k) => k !== "none");
-  if (levels.length < 2) {
-    findings.push({
-      domain: "elevation",
-      rule: "level_count",
-      severity: "warning",
-      message: `Only ${levels.length} non-none elevation level(s) defined. Define ≥2 (e.g. sm, md, lg) for meaningful depth hierarchy.`,
-    });
-    return;
-  }
-  const androidValues: number[] = [];
-  for (const level of levels) {
-    const val = doc.elevation[level]?.platform?.android?.elevation;
-    if (typeof val === "number") androidValues.push(val);
-  }
-  if (androidValues.length >= 2) {
-    for (let i = 1; i < androidValues.length; i++) {
-      if (androidValues[i] <= androidValues[i - 1]) {
-        findings.push({
-          domain: "elevation",
-          rule: "progression",
-          severity: "warning",
-          message: "Elevation levels do not increase monotonically. Each level should cast a deeper shadow than the previous.",
-        });
-        break;
-      }
-    }
-  }
-}
-
-function checkLayoutSizeClasses(tokensDir: string, findings: AuditFinding[]): void {
-  const doc = readYamlForAudit(join(tokensDir, "layout.yaml"), "layout", findings);
-  if (!doc?.layout?.size_classes) return;
-  const classes = Object.keys(doc.layout.size_classes);
-  if (classes.length < 2) {
-    findings.push({
-      domain: "layout",
-      rule: "size_class_coverage",
-      severity: "warning",
-      message: `Only ${classes.length} size class(es) defined. Define at least compact + regular for responsive layouts.`,
-    });
-  } else if (!classes.includes("compact")) {
-    findings.push({
-      domain: "layout",
-      rule: "size_class_coverage",
-      severity: "warning",
-      message: "No 'compact' size class defined. Mobile-first layouts require a compact breakpoint.",
-    });
-  }
-}
-
-function checkContractStateCoverage(contractsDir: string, findings: AuditFinding[]): void {
-  if (!existsSync(contractsDir)) return;
-  for (const file of readdirSync(contractsDir).filter((f) => f.endsWith(".yaml") && !f.startsWith("x_"))) {
-    const doc = readYamlForAudit(join(contractsDir, file), "contracts", findings);
-    if (!doc) continue;
-    const contractName = Object.keys(doc)[0];
-    const contract = doc[contractName];
-    const mustHandle: string[] = contract?.generation?.must_handle ?? [];
-    if (mustHandle.length === 0) {
-      findings.push({
-        domain: "contracts",
-        rule: "state_coverage",
-        severity: "warning",
-        message: `Contract "${contractName}" has no generation.must_handle entries. Define required states for AI compliance.`,
-      });
-    }
-  }
-}
-
-function checkContracts(contractsDir: string, findings: AuditFinding[]): void {
-  // All collections have empty_state in must_handle or variants
-  {
-    const doc = readYamlForAudit(join(contractsDir, "collection.yaml"), "contracts", findings);
-    const collection = doc ? doc[Object.keys(doc)[0]] : null;
-    if (collection) {
-      const mustHandle: string[] = collection.generation?.must_handle ?? [];
-      const hasEmptyState = mustHandle.some((s: string) => s.toLowerCase().includes("empty"));
-      if (!hasEmptyState) {
-        findings.push({
-          domain: "contracts",
-          rule: "collection_empty_state",
-          severity: "warning",
-          message: "collection contract does not list empty_state handling in generation.must_handle.",
-        });
-      }
-    }
-  }
-}
-
-export function buildAuditResult(projectDir: string, threshold: number = 0): AuditResult {
-  const manifest = readYaml(join(projectDir, "openuispec.yaml"));
-  const tokensDir = resolve(projectDir, manifest?.includes?.tokens ?? "./tokens/");
-  const contractsDir = resolve(projectDir, manifest?.includes?.contracts ?? "./contracts/");
-
-  // Use audit_threshold from manifest if no CLI override
-  const effectiveThreshold = threshold > 0 ? threshold : (manifest?.generation_guidance?.audit_threshold ?? 0);
-
-  const findings: AuditFinding[] = [];
-  checkRequiredTokenFiles(tokensDir, findings);
-  checkTypography(tokensDir, findings);
-  checkColor(tokensDir, findings);
-  checkSpacing(tokensDir, findings);
-  checkMotion(tokensDir, findings);
-  checkElevationProgression(tokensDir, findings);
-  checkLayoutSizeClasses(tokensDir, findings);
-  checkContracts(contractsDir, findings);
-  checkContractStateCoverage(contractsDir, findings);
-
-  const errors = findings.filter((f) => f.severity === "error").length;
-  const warnings = findings.filter((f) => f.severity === "warning").length;
-  const score = Math.max(0, 100 - errors * 10 - warnings * 3);
-
-  return {
-    score,
-    errors,
-    warnings,
-    findings,
-    passed: score >= effectiveThreshold,
-    threshold: effectiveThreshold,
-  };
-}
-
-export function formatAuditResult(result: AuditResult): string {
-  const lines: string[] = [
-    `Design Quality Score: ${result.score}/100`,
-    `Errors: ${result.errors}  Warnings: ${result.warnings}`,
-    result.threshold > 0 ? `Threshold: ${result.threshold} — ${result.passed ? "PASS" : "FAIL"}` : "",
-    "",
-  ].filter((l) => l !== "" || lines?.length === 0);
-
-  if (result.findings.length === 0) {
-    lines.push("No issues found.");
-  } else {
-    for (const f of result.findings) {
-      lines.push(`[${f.severity.toUpperCase()}] [${f.domain}] ${f.message}`);
-    }
-  }
-
-  return lines.join("\n");
-}