@nuvio/cli 1.0.0 → 1.1.0

package/dist/cli-entry.js

@@ -1,37 +1,29 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve } from "path";
+import { resolve as resolve4 } from "path";
 
-// src/detect-pm.ts
-import { existsSync } from "fs";
-import { join } from "path";
-function detectPackageManager(root, override) {
-  if (override) return override;
-  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(join(root, "package-lock.json"))) return "npm";
-  if (existsSync(join(root, "yarn.lock"))) return "yarn";
-  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock")))
-    return "bun";
-  return "npm";
-}
-function installCommand(pm, version) {
-  const pkgs = `@nuvio/vite-plugin@${version} @nuvio/overlay@${version}`;
-  switch (pm) {
-    case "pnpm":
-      return `pnpm add -D ${pkgs}`;
-    case "yarn":
-      return `yarn add -D ${pkgs}`;
-    case "bun":
-      return `bun add -d ${pkgs}`;
-    default:
-      return `npm install -D ${pkgs}`;
-  }
-}
+// src/brand-apply.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2, resolve } from "path";
+import { applyPatchToSource } from "@nuvio/ast-engine";
+import {
+  buildBrandPatchOps,
+  brandFragmentHostHint,
+  DEFAULT_BRAND_CONFIG,
+  isHostPatchable,
+  isPccBrandableCategory,
+  normalizeBrandConfig
+} from "@nuvio/shared";
+import {
+  listPccManifestFiles,
+  loadPccManifestFromFile,
+  resolvePccManifestPath
+} from "@nuvio/shared/load-pcc-manifest";
 
 // src/detect-project.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
 
 // src/messages.ts
 var MSG = {
@@ -73,8 +65,8 @@ function detectTailwind(root, pkg) {
   if (hasDep(pkg, "tailwindcss")) return true;
   const cssCandidates = ["src/index.css", "src/App.css"];
   for (const rel of cssCandidates) {
-    const p = join2(root, rel);
-    if (!existsSync2(p)) continue;
+    const p = join(root, rel);
+    if (!existsSync(p)) continue;
     const text = readFileSync(p, "utf8");
     if (text.includes("@tailwind") || text.includes('@import "tailwindcss"') || text.includes("@import 'tailwindcss'")) {
       return true;
@@ -83,8 +75,8 @@ function detectTailwind(root, pkg) {
   return false;
 }
 function detectProject(root) {
-  const packageJsonPath = join2(root, "package.json");
-  if (!existsSync2(packageJsonPath)) {
+  const packageJsonPath = join(root, "package.json");
+  if (!existsSync(packageJsonPath)) {
     throw new PreflightError(MSG.noPackageJson);
   }
   const packageJson = JSON.parse(
@@ -99,8 +91,8 @@ function detectProject(root) {
   let viteConfigPath = "";
   let viteConfigName = "";
   for (const name of VITE_CONFIGS) {
-    const p = join2(root, name);
-    if (existsSync2(p)) {
+    const p = join(root, name);
+    if (existsSync(p)) {
       viteConfigPath = p;
       viteConfigName = name;
       break;
@@ -127,32 +119,6 @@ function detectProject(root) {
   };
 }
 
-// src/nuvio-deps.ts
-import { readFileSync as readFileSync2 } from "fs";
-function readPackageJson(packageJsonPath) {
-  return JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-}
-function getDependencyVersion(pkg, name) {
-  const deps = pkg.dependencies;
-  const devDeps = pkg.devDependencies;
-  return deps?.[name] ?? devDeps?.[name];
-}
-function hasNuvioDependency(pkg, name) {
-  return Boolean(getDependencyVersion(pkg, name));
-}
-function hasNuvioPackages(pkg) {
-  return hasNuvioDependency(pkg, "@nuvio/vite-plugin") && hasNuvioDependency(pkg, "@nuvio/overlay");
-}
-function isWorkspaceLinkedVersion(version) {
-  if (!version) return false;
-  return version.startsWith("workspace:") || version.startsWith("link:") || version.startsWith("file:");
-}
-function nuvioOverlayLinkKind(pkg) {
-  const raw = getDependencyVersion(pkg, "@nuvio/overlay");
-  if (!raw) return "missing";
-  return isWorkspaceLinkedVersion(raw) ? "workspace" : "npm";
-}
-
 // src/project-scan.ts
 import { relative } from "path";
 import {
@@ -182,10 +148,639 @@ function aggregateClassNameModes(entries) {
   return counts;
 }
 
+// src/brand-apply.ts
+var BRAND_RELATIVE = "nuvio/brand.json";
+function readProjectBrandConfig(cwd) {
+  const filePath = join2(resolve(cwd), BRAND_RELATIVE);
+  if (!existsSync2(filePath)) {
+    return { ...DEFAULT_BRAND_CONFIG };
+  }
+  try {
+    const raw = readFileSync2(filePath, "utf8");
+    return normalizeBrandConfig(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_BRAND_CONFIG };
+  }
+}
+function duplicateIdSet(errors) {
+  return new Set(errors.map((error) => error.id));
+}
+function collectApplyTargets(manifest, entries, duplicateIds) {
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const targets = [];
+  let skipped = 0;
+  for (const category of Object.keys(manifest.categories)) {
+    if (!isPccBrandableCategory(category)) {
+      continue;
+    }
+    const config = manifest.categories[category];
+    if (!config) {
+      continue;
+    }
+    for (const hostId of config.hosts) {
+      const entry = byId.get(hostId);
+      if (!entry) {
+        skipped += 1;
+        continue;
+      }
+      const patch = isHostPatchable(entry, duplicateIds);
+      if (!patch.patchable) {
+        skipped += 1;
+        continue;
+      }
+      targets.push({
+        hostId,
+        category,
+        action: category,
+        entry
+      });
+    }
+  }
+  return { targets, skipped };
+}
+async function applyTargetsToProject(projectRoot, targets, brand, dryRun) {
+  const root = resolve(projectRoot);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const filePath = resolve(root, target.entry.file);
+    const list = byFile.get(filePath) ?? [];
+    list.push(target);
+    byFile.set(filePath, list);
+  }
+  let applied = 0;
+  const failed = [];
+  for (const [filePath, fileTargets] of byFile) {
+    if (!existsSync2(filePath)) {
+      for (const target of fileTargets) {
+        failed.push({ hostId: target.hostId, reason: "file_missing" });
+      }
+      continue;
+    }
+    if (dryRun) {
+      applied += fileTargets.length;
+      continue;
+    }
+    let source = readFileSync2(filePath, "utf8");
+    for (const target of fileTargets) {
+      const ops = buildBrandPatchOps(
+        target.action,
+        brand,
+        brandFragmentHostHint(target.entry)
+      );
+      const result = await applyPatchToSource(source, filePath, target.hostId, ops, {
+        classNameMode: target.entry.classNameMode
+      });
+      if (!result.ok) {
+        failed.push({ hostId: target.hostId, reason: result.message ?? result.code });
+        continue;
+      }
+      source = result.source;
+      applied += 1;
+    }
+    writeFileSync(filePath, source, "utf8");
+  }
+  return { applied, failed };
+}
+function printHumanReport(result) {
+  console.log(`Page: ${result.page}`);
+  console.log(`Route: ${result.route}`);
+  console.log(`Manifest: ${result.manifestPath}`);
+  console.log(`Applied: ${result.applied}`);
+  console.log(`Skipped: ${result.skipped}`);
+  if (result.failed.length > 0) {
+    console.log("Failed:");
+    for (const failure of result.failed) {
+      console.log(`- ${failure.hostId}: ${failure.reason}`);
+    }
+  }
+}
+async function applyLoadedManifest(manifestPath, manifest, entries, duplicateIds, brand, projectRoot, opts) {
+  const { targets, skipped } = collectApplyTargets(manifest, entries, duplicateIds);
+  const { applied, failed } = await applyTargetsToProject(
+    projectRoot,
+    targets,
+    brand,
+    opts.dryRun === true
+  );
+  return {
+    page: manifest.page,
+    route: manifest.route,
+    manifestPath,
+    applied,
+    skipped,
+    failed
+  };
+}
+async function runBrandApplyAll(opts) {
+  const manifestPaths = listPccManifestFiles(opts.cwd);
+  if (manifestPaths.length === 0) {
+    console.error(`No PCC manifests found under ${resolve(opts.cwd)}/nuvio/pages`);
+    return 2;
+  }
+  const brand = readProjectBrandConfig(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const duplicateIds = duplicateIdSet(scan.index.duplicateErrors);
+  const pages = [];
+  for (const manifestPath of manifestPaths) {
+    const loaded = loadPccManifestFromFile(manifestPath);
+    if (!loaded.ok) {
+      console.error(`Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`);
+      return 2;
+    }
+    pages.push(
+      await applyLoadedManifest(
+        manifestPath,
+        loaded.manifest,
+        scan.index.entries,
+        duplicateIds,
+        brand,
+        scan.ctx.root,
+        opts
+      )
+    );
+  }
+  const pass = pages.every((page) => page.failed.length === 0);
+  if (opts.json) {
+    console.log(JSON.stringify({ pass, dryRun: opts.dryRun === true, pages }, null, 2));
+    return pass ? 0 : 1;
+  }
+  console.log(`Nuvio Brand Apply${opts.dryRun ? " (dry run)" : ""}
+`);
+  for (const page of pages) {
+    printHumanReport(page);
+    console.log("");
+  }
+  console.log(`Result: ${pass ? "PASS" : "FAIL"}`);
+  return pass ? 0 : 1;
+}
+async function runBrandApply(opts) {
+  if (opts.all) {
+    return runBrandApplyAll(opts);
+  }
+  let manifestPath;
+  try {
+    manifestPath = resolve(
+      resolvePccManifestPath(opts.cwd, { page: opts.page, manifest: opts.manifest })
+    );
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    return 2;
+  }
+  const loaded = loadPccManifestFromFile(manifestPath);
+  if (!loaded.ok) {
+    console.error(`Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`);
+    return 2;
+  }
+  const brand = readProjectBrandConfig(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const duplicateIds = duplicateIdSet(scan.index.duplicateErrors);
+  const result = await applyLoadedManifest(
+    manifestPath,
+    loaded.manifest,
+    scan.index.entries,
+    duplicateIds,
+    brand,
+    scan.ctx.root,
+    opts
+  );
+  const pass = result.failed.length === 0;
+  if (opts.json) {
+    console.log(JSON.stringify({ pass, dryRun: opts.dryRun === true, ...result }, null, 2));
+    return pass ? 0 : 1;
+  }
+  console.log(`Nuvio Brand Apply${opts.dryRun ? " (dry run)" : ""}
+`);
+  printHumanReport(result);
+  console.log(`
+Result: ${pass ? "PASS" : "FAIL"}`);
+  return pass ? 0 : 1;
+}
+
+// src/brand-scan.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+import {
+  DEFAULT_BRAND_CONFIG as DEFAULT_BRAND_CONFIG2,
+  evaluateBrandPageScan,
+  getBrandColorLabel,
+  getBrandDensityLabel,
+  getBrandRadiusLabel,
+  getBrandTypographyLabel,
+  normalizeBrandConfig as normalizeBrandConfig2,
+  pccCategoryLabel
+} from "@nuvio/shared";
+import {
+  listPccManifestFiles as listPccManifestFiles2,
+  loadPccManifestFromFile as loadPccManifestFromFile2,
+  resolvePccManifestPath as resolvePccManifestPath2
+} from "@nuvio/shared/load-pcc-manifest";
+var BRAND_RELATIVE2 = "nuvio/brand.json";
+function readProjectBrandConfig2(cwd) {
+  const filePath = join3(resolve2(cwd), BRAND_RELATIVE2);
+  if (!existsSync3(filePath)) {
+    return { ...DEFAULT_BRAND_CONFIG2 };
+  }
+  try {
+    const raw = readFileSync3(filePath, "utf8");
+    return normalizeBrandConfig2(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_BRAND_CONFIG2 };
+  }
+}
+function formatBrandSummary(brand) {
+  return [
+    getBrandColorLabel(brand.color),
+    getBrandRadiusLabel(brand.radius),
+    getBrandDensityLabel(brand.density),
+    getBrandTypographyLabel(brand.typography)
+  ].join(" \xB7 ");
+}
+function printHumanReport2(result, manifestPath) {
+  console.log("Nuvio Brand Scan\n");
+  console.log(`Page: ${result.page}`);
+  console.log(`Route: ${result.route}`);
+  console.log(`Manifest: ${manifestPath}`);
+  console.log(`Saved brand: ${formatBrandSummary(result.brand)}
+`);
+  console.log("Category summary:");
+  for (const category of result.categories) {
+    const label = pccCategoryLabel(category.category).padEnd(10);
+    const status = category.pass ? "PASS" : "FAIL";
+    console.log(
+      `${label} ${status} on-brand ${category.onBrand}/${category.expected} \xB7 off-brand ${category.offBrand} \xB7 no-traits ${category.noTraits}`
+    );
+  }
+  console.log("\nTotals:");
+  console.log(`On-brand    ${result.onBrandCount}`);
+  console.log(`Off-brand   ${result.offBrandCount}`);
+  console.log(`No traits   ${result.noTraitsCount}`);
+  console.log(`Missing     ${result.missingCount}`);
+  const offBrandHosts = result.hosts.filter((host) => host.status === "off_brand");
+  if (offBrandHosts.length > 0) {
+    console.log("\nOff-brand hosts:");
+    for (const host of offBrandHosts.slice(0, 12)) {
+      const headline = host.inspect?.headline ?? "Off-brand";
+      console.log(`- ${host.hostId} (${host.category}) \u2014 ${headline}`);
+    }
+    if (offBrandHosts.length > 12) {
+      console.log(`\u2026and ${offBrandHosts.length - 12} more`);
+    }
+  }
+  console.log(`
+Result: ${result.pass ? "PASS" : "FAIL"}`);
+}
+function printAllHumanReport(pages) {
+  console.log("Nuvio Brand Scan (all pages)\n");
+  for (const page of pages) {
+    const status = page.result.pass ? "PASS" : "FAIL";
+    const summary = `${page.result.onBrandCount} on-brand \xB7 ${page.result.offBrandCount} off-brand`;
+    console.log(`${page.result.page.padEnd(16)} ${status}  ${summary}`);
+  }
+  const pass = pages.every((page) => page.result.pass);
+  console.log(`
+Result: ${pass ? "PASS" : "FAIL"}`);
+}
+function scanLoadedManifest(manifestPath, entries, brand) {
+  const loaded = loadPccManifestFromFile2(manifestPath);
+  if (!loaded.ok) {
+    return {
+      ok: false,
+      code: 2,
+      message: `Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`
+    };
+  }
+  return {
+    ok: true,
+    result: evaluateBrandPageScan(loaded.manifest, entries, brand)
+  };
+}
+function runBrandScanAll(opts) {
+  const manifestPaths = listPccManifestFiles2(opts.cwd);
+  if (manifestPaths.length === 0) {
+    console.error(`No PCC manifests found under ${resolve2(opts.cwd)}/nuvio/pages`);
+    return 2;
+  }
+  const brand = readProjectBrandConfig2(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const pages = [];
+  for (const manifestPath of manifestPaths) {
+    const scanned = scanLoadedManifest(manifestPath, scan.index.entries, brand);
+    if (!scanned.ok) {
+      console.error(scanned.message);
+      return scanned.code;
+    }
+    pages.push({ manifestPath, result: scanned.result });
+  }
+  const pass = pages.every((page) => page.result.pass);
+  if (opts.json) {
+    console.log(JSON.stringify({ pass, brand, pages }, null, 2));
+    return pass ? 0 : 1;
+  }
+  printAllHumanReport(pages);
+  return pass ? 0 : 1;
+}
+function runBrandScan(opts) {
+  if (opts.all) {
+    return runBrandScanAll(opts);
+  }
+  let manifestPath;
+  try {
+    manifestPath = resolve2(
+      resolvePccManifestPath2(opts.cwd, { page: opts.page, manifest: opts.manifest })
+    );
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    return 2;
+  }
+  const brand = readProjectBrandConfig2(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const scanned = scanLoadedManifest(manifestPath, scan.index.entries, brand);
+  if (!scanned.ok) {
+    console.error(scanned.message);
+    return scanned.code;
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          manifestPath,
+          ...scanned.result
+        },
+        null,
+        2
+      )
+    );
+    return scanned.result.pass ? 0 : 1;
+  }
+  printHumanReport2(scanned.result, manifestPath);
+  return scanned.result.pass ? 0 : 1;
+}
+
+// src/coverage-verify.ts
+import { resolve as resolve3 } from "path";
+import {
+  evaluatePageCoverage,
+  pccCategoryLabel as pccCategoryLabel2
+} from "@nuvio/shared";
+import {
+  listPccManifestFiles as listPccManifestFiles3,
+  loadPccManifestFromFile as loadPccManifestFromFile3,
+  resolvePccManifestPath as resolvePccManifestPath3
+} from "@nuvio/shared/load-pcc-manifest";
+function formatCategoryLine(summary) {
+  const label = pccCategoryLabel2(summary.category).padEnd(10);
+  const status = summary.pass ? "PASS" : "FAIL";
+  return `${label} ${status} ${summary.indexed}/${summary.expected}`;
+}
+function printHumanReport3(result, manifestPath) {
+  console.log("Nuvio Coverage Report\n");
+  console.log(`Page: ${result.page}`);
+  console.log(`Route: ${result.route}`);
+  console.log(`Manifest: ${manifestPath}
+`);
+  console.log("Category summary:");
+  for (const category of result.categories) {
+    console.log(formatCategoryLine(category));
+  }
+  console.log("\nCoverage gates:");
+  const g = result.gates;
+  console.log(`Indexed      ${g.indexed}/${g.expected}`);
+  console.log(`Patchable    ${g.patchable}/${g.expected}`);
+  console.log(`Categorized  ${g.categorized}/${g.expected}`);
+  console.log(`Editable     ${g.editable}/${g.expected}`);
+  console.log(`Brandable    ${g.brandable}/${g.expected}`);
+  console.log("\nBrandability:");
+  console.log(`Brandable      ${result.brandableCount}`);
+  console.log(`Editable-only  ${result.editableOnlyCount}`);
+  const missing = result.issues.filter((i) => i.kind === "missing");
+  const unpatchable = result.issues.filter((i) => i.kind === "unpatchable");
+  const duplicates = result.issues.filter((i) => i.kind === "duplicate_id");
+  if (missing.length > 0) {
+    console.log("\nMissing hosts:");
+    for (const issue of missing) {
+      console.log(`- ${issue.hostId} (${issue.category})`);
+    }
+  }
+  if (unpatchable.length > 0) {
+    console.log("\nUnpatchable hosts:");
+    for (const issue of unpatchable) {
+      console.log(`- ${issue.hostId}`);
+      if (issue.reason) {
+        console.log(`  reason: ${issue.reason}`);
+      }
+    }
+  }
+  if (duplicates.length > 0) {
+    console.log("\nDuplicate id hosts:");
+    for (const issue of duplicates) {
+      console.log(`- ${issue.hostId}`);
+    }
+  }
+  console.log(`
+Result: ${result.pass ? "PASS" : "FAIL"}`);
+}
+function printAllHumanReport2(summary) {
+  console.log("Nuvio Coverage Report (all pages)\n");
+  for (const entry of summary.pages) {
+    const status = entry.result.pass ? "PASS" : "FAIL";
+    console.log(`${entry.result.page.padEnd(16)} ${status}  ${entry.manifestPath}`);
+  }
+  console.log(`
+Result: ${summary.pass ? "PASS" : "FAIL"}`);
+}
+function verifyLoadedManifest(manifestPath, entries, duplicateErrors) {
+  const loaded = loadPccManifestFromFile3(manifestPath);
+  if (!loaded.ok) {
+    return {
+      ok: false,
+      code: 2,
+      message: `Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`
+    };
+  }
+  const result = evaluatePageCoverage(loaded.manifest, entries, duplicateErrors);
+  return { ok: true, result };
+}
+function runCoverageVerifyAll(opts) {
+  const manifestPaths = listPccManifestFiles3(opts.cwd);
+  if (manifestPaths.length === 0) {
+    console.error(`No PCC manifests found under ${resolve3(opts.cwd)}/nuvio/pages`);
+    return 2;
+  }
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const pages = [];
+  for (const manifestPath of manifestPaths) {
+    const verified = verifyLoadedManifest(
+      manifestPath,
+      scan.index.entries,
+      scan.index.duplicateErrors
+    );
+    if (!verified.ok) {
+      console.error(verified.message);
+      return verified.code;
+    }
+    pages.push({ manifestPath, result: verified.result });
+  }
+  const summary = {
+    pass: pages.every((page) => page.result.pass),
+    pages
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return summary.pass ? 0 : 1;
+  }
+  printAllHumanReport2(summary);
+  return summary.pass ? 0 : 1;
+}
+function runCoverageVerify(opts) {
+  if (opts.all) {
+    return runCoverageVerifyAll(opts);
+  }
+  let manifestPath;
+  try {
+    manifestPath = resolve3(
+      resolvePccManifestPath3(opts.cwd, { page: opts.page, manifest: opts.manifest })
+    );
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    return 2;
+  }
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const verified = verifyLoadedManifest(
+    manifestPath,
+    scan.index.entries,
+    scan.index.duplicateErrors
+  );
+  if (!verified.ok) {
+    console.error(verified.message);
+    return verified.code;
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          manifestPath,
+          ...verified.result
+        },
+        null,
+        2
+      )
+    );
+    return verified.result.pass ? 0 : 1;
+  }
+  printHumanReport3(verified.result, manifestPath);
+  return verified.result.pass ? 0 : 1;
+}
+
+// src/detect-pm.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+function detectPackageManager(root, override) {
+  if (override) return override;
+  if (existsSync4(join4(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(join4(root, "package-lock.json"))) return "npm";
+  if (existsSync4(join4(root, "yarn.lock"))) return "yarn";
+  if (existsSync4(join4(root, "bun.lockb")) || existsSync4(join4(root, "bun.lock")))
+    return "bun";
+  return "npm";
+}
+function installCommand(pm, version) {
+  const pkgs = `@nuvio/vite-plugin@${version} @nuvio/overlay@${version}`;
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add -D ${pkgs}`;
+    case "yarn":
+      return `yarn add -D ${pkgs}`;
+    case "bun":
+      return `bun add -d ${pkgs}`;
+    default:
+      return `npm install -D ${pkgs}`;
+  }
+}
+
+// src/nuvio-deps.ts
+import { readFileSync as readFileSync4 } from "fs";
+function readPackageJson(packageJsonPath) {
+  return JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+}
+function getDependencyVersion(pkg, name) {
+  const deps = pkg.dependencies;
+  const devDeps = pkg.devDependencies;
+  return deps?.[name] ?? devDeps?.[name];
+}
+function hasNuvioDependency(pkg, name) {
+  return Boolean(getDependencyVersion(pkg, name));
+}
+function hasNuvioPackages(pkg) {
+  return hasNuvioDependency(pkg, "@nuvio/vite-plugin") && hasNuvioDependency(pkg, "@nuvio/overlay");
+}
+function isWorkspaceLinkedVersion(version) {
+  if (!version) return false;
+  return version.startsWith("workspace:") || version.startsWith("link:") || version.startsWith("file:");
+}
+function nuvioOverlayLinkKind(pkg) {
+  const raw = getDependencyVersion(pkg, "@nuvio/overlay");
+  if (!raw) return "missing";
+  return isWorkspaceLinkedVersion(raw) ? "workspace" : "npm";
+}
+
 // src/telemetry.ts
-import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 import { randomUUID } from "crypto";
 import os from "os";
 import { PostHog } from "posthog-node";
@@ -201,7 +796,7 @@ var NUVIO_VERSION = require2("../package.json").version;
 // src/telemetry.ts
 var POSTHOG_HOST = "https://us.i.posthog.com";
 function telemetryFilePath() {
-  return join3(homedir(), ".nuvio", "telemetry.json");
+  return join5(homedir(), ".nuvio", "telemetry.json");
 }
 var FORBIDDEN_PROP_KEYS = /* @__PURE__ */ new Set([
   "cwd",
@@ -240,7 +835,7 @@ function tokenIsConfigured(token) {
 function readOrCreateAnonymousId() {
   if (sessionAnonymousId) return sessionAnonymousId;
   try {
-    const raw = readFileSync3(telemetryFilePath(), "utf8");
+    const raw = readFileSync5(telemetryFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.anonymousId) {
       sessionAnonymousId = parsed.anonymousId;
@@ -251,8 +846,8 @@ function readOrCreateAnonymousId() {
   const id = randomUUID();
   sessionAnonymousId = id;
   try {
-    mkdirSync(join3(homedir(), ".nuvio"), { recursive: true, mode: 448 });
-    writeFileSync(
+    mkdirSync(join5(homedir(), ".nuvio"), { recursive: true, mode: 448 });
+    writeFileSync2(
       telemetryFilePath(),
       JSON.stringify({ anonymousId: id }, null, 2),
       { mode: 384 }
@@ -408,8 +1003,8 @@ var babel_traverse_default = traverse;
 // src/patch-app-root.ts
 import * as t from "@babel/types";
 import fg from "fast-glob";
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 
 // src/babel-generator.ts
 import generateImport from "@babel/generator";
@@ -443,8 +1038,8 @@ var APP_CANDIDATES = [
 ];
 function resolveAppFile(root) {
   for (const rel of APP_CANDIDATES) {
-    const p = join4(root, rel);
-    if (existsSync3(p)) return p;
+    const p = join6(root, rel);
+    if (existsSync5(p)) return p;
   }
   return null;
 }
@@ -502,7 +1097,7 @@ function appendDevShell(ast) {
   return patched;
 }
 function patchAppRootFile(filePath) {
-  const source = readFileSync4(filePath, "utf8");
+  const source = readFileSync6(filePath, "utf8");
   let ast;
   try {
     ast = parseTs(source, filePath);
@@ -528,12 +1123,12 @@ function patchAppRootFile(filePath) {
   if (!hasDevShell(ast) && !appendDevShell(ast)) {
     return { ok: false, error: "no JSX return to patch" };
   }
-  writeFileSync2(filePath, printTs(ast, source), "utf8");
+  writeFileSync3(filePath, printTs(ast, source), "utf8");
   return { ok: true };
 }
 function appHasDevShell(filePath) {
-  if (!existsSync3(filePath)) return false;
-  const source = readFileSync4(filePath, "utf8");
+  if (!existsSync5(filePath)) return false;
+  const source = readFileSync6(filePath, "utf8");
   try {
     const ast = parseTs(source, filePath);
     return hasOverlayImport(ast) && hasDevShell(ast);
@@ -556,8 +1151,8 @@ function projectHasDevShell(root) {
 }
 
 // src/patch-main-styles.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
 var MAIN_CANDIDATES = ["src/main.tsx", "src/main.jsx", "main.tsx", "main.jsx"];
 var STYLE_IMPORT = 'import "@nuvio/overlay/style.css";';
 function overlayInstalledFromNpm(packageJsonPath) {
@@ -566,17 +1161,17 @@ function overlayInstalledFromNpm(packageJsonPath) {
 }
 function resolveMainEntry(root) {
   for (const rel of MAIN_CANDIDATES) {
-    const p = join5(root, rel);
-    if (existsSync4(p)) return p;
+    const p = join7(root, rel);
+    if (existsSync6(p)) return p;
   }
   return null;
 }
 function mainHasOverlayStyles(mainPath) {
-  const text = readFileSync5(mainPath, "utf8");
+  const text = readFileSync7(mainPath, "utf8");
   return text.includes("@nuvio/overlay/style.css") || text.includes("@nuvio/overlay/dist/style.css");
 }
 function patchMainOverlayStyles(mainPath) {
-  const text = readFileSync5(mainPath, "utf8");
+  const text = readFileSync7(mainPath, "utf8");
   if (text.includes("@nuvio/overlay/style.css") || text.includes("@nuvio/overlay/dist/style.css")) {
     return { ok: true, skipped: true };
   }
@@ -590,13 +1185,13 @@ function patchMainOverlayStyles(mainPath) {
   } else {
     lines.unshift(STYLE_IMPORT, "");
   }
-  writeFileSync3(mainPath, lines.join("\n"));
+  writeFileSync4(mainPath, lines.join("\n"));
   return { ok: true };
 }
 
 // src/patch-vite-config.ts
 import * as t2 from "@babel/types";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 function hasNuvioImport(ast) {
   let found = false;
   babel_traverse_default(ast, {
@@ -679,7 +1274,7 @@ function ensureOptimizeDepsExclude(ast) {
   return patched;
 }
 function viteConfigHasOverlayOptimizeExclude(filePath) {
-  const source = readFileSync6(filePath, "utf8");
+  const source = readFileSync8(filePath, "utf8");
   return /optimizeDeps\s*:\s*\{[^}]*exclude\s*:\s*\[[^\]]*@nuvio\/overlay/.test(
     source
   ) || /exclude\s*:\s*\[[^\]]*["']@nuvio\/overlay["']/.test(source);
@@ -697,7 +1292,7 @@ function appendNuvioPlugin(ast) {
   return patched;
 }
 function patchViteConfigFile(filePath) {
-  const source = readFileSync6(filePath, "utf8");
+  const source = readFileSync8(filePath, "utf8");
   let ast;
   try {
     ast = parseTs(source, filePath);
@@ -722,11 +1317,11 @@ function patchViteConfigFile(filePath) {
       return { ok: false, error: "no static plugins array" };
     }
   }
-  writeFileSync4(filePath, printTs(ast, source), "utf8");
+  writeFileSync5(filePath, printTs(ast, source), "utf8");
   return { ok: true, skipped: alreadyPlugin && depsPatched };
 }
 function viteConfigHasNuvio(filePath) {
-  const source = readFileSync6(filePath, "utf8");
+  const source = readFileSync8(filePath, "utf8");
   try {
     const ast = parseTs(source, filePath);
     return hasNuvioImport(ast) && hasNuvioPluginCall(ast);
@@ -736,14 +1331,14 @@ function viteConfigHasNuvio(filePath) {
 }
 
 // src/scan-ids.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
 import fg2 from "fast-glob";
 var ID_GLOB = ["src/**/*.{tsx,jsx}"];
 function projectHasPageTitleId(root) {
   const files = fg2.sync(ID_GLOB, { cwd: root, absolute: true });
   for (const file of files) {
-    const text = readFileSync7(file, "utf8");
+    const text = readFileSync9(file, "utf8");
     if (/data-nuvio-id=["']page\.title["']/.test(text)) {
       return true;
     }
@@ -753,8 +1348,8 @@ function projectHasPageTitleId(root) {
 function findHeadingFiles(root) {
   const files = fg2.sync(ID_GLOB, { cwd: root, absolute: true });
   const ordered = [
-    join6(root, "src/App.tsx"),
-    join6(root, "src/App.jsx"),
+    join8(root, "src/App.tsx"),
+    join8(root, "src/App.jsx"),
     ...files.filter(
       (f) => !f.endsWith("App.tsx") && !f.endsWith("App.jsx")
     )
@@ -967,7 +1562,7 @@ import { createInterface } from "readline";
 
 // src/install-packages.ts
 import { spawnSync } from "child_process";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 function parseInstalledVersion(pkg, name) {
   const dev = pkg.devDependencies;
   const deps = pkg.dependencies;
@@ -976,7 +1571,7 @@ function parseInstalledVersion(pkg, name) {
   return raw.replace(/^[\^~]/, "");
 }
 function packagesNeedInstall(packageJsonPath, targetVersion) {
-  const pkg = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
+  const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf8"));
   for (const name of ["@nuvio/vite-plugin", "@nuvio/overlay"]) {
     const v = parseInstalledVersion(pkg, name);
     if (v !== targetVersion) return true;
@@ -1003,9 +1598,9 @@ function runInstall(root, pm, version) {
 
 // src/patch-starter-id.ts
 import * as t3 from "@babel/types";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
 function patchFirstHeading(filePath) {
-  const source = readFileSync9(filePath, "utf8");
+  const source = readFileSync11(filePath, "utf8");
   let ast;
   try {
     ast = parseTs(source, filePath);
@@ -1034,13 +1629,13 @@ function patchFirstHeading(filePath) {
     }
   });
   if (!patched) return { ok: false, error: "no h1/h2" };
-  writeFileSync5(filePath, printTs(ast, source), "utf8");
+  writeFileSync6(filePath, printTs(ast, source), "utf8");
   return { ok: true };
 }
 function patchStarterId(root) {
   const files = findHeadingFiles(root);
   for (const file of files) {
-    const source = readFileSync9(file, "utf8");
+    const source = readFileSync11(file, "utf8");
     if (!/<h[12][\s>]/.test(source) && !/<>[\s\S]*<h[12]/.test(source)) {
       try {
         const ast = parseTs(source, file);
@@ -1080,12 +1675,13 @@ function createPlan(root, pm) {
 }
 
 // src/write-nuvio-folder.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { dirname, join as join7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { dirname, join as join9 } from "path";
 import { fileURLToPath } from "url";
-var CLI_ROOT = join7(dirname(fileURLToPath(import.meta.url)), "..");
+import { DEFAULT_BRAND_CONFIG as DEFAULT_BRAND_CONFIG3, serializeBrandConfig } from "@nuvio/shared";
+var CLI_ROOT = join9(dirname(fileURLToPath(import.meta.url)), "..");
 function loadTemplate(name) {
-  return readFileSync10(join7(CLI_ROOT, "templates", name), "utf8");
+  return readFileSync12(join9(CLI_ROOT, "templates", name), "utf8");
 }
 function render(tpl, vars) {
   let out = tpl;
@@ -1095,7 +1691,7 @@ function render(tpl, vars) {
   return out;
 }
 function writeNuvioFolder(opts) {
-  const dir = join7(opts.root, "nuvio");
+  const dir = join9(opts.root, "nuvio");
   const created = [];
   mkdirSync2(dir, { recursive: true });
   const vars = {
@@ -1103,34 +1699,40 @@ function writeNuvioFolder(opts) {
     PM_RUN: opts.pmRun,
     FAILED_STEPS: opts.failedSteps.join(", ") || "(none)"
   };
-  const startHere = join7(dir, "START_HERE.md");
-  writeFileSync6(
+  const startHere = join9(dir, "START_HERE.md");
+  writeFileSync7(
     startHere,
     render(loadTemplate("START_HERE.md.tpl"), vars),
     "utf8"
   );
   created.push("nuvio/START_HERE.md");
-  const readme = join7(dir, "README.md");
-  writeFileSync6(
+  const readme = join9(dir, "README.md");
+  writeFileSync7(
     readme,
     render(loadTemplate("README.pointer.md.tpl"), vars),
     "utf8"
   );
   created.push("nuvio/README.md");
-  const agent = join7(dir, "AGENT.md");
-  if (!existsSync5(agent) || opts.forceAgent) {
-    writeFileSync6(agent, render(loadTemplate("AGENT.md.tpl"), vars), "utf8");
+  const agent = join9(dir, "AGENT.md");
+  if (!existsSync7(agent) || opts.forceAgent) {
+    writeFileSync7(agent, render(loadTemplate("AGENT.md.tpl"), vars), "utf8");
     created.push("nuvio/AGENT.md");
   }
   if (opts.failedSteps.length > 0) {
-    const todo = join7(dir, "SETUP_TODO.md");
-    writeFileSync6(
+    const todo = join9(dir, "SETUP_TODO.md");
+    writeFileSync7(
       todo,
       render(loadTemplate("SETUP_TODO.md.tpl"), vars),
       "utf8"
     );
     created.push("nuvio/SETUP_TODO.md");
   }
+  const brand = join9(dir, "brand.json");
+  if (!existsSync7(brand)) {
+    writeFileSync7(brand, `${JSON.stringify(serializeBrandConfig(DEFAULT_BRAND_CONFIG3), null, 2)}
+`, "utf8");
+    created.push("nuvio/brand.json");
+  }
   return created;
 }
 
@@ -1151,10 +1753,10 @@ async function confirm(plan) {
   console.log(`
 Install: ${plan.installCommand || "(skip)"}`);
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
+  return new Promise((resolve5) => {
     rl.question("\nProceed? [y/N] ", (answer) => {
       rl.close();
-      resolve2(/^y(es)?$/i.test(answer.trim()));
+      resolve5(/^y(es)?$/i.test(answer.trim()));
     });
   });
 }
@@ -1527,6 +2129,9 @@ Usage:
   nuvio doctor [options]
   nuvio scan [options]
   nuvio stats [options]
+  nuvio coverage verify [options]
+  nuvio brand scan [options]
+  nuvio brand apply [options]
 
 Common options:
   --cwd <path>          Project root (default: current directory)
@@ -1546,11 +2151,32 @@ Init options:
 Doctor options:
   --skip-dev-server     Skip localhost dev-server health check
 
+Coverage verify options:
+  --page <slug>         Page slug (loads nuvio/pages/<slug>.pcc.yaml)
+  --manifest <path>     Explicit PCC manifest path (overrides --page)
+  --all                 Verify every manifest in nuvio/pages/
+
+Brand scan options:
+  --page <slug>         Page slug (loads nuvio/pages/<slug>.pcc.yaml)
+  --manifest <path>     Explicit PCC manifest path (overrides --page)
+  --all                 Scan every manifest in nuvio/pages/
+
+Brand apply options:
+  --page <slug>         Page slug (loads nuvio/pages/<slug>.pcc.yaml)
+  --manifest <path>     Explicit PCC manifest path (overrides --page)
+  --all                 Apply to every manifest in nuvio/pages/
+  --dry-run             Report targets without writing source files
+
 Examples:
   pnpm dlx @nuvio/cli init --yes
   pnpm dlx @nuvio/cli doctor
   pnpm dlx @nuvio/cli scan --json
   pnpm dlx @nuvio/cli stats
+  pnpm dlx @nuvio/cli coverage verify --page dashboard --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli coverage verify --all --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli brand scan --page dashboard --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli brand scan --all --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli brand apply --all --cwd apps/tailadmin-dogfood
 `);
 }
 function parseInitArgs(argv) {
@@ -1578,7 +2204,7 @@ function parseInitArgs(argv) {
     else if (arg === "--pm") {
       opts.pm = args[++i];
     } else if (arg === "--cwd") {
-      opts.cwd = resolve(args[++i] ?? ".");
+      opts.cwd = resolve4(args[++i] ?? ".");
     } else if (arg.startsWith("-")) {
       console.error(`Unknown option: ${arg}`);
       help = true;
@@ -1605,7 +2231,7 @@ function parseProjectCommandArgs(argv, command) {
       common.verbose = true;
       doctor.verbose = true;
     } else if (arg === "--cwd") {
-      const cwd = resolve(args[++i] ?? ".");
+      const cwd = resolve4(args[++i] ?? ".");
       common.cwd = cwd;
       doctor.cwd = cwd;
     } else if (arg === "--skip-dev-server") {
@@ -1617,16 +2243,114 @@ function parseProjectCommandArgs(argv, command) {
   }
   return { command, common, doctor, help };
 }
+function parseCoverageVerifyArgs(argv) {
+  const args = argv.slice(2);
+  const common = { cwd: process.cwd() };
+  let help = false;
+  let page;
+  let manifest;
+  let all = false;
+  let i = 0;
+  if (args[0] === "coverage") {
+    i = 1;
+  }
+  const subcommand = args[i] === "verify" ? "verify" : "";
+  if (subcommand) {
+    i += 1;
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      common.json = true;
+    } else if (arg === "--verbose") {
+      common.verbose = true;
+    } else if (arg === "--cwd") {
+      common.cwd = resolve4(args[++i] ?? ".");
+    } else if (arg === "--page") {
+      page = args[++i];
+    } else if (arg === "--manifest") {
+      manifest = resolve4(args[++i] ?? "");
+    } else if (arg === "--all") {
+      all = true;
+    } else if (arg.startsWith("-")) {
+      console.error(`Unknown option: ${arg}`);
+      help = true;
+    }
+  }
+  return { command: "coverage", subcommand, common, page, manifest, all, help };
+}
+function parseBrandArgs(argv) {
+  const args = argv.slice(2);
+  const common = { cwd: process.cwd() };
+  let help = false;
+  let page;
+  let manifest;
+  let all = false;
+  let dryRun = false;
+  let i = 0;
+  if (args[0] === "brand") {
+    i = 1;
+  }
+  const subArg = args[i];
+  const subcommand = subArg === "scan" || subArg === "apply" ? subArg : "";
+  if (subcommand) {
+    i += 1;
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      common.json = true;
+    } else if (arg === "--verbose") {
+      common.verbose = true;
+    } else if (arg === "--cwd") {
+      common.cwd = resolve4(args[++i] ?? ".");
+    } else if (arg === "--page") {
+      page = args[++i];
+    } else if (arg === "--manifest") {
+      manifest = resolve4(args[++i] ?? "");
+    } else if (arg === "--all") {
+      all = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg.startsWith("-")) {
+      console.error(`Unknown option: ${arg}`);
+      help = true;
+    }
+  }
+  return { command: "brand", subcommand, common, page, manifest, all, dryRun, help };
+}
 async function runCli(argv) {
   registerTelemetrySignalHandlers();
   const rawCommand = argv[2] ?? null;
-  const isProjectCmd = rawCommand === "doctor" || rawCommand === "scan" || rawCommand === "stats";
+  const isCoverageCmd = rawCommand === "coverage";
+  const isBrandCmd = rawCommand === "brand";
+  const isProjectCmd = rawCommand === "doctor" || rawCommand === "scan" || rawCommand === "stats" || isCoverageCmd || isBrandCmd;
   let help = false;
   let command = rawCommand;
   let initOpts = { cwd: process.cwd() };
   let commonOpts = { cwd: process.cwd() };
   let doctorOpts = { cwd: process.cwd() };
-  if (isProjectCmd) {
+  let coverageOpts = null;
+  let brandOpts = null;
+  if (isBrandCmd) {
+    brandOpts = parseBrandArgs(argv);
+    help = brandOpts.help;
+    command = brandOpts.command;
+    commonOpts = brandOpts.common;
+  } else if (isCoverageCmd) {
+    coverageOpts = parseCoverageVerifyArgs(argv);
+    help = coverageOpts.help;
+    command = coverageOpts.command;
+    commonOpts = coverageOpts.common;
+  } else if (isProjectCmd) {
     const parsed = parseProjectCommandArgs(argv, rawCommand);
     help = parsed.help;
     command = parsed.command;
@@ -1665,6 +2389,52 @@ async function runCli(argv) {
         return runScan({ cwd: commonOpts.cwd, json: commonOpts.json });
       case "stats":
         return runStats({ cwd: commonOpts.cwd, json: commonOpts.json });
+      case "coverage": {
+        if (!coverageOpts || coverageOpts.subcommand !== "verify") {
+          console.error("Usage: nuvio coverage verify --page <slug>");
+          printHelp();
+          return 1;
+        }
+        if (!coverageOpts.page && !coverageOpts.manifest && !coverageOpts.all) {
+          console.error("Either --page, --manifest, or --all is required");
+          return 2;
+        }
+        return runCoverageVerify({
+          cwd: coverageOpts.common.cwd,
+          page: coverageOpts.page,
+          manifest: coverageOpts.manifest,
+          all: coverageOpts.all,
+          json: coverageOpts.common.json
+        });
+      }
+      case "brand": {
+        if (!brandOpts || brandOpts.subcommand !== "scan" && brandOpts.subcommand !== "apply") {
+          console.error("Usage: nuvio brand scan|apply --page <slug>");
+          printHelp();
+          return 1;
+        }
+        if (!brandOpts.page && !brandOpts.manifest && !brandOpts.all) {
+          console.error("Either --page, --manifest, or --all is required");
+          return 2;
+        }
+        if (brandOpts.subcommand === "scan") {
+          return runBrandScan({
+            cwd: brandOpts.common.cwd,
+            page: brandOpts.page,
+            manifest: brandOpts.manifest,
+            all: brandOpts.all,
+            json: brandOpts.common.json
+          });
+        }
+        return runBrandApply({
+          cwd: brandOpts.common.cwd,
+          page: brandOpts.page,
+          manifest: brandOpts.manifest,
+          all: brandOpts.all,
+          dryRun: brandOpts.dryRun,
+          json: brandOpts.common.json
+        });
+      }
       default:
         console.error(`Unknown command: ${command}`);
         printHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuvio/cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Nuvio CLI 1.0 — Vite + Tailwind onboarding and diagnostics (init, doctor, scan, stats).",
   "license": "MIT",
   "repository": {
@@ -41,8 +41,9 @@
     "@babel/types": "^7.26.9",
     "fast-glob": "^3.3.3",
     "posthog-node": "^5.36.2",
-    "@nuvio/shared": "1.0.0",
-    "@nuvio/vite-plugin": "1.0.0"
+    "@nuvio/shared": "1.1.0",
+    "@nuvio/ast-engine": "1.1.0",
+    "@nuvio/vite-plugin": "1.1.0"
   },
   "devDependencies": {
     "@types/babel__generator": "^7.6.8",