@vibgrate/cli 1.0.44 → 1.0.46

package/dist/{chunk-GN3IWKSY.js → chunk-PTMLMDZU.js}

@@ -51,6 +51,26 @@ function formatMarkdown(artifact) {
     }
     lines.push("");
   }
+  if (artifact.extended?.uiPurpose) {
+    const up = artifact.extended.uiPurpose;
+    lines.push("## Product Purpose Signals");
+    lines.push("");
+    lines.push(`- **Frameworks:** ${up.detectedFrameworks.length > 0 ? up.detectedFrameworks.join(", ") : "unknown"}`);
+    lines.push(`- **Evidence Items:** ${up.topEvidence.length}${up.capped ? ` (capped from ${up.evidenceCount})` : ""}`);
+    if (up.topEvidence.length > 0) {
+      lines.push("- **Top Evidence:**");
+      for (const item of up.topEvidence.slice(0, 10)) {
+        lines.push(`  - [${item.kind}] ${item.value} (${item.file})`);
+      }
+    }
+    if (up.unknownSignals.length > 0) {
+      lines.push("- **Unknowns:**");
+      for (const u of up.unknownSignals.slice(0, 5)) {
+        lines.push(`  - ${u}`);
+      }
+    }
+    lines.push("");
+  }
   if (artifact.findings.length > 0) {
     lines.push("## Findings");
     lines.push("");

package/dist/{chunk-LO66M6OC.js → chunk-SKROLJET.js}

@@ -1,6 +1,6 @@
 import {
   runScan
-} from "./chunk-YFJC5JSQ.js";
+} from "./chunk-HEILEAVO.js";
 import {
   writeJsonFile
 } from "./chunk-RNVZIZNL.js";

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   formatMarkdown
-} from "./chunk-GN3IWKSY.js";
+} from "./chunk-PTMLMDZU.js";
 import {
   baselineCommand
-} from "./chunk-LO66M6OC.js";
+} from "./chunk-SKROLJET.js";
 import {
   VERSION,
   dsnCommand,
@@ -12,16 +12,17 @@ import {
   pushCommand,
   scanCommand,
   writeDefaultConfig
-} from "./chunk-YFJC5JSQ.js";
+} from "./chunk-HEILEAVO.js";
 import {
   ensureDir,
   pathExists,
-  readJsonFile
+  readJsonFile,
+  writeTextFile
 } from "./chunk-RNVZIZNL.js";
 
 // src/cli.ts
-import { Command as Command4 } from "commander";
-import chalk4 from "chalk";
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
 
 // src/commands/init.ts
 import * as path from "path";
@@ -40,7 +41,7 @@ var initCommand = new Command("init").description("Initialize vibgrate in a proj
     console.log(chalk.green("\u2714") + ` Created ${chalk.bold("vibgrate.config.ts")}`);
   }
   if (opts.baseline) {
-    const { runBaseline } = await import("./baseline-FDWMBM2O.js");
+    const { runBaseline } = await import("./baseline-AWRL3ITR.js");
     await runBaseline(rootDir);
   }
   console.log("");
@@ -222,8 +223,186 @@ var updateCommand = new Command3("update").description("Update vibgrate to the l
   }
 });
 
+// src/commands/sbom.ts
+import * as path5 from "path";
+import { randomUUID } from "crypto";
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+function flattenDependencies(artifact) {
+  const rows = [];
+  for (const project of artifact.projects) {
+    for (const dep of project.dependencies) {
+      rows.push({
+        project: project.name,
+        package: dep.package,
+        version: dep.resolvedVersion ?? dep.currentSpec,
+        currentSpec: dep.currentSpec,
+        drift: dep.drift,
+        majorsBehind: dep.majorsBehind
+      });
+    }
+  }
+  return rows;
+}
+function toCycloneDx(artifact) {
+  const dependencies = flattenDependencies(artifact);
+  return {
+    bomFormat: "CycloneDX",
+    specVersion: "1.5",
+    serialNumber: `urn:uuid:${randomUUID()}`,
+    version: 1,
+    metadata: {
+      timestamp: artifact.timestamp,
+      tools: [
+        {
+          vendor: "Vibgrate",
+          name: "@vibgrate/cli",
+          version: artifact.vibgrateVersion
+        }
+      ],
+      component: {
+        type: "application",
+        name: artifact.rootPath
+      }
+    },
+    components: dependencies.map((dep) => ({
+      type: "library",
+      name: dep.package,
+      version: dep.version,
+      properties: [
+        { name: "vibgrate:project", value: dep.project },
+        { name: "vibgrate:currentSpec", value: dep.currentSpec },
+        { name: "vibgrate:drift", value: dep.drift },
+        { name: "vibgrate:majorsBehind", value: String(dep.majorsBehind ?? "unknown") }
+      ]
+    }))
+  };
+}
+function toSpdx(artifact) {
+  const dependencies = flattenDependencies(artifact);
+  return {
+    spdxVersion: "SPDX-2.3",
+    dataLicense: "CC0-1.0",
+    SPDXID: "SPDXRef-DOCUMENT",
+    name: `${artifact.rootPath}-sbom`,
+    documentNamespace: `https://vibgrate.com/spdx/${artifact.rootPath}/${randomUUID()}`,
+    creationInfo: {
+      created: artifact.timestamp,
+      creators: [`Tool: @vibgrate/cli-${artifact.vibgrateVersion}`]
+    },
+    packages: dependencies.map((dep, i) => ({
+      name: dep.package,
+      SPDXID: `SPDXRef-Package-${i + 1}`,
+      versionInfo: dep.version,
+      downloadLocation: "NOASSERTION",
+      filesAnalyzed: false,
+      externalRefs: [
+        {
+          referenceCategory: "PACKAGE-MANAGER",
+          referenceType: "purl",
+          referenceLocator: `pkg:npm/${encodeURIComponent(dep.package)}@${encodeURIComponent(dep.version)}`
+        }
+      ],
+      annotations: [
+        {
+          annotationType: "OTHER",
+          annotator: "Tool: @vibgrate/cli",
+          annotationDate: artifact.timestamp,
+          comment: `project=${dep.project}; drift=${dep.drift}; majorsBehind=${dep.majorsBehind ?? "unknown"}`
+        }
+      ]
+    }))
+  };
+}
+function projectDependencyMap(artifact) {
+  const map = /* @__PURE__ */ new Map();
+  for (const project of artifact.projects) {
+    for (const dep of project.dependencies) {
+      map.set(`${project.name}:${dep.package}`, dep);
+    }
+  }
+  return map;
+}
+function formatDeltaText(base, current) {
+  const baseMap = projectDependencyMap(base);
+  const currentMap = projectDependencyMap(current);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [key, dep] of currentMap.entries()) {
+    if (!baseMap.has(key)) {
+      added.push(`${key} @ ${dep.resolvedVersion ?? dep.currentSpec}`);
+      continue;
+    }
+    const prev = baseMap.get(key);
+    const prevVersion = prev.resolvedVersion ?? prev.currentSpec;
+    const nowVersion = dep.resolvedVersion ?? dep.currentSpec;
+    if (prevVersion !== nowVersion || prev.majorsBehind !== dep.majorsBehind) {
+      changed.push(`${key} ${prevVersion} -> ${nowVersion} (majorsBehind ${prev.majorsBehind ?? "unknown"} -> ${dep.majorsBehind ?? "unknown"})`);
+    }
+  }
+  for (const [key, dep] of baseMap.entries()) {
+    if (!currentMap.has(key)) {
+      removed.push(`${key} @ ${dep.resolvedVersion ?? dep.currentSpec}`);
+    }
+  }
+  const lines = [
+    "Vibgrate SBOM Delta",
+    "===================",
+    `Baseline: ${base.timestamp}`,
+    `Current:  ${current.timestamp}`,
+    `Drift score delta: ${(current.drift.score - base.drift.score).toFixed(2)} points`,
+    "",
+    `Added dependencies (${added.length})`,
+    ...added.map((d) => `  + ${d}`),
+    "",
+    `Removed dependencies (${removed.length})`,
+    ...removed.map((d) => `  - ${d}`),
+    "",
+    `Changed dependencies (${changed.length})`,
+    ...changed.map((d) => `  * ${d}`)
+  ];
+  return lines.join("\n");
+}
+async function readArtifactOrExit(filePath) {
+  const absolutePath = path5.resolve(filePath);
+  if (!await pathExists(absolutePath)) {
+    console.error(chalk4.red(`Artifact not found: ${absolutePath}`));
+    process.exit(1);
+  }
+  return readJsonFile(absolutePath);
+}
+var exportCommand = new Command4("export").description("Export scan artifact as SBOM").option("--in <file>", "Input artifact file", ".vibgrate/scan_result.json").option("--out <file>", "Output SBOM file").option("--format <format>", "SBOM format (cyclonedx|spdx)", "cyclonedx").action(async (opts) => {
+  const artifact = await readArtifactOrExit(opts.in);
+  const format = opts.format.toLowerCase();
+  if (format !== "cyclonedx" && format !== "spdx") {
+    console.error(chalk4.red("Invalid SBOM format. Use cyclonedx or spdx."));
+    process.exit(1);
+  }
+  const sbom = format === "cyclonedx" ? toCycloneDx(artifact) : toSpdx(artifact);
+  const body = JSON.stringify(sbom, null, 2);
+  if (opts.out) {
+    await writeTextFile(path5.resolve(opts.out), body);
+    console.log(chalk4.green("\u2714") + ` SBOM written to ${opts.out}`);
+  } else {
+    console.log(body);
+  }
+});
+var deltaCommand = new Command4("delta").description("Show SBOM delta between two scan artifacts").requiredOption("--from <file>", "Baseline scan artifact path").requiredOption("--to <file>", "Current scan artifact path").option("--out <file>", "Write report to file").action(async (opts) => {
+  const base = await readArtifactOrExit(opts.from);
+  const current = await readArtifactOrExit(opts.to);
+  const report = formatDeltaText(base, current);
+  if (opts.out) {
+    await writeTextFile(path5.resolve(opts.out), report);
+    console.log(chalk4.green("\u2714") + ` SBOM delta report written to ${opts.out}`);
+  } else {
+    console.log(report);
+  }
+});
+var sbomCommand = new Command4("sbom").description("SBOM export and delta reports for dependency drift tracking").addCommand(exportCommand).addCommand(deltaCommand);
+
 // src/cli.ts
-var program = new Command4();
+var program = new Command5();
 program.name("vibgrate").description("Continuous Drift Intelligence for Node & .NET").version(VERSION);
 program.addCommand(initCommand);
 program.addCommand(scanCommand);
@@ -232,12 +411,13 @@ program.addCommand(reportCommand);
 program.addCommand(dsnCommand);
 program.addCommand(pushCommand);
 program.addCommand(updateCommand);
+program.addCommand(sbomCommand);
 program.parseAsync().then(async () => {
   const update = await checkForUpdate();
   if (update?.updateAvailable) {
     console.error("");
-    console.error(chalk4.yellow(`  Update available: ${update.current} \u2192 ${update.latest}`));
-    console.error(chalk4.dim('  Run "vibgrate update" to install the latest version.'));
+    console.error(chalk5.yellow(`  Update available: ${update.current} \u2192 ${update.latest}`));
+    console.error(chalk5.dim('  Run "vibgrate update" to install the latest version.'));
     console.error("");
   }
 }).catch((err) => {

package/dist/index.d.ts

@@ -49,6 +49,14 @@ interface ProjectScan {
     projectReferences?: ProjectReference[];
     /** Number of source files in the project directory */
     fileCount?: number;
+    /** Project-level architecture layer diagram (Mermaid flowchart) */
+    architectureMermaid?: string;
+    /** Project-level relationship diagram (first-level parents + children) */
+    relationshipDiagram?: MermaidDiagram;
+}
+interface MermaidDiagram {
+    mermaid: string;
+    svg?: string;
 }
 interface DriftScore {
     score: number;
@@ -100,6 +108,8 @@ interface ScanArtifact {
     filesScanned?: number;
     /** Workspace tree summary (file & directory counts from discovery) */
     treeSummary?: TreeCount;
+    /** Workspace-level relationship diagram */
+    relationshipDiagram?: MermaidDiagram;
 }
 interface ScanOptions {
     out?: string;
@@ -117,6 +127,12 @@ interface ScanOptions {
     strict?: boolean;
     /** Auto-install missing security tools via Homebrew */
     installTools?: boolean;
+    /** Enable optional UI-purpose evidence extraction (slower, richer context for dashboard) */
+    uiPurpose?: boolean;
+    /** Fail the run if drift score is above this absolute budget */
+    driftBudget?: number;
+    /** Fail when drift worsens by more than this percentage vs baseline */
+    driftWorseningPercent?: number;
 }
 interface ScannerToggle {
     enabled: boolean;
@@ -140,6 +156,7 @@ interface ScannersConfig {
     architecture?: ScannerToggle;
     codeQuality?: ScannerToggle;
     owaspCategoryMapping?: OwaspScannerConfig;
+    uiPurpose?: ScannerToggle;
 }
 interface VibgrateConfig {
     include?: string[];
@@ -363,6 +380,20 @@ interface CodeQualityResult {
     circularDependencies: number;
     deadCodePercent: number;
 }
+interface UiPurposeEvidenceItem {
+    kind: 'route' | 'nav' | 'title' | 'heading' | 'cta' | 'copy' | 'dependency' | 'feature_flag';
+    value: string;
+    file: string;
+    weight: number;
+}
+interface UiPurposeResult {
+    enabled: boolean;
+    detectedFrameworks: string[];
+    evidenceCount: number;
+    capped: boolean;
+    topEvidence: UiPurposeEvidenceItem[];
+    unknownSignals: string[];
+}
 interface ExtendedScanResults {
     platformMatrix?: PlatformMatrixResult;
     dependencyRisk?: DependencyRiskResult;
@@ -378,6 +409,7 @@ interface ExtendedScanResults {
     architecture?: ArchitectureResult;
     codeQuality?: CodeQualityResult;
     owaspCategoryMapping?: OwaspCategoryMappingResult;
+    uiPurpose?: UiPurposeResult;
 }
 interface OwaspFinding {
     ruleId: string;

package/dist/index.js

@@ -1,13 +1,13 @@
 import {
   formatMarkdown
-} from "./chunk-GN3IWKSY.js";
+} from "./chunk-PTMLMDZU.js";
 import {
   computeDriftScore,
   formatSarif,
   formatText,
   generateFindings,
   runScan
-} from "./chunk-YFJC5JSQ.js";
+} from "./chunk-HEILEAVO.js";
 import "./chunk-RNVZIZNL.js";
 export {
   computeDriftScore,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibgrate/cli",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "description": "CLI for measuring upgrade drift across Node, .NET, Python & Java projects",
   "type": "module",
   "bin": {