@loworbitstudio/visor 0.1.0

package/dist/index.js

@@ -0,0 +1,2570 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync3, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { join as join3, dirname } from "path";
+
+// src/config/config.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  paths: {
+    components: "components/ui",
+    deckComponents: "components/deck",
+    blocks: "blocks",
+    hooks: "hooks",
+    lib: "lib"
+  }
+};
+var CONFIG_FILE = "visor.json";
+
+// src/config/config.ts
+function getConfigPath(cwd) {
+  return join(cwd, CONFIG_FILE);
+}
+function configExists(cwd) {
+  return existsSync(getConfigPath(cwd));
+}
+function loadConfig(cwd) {
+  const configPath = getConfigPath(cwd);
+  if (!existsSync(configPath)) {
+    throw new Error(
+      `No ${CONFIG_FILE} found. Run "visor init" first.`
+    );
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return {
+    paths: {
+      ...DEFAULT_CONFIG.paths,
+      ...parsed.paths
+    }
+  };
+}
+function writeConfig(cwd, config) {
+  const configPath = getConfigPath(cwd);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+// src/utils/packages.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function readPackageJson(cwd) {
+  const pkgPath = join2(cwd, "package.json");
+  if (!existsSync2(pkgPath)) return null;
+  return JSON.parse(readFileSync2(pkgPath, "utf-8"));
+}
+function isPackageInstalled(packageName, cwd) {
+  const pkg = readPackageJson(cwd);
+  if (!pkg) return false;
+  return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName]);
+}
+function hasVisorTokens(cwd) {
+  return isPackageInstalled("@loworbitstudio/visor-core", cwd);
+}
+function getUninstalledDeps(dependencies, cwd) {
+  return dependencies.filter((dep) => !isPackageInstalled(dep, cwd));
+}
+function installPackages(packages, cwd, dev = false) {
+  if (packages.length === 0) return true;
+  const args = ["install", dev ? "--save-dev" : "--save", ...packages];
+  try {
+    execFileSync("npm", args, { cwd, stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info(message) {
+    console.log(message);
+  },
+  success(message) {
+    console.log(pc.green(`\u2713 ${message}`));
+  },
+  warn(message) {
+    console.log(pc.yellow(`\u26A0 ${message}`));
+  },
+  error(message) {
+    console.error(pc.red(`\u2717 ${message}`));
+  },
+  item(message) {
+    console.log(pc.dim(`  ${message}`));
+  },
+  heading(message) {
+    console.log(pc.bold(message));
+  },
+  blank() {
+    console.log();
+  }
+};
+
+// src/commands/templates/nextjs.ts
+var NEXTJS_STARTER_YAML = `name: my-app
+version: 1
+colors:
+  primary: "#2563EB"
+`;
+
+// src/commands/init.ts
+import { generateThemeData } from "@loworbitstudio/visor-theme-engine";
+import { nextjsAdapter } from "@loworbitstudio/visor-theme-engine/adapters";
+function initCommand(cwd, options) {
+  const json = options?.json ?? false;
+  const filesCreated = [];
+  const filesSkipped = [];
+  const warnings = [];
+  if (options?.template && options.template !== "nextjs") {
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: `Unknown template: ${options.template}. Available templates: nextjs` },
+          null,
+          2
+        )
+      );
+    } else {
+      logger.error(`Unknown template: ${options.template}`);
+      logger.info("Available templates: nextjs");
+    }
+    process.exit(1);
+  }
+  if (configExists(cwd)) {
+    filesSkipped.push("visor.json");
+    if (!json) {
+      logger.warn("visor.json already exists. Skipping config creation.");
+    }
+  } else {
+    writeConfig(cwd, DEFAULT_CONFIG);
+    filesCreated.push("visor.json");
+    if (!json) {
+      logger.success("Created visor.json");
+      logger.blank();
+      logger.info("Default paths:");
+      logger.item(`components      \u2192 ${DEFAULT_CONFIG.paths.components}`);
+      logger.item(`deck components \u2192 ${DEFAULT_CONFIG.paths.deckComponents}`);
+      logger.item(`blocks          \u2192 ${DEFAULT_CONFIG.paths.blocks}`);
+      logger.item(`hooks           \u2192 ${DEFAULT_CONFIG.paths.hooks}`);
+      logger.item(`lib             \u2192 ${DEFAULT_CONFIG.paths.lib}`);
+    }
+  }
+  if (options?.template === "nextjs") {
+    scaffoldNextjs(cwd, json, filesCreated, filesSkipped);
+  }
+  const missingTokens = !hasVisorTokens(cwd);
+  if (missingTokens) {
+    const warning = "@loworbitstudio/visor-core is not installed. Components require it for styling.";
+    warnings.push(warning);
+    if (!json) {
+      logger.blank();
+      logger.warn(warning);
+      logger.info("  For Next.js: re-run with --template nextjs to generate tokens inline.");
+    }
+  }
+  if (json) {
+    const nextSteps = [];
+    if (options?.template === "nextjs") {
+      nextSteps.push("Customize colors in .visor.yaml");
+      nextSteps.push("Add FOWT prevention script to your layout.tsx <head>");
+      nextSteps.push("Run: npx visor add button \u2014 to add your first component");
+    } else {
+      nextSteps.push("Run: npx visor add button \u2014 to add your first component");
+    }
+    if (missingTokens) {
+      nextSteps.push("Re-run with --template nextjs to generate tokens inline (no npm package needed)");
+    }
+    console.log(
+      JSON.stringify(
+        {
+          success: true,
+          config: DEFAULT_CONFIG,
+          files: { created: filesCreated, skipped: filesSkipped },
+          warnings,
+          nextSteps
+        },
+        null,
+        2
+      )
+    );
+    process.exit(0);
+  }
+}
+function scaffoldNextjs(cwd, json, filesCreated, filesSkipped) {
+  if (!json) {
+    logger.blank();
+    logger.info("Scaffolding NextJS theme...");
+  }
+  const yamlPath = join3(cwd, ".visor.yaml");
+  if (existsSync3(yamlPath)) {
+    filesSkipped.push(".visor.yaml");
+    if (!json) {
+      logger.warn(".visor.yaml already exists. Skipping.");
+    }
+  } else {
+    writeFileSync2(yamlPath, NEXTJS_STARTER_YAML, "utf-8");
+    filesCreated.push(".visor.yaml");
+    if (!json) {
+      logger.success("Created .visor.yaml");
+    }
+  }
+  const data = generateThemeData(NEXTJS_STARTER_YAML);
+  const css = nextjsAdapter({
+    primitives: data.primitives,
+    tokens: data.tokens,
+    config: data.config
+  });
+  const globalsPath = join3(cwd, "app", "globals.css");
+  const globalsDir = dirname(globalsPath);
+  if (existsSync3(globalsPath)) {
+    filesSkipped.push("app/globals.css");
+    if (!json) {
+      logger.warn("app/globals.css already exists. Skipping.");
+    }
+  } else {
+    mkdirSync(globalsDir, { recursive: true });
+    writeFileSync2(globalsPath, css, "utf-8");
+    filesCreated.push("app/globals.css");
+    if (!json) {
+      logger.success("Created app/globals.css with theme tokens");
+    }
+  }
+  if (!json) {
+    logger.blank();
+    logger.info("Next steps:");
+    logger.item("Customize colors in .visor.yaml");
+    logger.item("Add FOWT prevention script to your layout.tsx <head>");
+    logger.item("Run: npx visor add button \u2014 to add your first component");
+  }
+}
+
+// src/registry/resolve.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var cachedRegistry = null;
+function loadRegistry() {
+  if (cachedRegistry) return cachedRegistry;
+  const registryPath = join4(__dirname, "registry.json");
+  const raw = readFileSync3(registryPath, "utf-8");
+  cachedRegistry = JSON.parse(raw);
+  return cachedRegistry;
+}
+function findItem(registry, name) {
+  return registry.items.find((item) => item.name === name);
+}
+function resolveTransitiveDeps(registry, names) {
+  const resolved = /* @__PURE__ */ new Map();
+  const queue = [...names];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (resolved.has(name)) continue;
+    const item = findItem(registry, name);
+    if (!item) {
+      throw new Error(`Registry item "${name}" not found.`);
+    }
+    resolved.set(name, item);
+    if (item.registryDependencies) {
+      for (const dep of item.registryDependencies) {
+        if (!resolved.has(dep)) {
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  return Array.from(resolved.values());
+}
+function collectDependencies(items) {
+  const deps = /* @__PURE__ */ new Set();
+  const devDeps = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (item.dependencies) {
+      for (const dep of item.dependencies) {
+        deps.add(dep);
+      }
+    }
+    if (item.devDependencies) {
+      for (const dep of item.devDependencies) {
+        devDeps.add(dep);
+      }
+    }
+  }
+  return {
+    dependencies: Array.from(deps).sort(),
+    devDependencies: Array.from(devDeps).sort()
+  };
+}
+
+// src/utils/fs.ts
+import {
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync4,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2
+} from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+function resolveOutputPath(registryPath, type, config, cwd) {
+  let relativePath;
+  if (type === "registry:block") {
+    relativePath = registryPath.replace(/^blocks\//, "");
+    return join5(cwd, config.paths.blocks, relativePath);
+  }
+  if (type === "registry:ui") {
+    if (registryPath.startsWith("components/deck/")) {
+      relativePath = registryPath.replace(/^components\/deck\//, "");
+      return join5(cwd, config.paths.deckComponents, relativePath);
+    }
+    relativePath = registryPath.replace(/^components\/ui\//, "");
+    return join5(cwd, config.paths.components, relativePath);
+  }
+  if (type === "registry:hook") {
+    relativePath = registryPath.replace(/^hooks\//, "");
+    return join5(cwd, config.paths.hooks, relativePath);
+  }
+  if (type === "registry:lib") {
+    relativePath = registryPath.replace(/^lib\//, "");
+    return join5(cwd, config.paths.lib, relativePath);
+  }
+  return join5(cwd, registryPath);
+}
+function writeFile(filePath, content) {
+  const dir = dirname3(filePath);
+  if (!existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync3(filePath, content, "utf-8");
+}
+function readFile(filePath) {
+  if (!existsSync4(filePath)) return null;
+  return readFileSync4(filePath, "utf-8");
+}
+function fileExists(filePath) {
+  return existsSync4(filePath);
+}
+
+// src/commands/list.ts
+var TYPE_LABELS = {
+  "registry:ui": "Components",
+  "registry:hook": "Hooks",
+  "registry:lib": "Utilities",
+  "registry:block": "Blocks",
+  "registry:page": "Pages",
+  "registry:theme": "Themes",
+  "registry:style": "Styles"
+};
+var CATEGORY_LABELS = {
+  deck: "Deck Components",
+  authentication: "Authentication Blocks"
+};
+function listCommand(cwd, options = {}) {
+  const json = options.json ?? false;
+  let registry;
+  try {
+    registry = loadRegistry();
+  } catch (error) {
+    if (json) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(JSON.stringify({ success: false, error: message }, null, 2));
+      process.exit(1);
+    }
+    throw error;
+  }
+  let registryItems = registry.items;
+  if (options.category) {
+    registryItems = registry.items.filter(
+      (item) => item.category === options.category
+    );
+    if (registryItems.length === 0) {
+      if (json) {
+        console.log(
+          JSON.stringify(
+            { success: false, error: `No items found in category "${options.category}".` },
+            null,
+            2
+          )
+        );
+        process.exit(1);
+        return;
+      }
+      logger.error(`No items found in category "${options.category}".`);
+      process.exit(1);
+      return;
+    }
+  }
+  const hasConfig = configExists(cwd);
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const item of registryItems) {
+    const groupKey = item.category ? `${item.type}||${item.category}` : item.type;
+    const existing = groupMap.get(groupKey);
+    if (existing) {
+      existing.items.push(item);
+    } else {
+      groupMap.set(groupKey, {
+        type: item.type,
+        category: item.category,
+        items: [item]
+      });
+    }
+  }
+  const config = hasConfig ? loadConfig(cwd) : null;
+  if (json) {
+    const items = registryItems.map((item) => {
+      let installed = false;
+      if (config) {
+        const firstFile = item.files[0];
+        if (firstFile) {
+          const outputPath = resolveOutputPath(
+            firstFile.path,
+            firstFile.type,
+            config,
+            cwd
+          );
+          installed = fileExists(outputPath);
+        }
+      }
+      return {
+        type: item.type,
+        category: item.category ?? null,
+        name: item.name,
+        description: item.description ?? null,
+        installed
+      };
+    });
+    const byType = {};
+    for (const item of items) {
+      byType[item.type] = (byType[item.type] ?? 0) + 1;
+    }
+    console.log(
+      JSON.stringify(
+        {
+          success: true,
+          items,
+          summary: {
+            total: items.length,
+            installed: items.filter((i) => i.installed).length,
+            byType
+          }
+        },
+        null,
+        2
+      )
+    );
+    process.exit(0);
+    return;
+  }
+  for (const group of groupMap.values()) {
+    const label = group.category ? CATEGORY_LABELS[group.category] ?? `${TYPE_LABELS[group.type] ?? group.type} (${group.category})` : TYPE_LABELS[group.type] ?? group.type;
+    logger.heading(`${label} (${group.items.length})`);
+    logger.blank();
+    for (const item of group.items) {
+      let installed = false;
+      if (config) {
+        const firstFile = item.files[0];
+        if (firstFile) {
+          const outputPath = resolveOutputPath(
+            firstFile.path,
+            firstFile.type,
+            config,
+            cwd
+          );
+          installed = fileExists(outputPath);
+        }
+      }
+      const status = installed ? " (installed)" : "";
+      const name = item.name.padEnd(24);
+      const desc = item.description ?? "";
+      logger.info(`  ${name} ${desc}${status}`);
+    }
+    logger.blank();
+  }
+}
+
+// src/commands/add.ts
+function addCommand(components, cwd, options = {}) {
+  const json = options.json ?? false;
+  let autoInitialized = false;
+  if (!configExists(cwd)) {
+    writeConfig(cwd, DEFAULT_CONFIG);
+    autoInitialized = true;
+    if (!json) {
+      logger.info("No visor.json found \u2014 created one with default paths.");
+      logger.blank();
+    }
+  }
+  let config;
+  let registry;
+  try {
+    config = loadConfig(cwd);
+    registry = loadRegistry();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: message }, null, 2));
+    } else {
+      logger.error(message);
+    }
+    process.exit(1);
+  }
+  if (options.block && components.length > 0) {
+    for (const name of components) {
+      const item = registry.items.find((i) => i.name === name);
+      if (item && item.type !== "registry:block") {
+        if (json) {
+          console.log(
+            JSON.stringify(
+              { success: false, error: `"${name}" is not a block. Remove the --block flag to install it as a component.` },
+              null,
+              2
+            )
+          );
+        } else {
+          logger.error(
+            `"${name}" is not a block. Remove the --block flag to install it as a component.`
+          );
+        }
+        process.exit(1);
+      }
+    }
+  }
+  let itemNames = components;
+  if (options.category) {
+    if (components.length > 0) {
+      if (json) {
+        console.log(
+          JSON.stringify(
+            { success: false, error: "Cannot use --category with individual component names. Use one or the other." },
+            null,
+            2
+          )
+        );
+      } else {
+        logger.error(
+          "Cannot use --category with individual component names. Use one or the other."
+        );
+      }
+      process.exit(1);
+    }
+    const categoryItems = registry.items.filter(
+      (item) => item.category === options.category
+    );
+    if (categoryItems.length === 0) {
+      if (json) {
+        console.log(
+          JSON.stringify(
+            { success: false, error: `No items found in category "${options.category}".` },
+            null,
+            2
+          )
+        );
+      } else {
+        logger.error(`No items found in category "${options.category}".`);
+      }
+      process.exit(1);
+    }
+    itemNames = categoryItems.map((item) => item.name);
+    if (!json) {
+      logger.info(
+        `Category "${options.category}": ${itemNames.length} item(s) found`
+      );
+    }
+  }
+  if (itemNames.length === 0) {
+    if (options.block) {
+      const blockItems = registry.items.filter(
+        (item) => item.type === "registry:block"
+      );
+      if (json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: false,
+              error: blockItems.length === 0 ? "No blocks available in the registry." : `No block name specified. Available blocks: ${blockItems.map((i) => i.name).join(", ")}`
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        if (blockItems.length === 0) {
+          logger.error("No blocks available in the registry.");
+        } else {
+          logger.error("No block name specified. Available blocks:");
+          for (const item of blockItems) {
+            logger.info(`  ${item.name}`);
+          }
+        }
+      }
+      process.exit(1);
+    }
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { success: false, error: "No items specified. Provide item names or use --category." },
+          null,
+          2
+        )
+      );
+    } else {
+      logger.error("No items specified. Provide item names or use --category.");
+    }
+    process.exit(1);
+  }
+  let items;
+  try {
+    items = resolveTransitiveDeps(registry, itemNames);
+  } catch (error) {
+    if (json) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(JSON.stringify({ success: false, error: message }, null, 2));
+      process.exit(1);
+    }
+    throw error;
+  }
+  if (!json) {
+    logger.info(
+      `Resolving ${itemNames.length} item(s) \u2192 ${items.length} total (with dependencies)`
+    );
+    logger.blank();
+  }
+  const writtenFiles = [];
+  const skippedFiles = [];
+  for (const item of items) {
+    for (const file of item.files) {
+      const outputPath = resolveOutputPath(
+        file.path,
+        file.type,
+        config,
+        cwd
+      );
+      if (fileExists(outputPath) && !options.overwrite) {
+        if (!json) {
+          logger.item(`skip ${file.path} (already exists)`);
+        }
+        skippedFiles.push(file.path);
+        continue;
+      }
+      writeFile(outputPath, file.content);
+      if (!json) {
+        logger.success(file.path);
+      }
+      writtenFiles.push(file.path);
+    }
+  }
+  if (!json) {
+    logger.blank();
+    logger.info(
+      `Files: ${writtenFiles.length} written, ${skippedFiles.length} skipped`
+    );
+  }
+  const { dependencies, devDependencies } = collectDependencies(items);
+  const uninstalledDeps = getUninstalledDeps(dependencies, cwd);
+  const uninstalledDevDeps = getUninstalledDeps(devDependencies, cwd);
+  const installedDeps = [];
+  const failedDeps = [];
+  if (uninstalledDeps.length > 0) {
+    if (!json) {
+      logger.blank();
+      logger.info("Installing dependencies...");
+    }
+    if (installPackages(uninstalledDeps, cwd)) {
+      installedDeps.push(...uninstalledDeps);
+    } else {
+      failedDeps.push(...uninstalledDeps);
+      if (!json) {
+        logger.warn("Some dependencies failed to install. Install them manually:");
+        logger.info(`  npm install ${uninstalledDeps.join(" ")}`);
+      }
+    }
+  }
+  if (uninstalledDevDeps.length > 0) {
+    if (!json) {
+      logger.blank();
+      logger.info("Installing dev dependencies...");
+    }
+    if (installPackages(uninstalledDevDeps, cwd, true)) {
+      installedDeps.push(...uninstalledDevDeps);
+    } else {
+      failedDeps.push(...uninstalledDevDeps);
+      if (!json) {
+        logger.warn("Some dev dependencies failed to install. Install them manually:");
+        logger.info(`  npm install --save-dev ${uninstalledDevDeps.join(" ")}`);
+      }
+    }
+  }
+  const warnings = [];
+  if (!hasVisorTokens(cwd)) {
+    const warning = "@loworbitstudio/visor-core is not installed. Components require it for styling.";
+    warnings.push(warning);
+    if (!json) {
+      logger.blank();
+      logger.warn(warning);
+      logger.info("  For Next.js: npx @loworbitstudio/visor init --template nextjs");
+      logger.info("  This generates all tokens inline \u2014 no npm package needed.");
+    }
+  }
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          success: true,
+          autoInitialized,
+          requested: itemNames,
+          resolved: items.map((i) => i.name),
+          files: { written: writtenFiles, skipped: skippedFiles },
+          dependencies: { installed: installedDeps, failed: failedDeps },
+          warnings
+        },
+        null,
+        2
+      )
+    );
+    process.exit(0);
+  }
+}
+
+// src/utils/diff.ts
+import { createTwoFilesPatch } from "diff";
+function computeDiff(filePath, localContent, registryContent) {
+  return createTwoFilesPatch(
+    `a/${filePath}`,
+    `b/${filePath}`,
+    localContent,
+    registryContent,
+    "local",
+    "registry"
+  );
+}
+function hasDifferences(localContent, registryContent) {
+  return localContent !== registryContent;
+}
+
+// src/commands/diff.ts
+function diffCommand(componentName, cwd, options = {}) {
+  const json = options.json ?? false;
+  let config;
+  let registry;
+  try {
+    config = loadConfig(cwd);
+    registry = loadRegistry();
+  } catch (error) {
+    if (json) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(JSON.stringify({ success: false, error: message }, null, 2));
+      process.exit(1);
+    }
+    throw error;
+  }
+  const itemsToDiff = componentName ? (() => {
+    const item = findItem(registry, componentName);
+    if (!item) {
+      if (json) {
+        console.log(
+          JSON.stringify(
+            { success: false, error: `Component "${componentName}" not found in registry.` },
+            null,
+            2
+          )
+        );
+      } else {
+        logger.error(`Component "${componentName}" not found in registry.`);
+      }
+      process.exit(1);
+    }
+    return [item];
+  })() : registry.items;
+  let totalDiffs = 0;
+  let totalFiles = 0;
+  const diffs = [];
+  for (const item of itemsToDiff) {
+    let itemHasDiff = false;
+    for (const file of item.files) {
+      const outputPath = resolveOutputPath(
+        file.path,
+        file.type,
+        config,
+        cwd
+      );
+      const localContent = readFile(outputPath);
+      if (localContent === null) continue;
+      totalFiles++;
+      const fileHasDiff = hasDifferences(localContent, file.content);
+      if (json) {
+        const diffText = fileHasDiff ? computeDiff(file.path, localContent, file.content) : "";
+        diffs.push({
+          file: file.path,
+          component: item.name,
+          hasDifferences: fileHasDiff,
+          diff: diffText
+        });
+        if (fileHasDiff) {
+          totalDiffs++;
+        }
+        continue;
+      }
+      if (!fileHasDiff) continue;
+      if (!itemHasDiff) {
+        logger.heading(item.name);
+        itemHasDiff = true;
+      }
+      const diff = computeDiff(file.path, localContent, file.content);
+      console.log(diff);
+      totalDiffs++;
+    }
+  }
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          success: true,
+          diffs,
+          summary: {
+            totalFiles,
+            filesWithDiffs: totalDiffs
+          }
+        },
+        null,
+        2
+      )
+    );
+    process.exit(0);
+    return;
+  }
+  if (totalDiffs === 0) {
+    if (totalFiles === 0) {
+      logger.info("No installed components found.");
+    } else {
+      logger.success("All files match the registry. No differences found.");
+    }
+  } else {
+    logger.blank();
+    logger.info(`${totalDiffs} file(s) with differences`);
+  }
+}
+
+// src/commands/theme-apply.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { resolve, dirname as dirname4 } from "path";
+import { generateTheme, generateThemeData as generateThemeData2 } from "@loworbitstudio/visor-theme-engine";
+import {
+  nextjsAdapter as nextjsAdapter2,
+  fumadocsAdapter,
+  deckAdapter,
+  docsAdapter
+} from "@loworbitstudio/visor-theme-engine/adapters";
+function defaultOutputPath(adapter, themeName) {
+  switch (adapter) {
+    case "nextjs":
+      return "globals.css";
+    case "fumadocs":
+      return "visor-fumadocs-bridge.css";
+    case "deck": {
+      const slug = (themeName ?? "theme").toLowerCase().replace(/\s+/g, "-");
+      return `visor-deck-${slug}.css`;
+    }
+    case "docs": {
+      const slug = (themeName ?? "theme").toLowerCase().replace(/\s+/g, "-");
+      return `${slug}-theme.css`;
+    }
+    default:
+      return "visor-theme.css";
+  }
+}
+function themeApplyCommand(file, cwd, options) {
+  const filePath = resolve(cwd, file);
+  let yamlContent;
+  try {
+    yamlContent = readFileSync5(filePath, "utf-8");
+  } catch {
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: `Could not read file: ${filePath}`
+        })
+      );
+    } else {
+      logger.error(`Could not read file: ${filePath}`);
+      logger.info("Make sure the file exists and is readable.");
+    }
+    process.exit(2);
+  }
+  let css;
+  let themeName;
+  let sections;
+  try {
+    if (options.adapter) {
+      const data = generateThemeData2(yamlContent);
+      themeName = data.config.name;
+      const adapterInput = {
+        primitives: data.primitives,
+        tokens: data.tokens,
+        config: data.config
+      };
+      switch (options.adapter) {
+        case "nextjs":
+          css = nextjsAdapter2(adapterInput);
+          break;
+        case "fumadocs":
+          css = fumadocsAdapter(adapterInput);
+          break;
+        case "deck":
+          css = deckAdapter(adapterInput);
+          break;
+        case "docs":
+          css = docsAdapter(adapterInput);
+          break;
+        default:
+          throw new Error(`Unknown adapter: ${options.adapter}`);
+      }
+    } else {
+      const output = generateTheme(yamlContent);
+      css = output.fullBundleCss;
+      sections = {
+        primitives: output.primitivesCss.length,
+        semantic: output.semanticCss.length,
+        light: output.lightCss.length,
+        dark: output.darkCss.length,
+        fullBundle: output.fullBundleCss.length
+      };
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error generating theme";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: message }));
+    } else {
+      logger.error("Failed to generate theme.");
+      logger.info(message);
+    }
+    process.exit(1);
+  }
+  const outputFile = options.output ?? defaultOutputPath(options.adapter, themeName);
+  const outputPath = resolve(cwd, outputFile);
+  const outputDir = dirname4(outputPath);
+  try {
+    mkdirSync3(outputDir, { recursive: true });
+    writeFileSync4(outputPath, css, "utf-8");
+  } catch {
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: `Could not write to: ${outputPath}`
+        })
+      );
+    } else {
+      logger.error(`Could not write to: ${outputPath}`);
+    }
+    process.exit(2);
+  }
+  if (options.json) {
+    const jsonResult = {
+      success: true,
+      file: outputPath
+    };
+    if (options.adapter) {
+      jsonResult.adapter = options.adapter;
+      jsonResult.size = css.length;
+    }
+    if (sections) {
+      jsonResult.sections = sections;
+    }
+    console.log(JSON.stringify(jsonResult));
+  } else {
+    logger.success(`Theme CSS generated: ${outputPath}`);
+    if (options.adapter) {
+      logger.info(`Adapter: ${options.adapter}`);
+    }
+    logger.item(`Size: ${formatSize(css.length)}`);
+  }
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  return `${(bytes / 1024).toFixed(1)} KB`;
+}
+
+// src/commands/theme-export.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve2 } from "path";
+import {
+  parseConfig,
+  resolveConfig,
+  generatePrimitives,
+  exportTheme
+} from "@loworbitstudio/visor-theme-engine";
+function themeExportCommand(file, cwd, options) {
+  const filePath = resolve2(cwd, file ?? ".visor.yaml");
+  let yamlContent;
+  try {
+    yamlContent = readFileSync6(filePath, "utf-8");
+  } catch {
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: `Could not read file: ${filePath}`
+        })
+      );
+    } else {
+      logger.error(`Could not read file: ${filePath}`);
+      logger.info(
+        "Make sure a .visor.yaml file exists in the current directory, or specify a path."
+      );
+    }
+    process.exit(2);
+  }
+  let config;
+  try {
+    config = parseConfig(yamlContent);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error parsing config";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: message }));
+    } else {
+      logger.error("Failed to parse theme config.");
+      logger.info(message);
+    }
+    process.exit(1);
+  }
+  const resolved = resolveConfig(config);
+  const primitives = generatePrimitives(resolved);
+  const exportedYaml = exportTheme(primitives, resolved);
+  const format = options.format ?? "yaml";
+  if (options.json) {
+    if (format === "json") {
+      const parsed = parseConfig(exportedYaml);
+      console.log(JSON.stringify({ success: true, theme: parsed }));
+    } else {
+      console.log(JSON.stringify({ success: true, yaml: exportedYaml }));
+    }
+  } else {
+    if (format === "json") {
+      const parsed = parseConfig(exportedYaml);
+      console.log(JSON.stringify(parsed, null, 2));
+    } else {
+      console.log(exportedYaml);
+    }
+  }
+}
+
+// src/commands/theme-validate.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve3 } from "path";
+import { parse as parseYaml } from "yaml";
+import { validate } from "@loworbitstudio/visor-theme-engine";
+import pc2 from "picocolors";
+function themeValidateCommand(file, cwd, options) {
+  const filePath = resolve3(cwd, file);
+  let fileContent;
+  try {
+    fileContent = readFileSync7(filePath, "utf-8");
+  } catch {
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          valid: false,
+          errors: [
+            {
+              severity: "error",
+              code: "FILE_NOT_FOUND",
+              message: `Could not read file: ${filePath}`
+            }
+          ],
+          warnings: []
+        })
+      );
+    } else {
+      logger.error(`Could not read file: ${filePath}`);
+      logger.info("Make sure the file exists and is readable.");
+    }
+    process.exit(2);
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(fileContent);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Invalid YAML syntax";
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          valid: false,
+          errors: [
+            {
+              severity: "error",
+              code: "YAML_PARSE_ERROR",
+              message
+            }
+          ],
+          warnings: []
+        })
+      );
+    } else {
+      logger.error("Invalid YAML syntax.");
+      logger.info(message);
+    }
+    process.exit(1);
+  }
+  const result = validate(parsed);
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    process.exit(result.valid ? 0 : 1);
+  }
+  if (result.valid && result.warnings.length === 0) {
+    logger.success("Theme is valid. No issues found.");
+    process.exit(0);
+  }
+  if (result.valid) {
+    logger.success("Theme is valid.");
+    logger.blank();
+  }
+  if (result.errors.length > 0) {
+    logger.heading(`${result.errors.length} error(s):`);
+    for (const err of result.errors) {
+      printIssue(err);
+    }
+    logger.blank();
+  }
+  if (result.warnings.length > 0) {
+    logger.heading(`${result.warnings.length} warning(s):`);
+    for (const warn of result.warnings) {
+      printIssue(warn);
+    }
+    logger.blank();
+  }
+  if (!result.valid) {
+    logger.error("Validation failed. Fix the errors above before applying this theme.");
+    process.exit(1);
+  }
+}
+function printIssue(issue) {
+  const prefix = issue.severity === "error" ? pc2.red("  ERROR") : pc2.yellow("  WARN ");
+  const code = pc2.dim(`[${issue.code}]`);
+  const path = issue.path ? pc2.dim(` (${issue.path})`) : "";
+  console.log(`${prefix} ${code} ${issue.message}${path}`);
+}
+
+// src/commands/theme-extract.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync5, readdirSync, statSync } from "fs";
+import { resolve as resolve4, join as join6, basename, extname, relative } from "path";
+import { stringify as stringifyYaml } from "yaml";
+import {
+  extractFromCSS,
+  validate as validate2
+} from "@loworbitstudio/visor-theme-engine";
+var CSS_FILE_PATTERNS = [
+  "globals.css",
+  "global.css",
+  "tokens.css",
+  "variables.css",
+  "theme.css",
+  "design-tokens.css",
+  "primitives.css",
+  "semantic.css",
+  "adaptive.css"
+];
+var CSS_DIRS = [
+  "src",
+  "app",
+  "styles",
+  "css",
+  "src/styles",
+  "src/app",
+  "src/css",
+  "packages/tokens",
+  "packages/design-tokens"
+];
+function themeExtractCommand(cwd, options) {
+  const targetDir = resolve4(cwd, options.from ?? ".");
+  if (!existsSync5(targetDir)) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: `Directory not found: ${targetDir}` }));
+    } else {
+      logger.error(`Directory not found: ${targetDir}`);
+    }
+    process.exit(2);
+  }
+  if (!options.json) {
+    logger.heading("Visor Theme Extractor");
+    logger.info(`Scanning: ${targetDir}`);
+    logger.blank();
+  }
+  const cssFiles = collectCSSFiles(targetDir);
+  if (cssFiles.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: false,
+        error: "No CSS files found to extract from."
+      }));
+    } else {
+      logger.error("No CSS files found to extract from.");
+      logger.info("Make sure the target directory contains .css files with custom properties.");
+    }
+    process.exit(2);
+  }
+  if (!options.json) {
+    logger.info(`Found ${cssFiles.length} CSS file(s):`);
+    for (const f of cssFiles) {
+      logger.item(relative(targetDir, f.path));
+    }
+    logger.blank();
+  }
+  const themeName = inferThemeName(targetDir);
+  const result = extractFromCSS(cssFiles, themeName);
+  resolveVarFontReferences(result, targetDir);
+  const fontHints = extractFontHints(targetDir);
+  if (fontHints && !result.config.typography) {
+    result.config.typography = fontHints;
+  }
+  let validationResult;
+  if (options.runValidation) {
+    validationResult = validate2(result.config);
+  }
+  if (options.json) {
+    outputJSON(result, validationResult);
+  } else {
+    outputYAML(result, options.output, cwd, validationResult);
+  }
+}
+function collectCSSFiles(targetDir) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of CSS_FILE_PATTERNS) {
+    const rootPath = join6(targetDir, pattern);
+    addFileIfExists(rootPath, files, seen);
+    for (const dir of CSS_DIRS) {
+      const dirPath = join6(targetDir, dir, pattern);
+      addFileIfExists(dirPath, files, seen);
+    }
+  }
+  for (const dir of CSS_DIRS) {
+    const dirPath = join6(targetDir, dir);
+    if (existsSync5(dirPath) && statSync(dirPath).isDirectory()) {
+      scanDirForCSS(dirPath, files, seen, 2);
+    }
+  }
+  scanDirForCSS(targetDir, files, seen, 0);
+  return files;
+}
+function addFileIfExists(filePath, files, seen) {
+  const resolved = resolve4(filePath);
+  if (seen.has(resolved)) return;
+  if (!existsSync5(resolved)) return;
+  try {
+    const content = readFileSync8(resolved, "utf-8");
+    if (content.includes("--")) {
+      files.push({ path: resolved, content });
+      seen.add(resolved);
+    }
+  } catch {
+  }
+}
+function scanDirForCSS(dir, files, seen, maxDepth) {
+  if (!existsSync5(dir)) return;
+  const SKIP_DIRS = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".next",
+    ".nuxt",
+    "dist",
+    "build",
+    ".git",
+    ".cache",
+    "coverage",
+    ".turbo",
+    ".vercel"
+  ]);
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (maxDepth > 0) {
+          scanDirForCSS(join6(dir, entry.name), files, seen, maxDepth - 1);
+        }
+      } else if (entry.isFile() && extname(entry.name) === ".css") {
+        addFileIfExists(join6(dir, entry.name), files, seen);
+      }
+    }
+  } catch {
+  }
+}
+var LAYOUT_FILE_PATHS = [
+  "src/app/layout.tsx",
+  "src/app/layout.ts",
+  "src/app/layout.jsx",
+  "src/app/layout.js",
+  "app/layout.tsx",
+  "app/layout.ts",
+  "app/layout.jsx",
+  "app/layout.js",
+  "src/pages/_app.tsx",
+  "src/pages/_app.ts",
+  "src/pages/_app.jsx",
+  "src/pages/_app.js",
+  "pages/_app.tsx",
+  "pages/_app.ts",
+  "pages/_app.jsx",
+  "pages/_app.js"
+];
+var NEXT_FONT_MAP = {
+  Inter: "Inter",
+  Roboto: "Roboto",
+  Open_Sans: "Open Sans",
+  Lato: "Lato",
+  Poppins: "Poppins",
+  Montserrat: "Montserrat",
+  Raleway: "Raleway",
+  Nunito: "Nunito",
+  Playfair_Display: "Playfair Display",
+  Source_Code_Pro: "Source Code Pro",
+  Fira_Code: "Fira Code",
+  JetBrains_Mono: "JetBrains Mono",
+  Roboto_Mono: "Roboto Mono",
+  IBM_Plex_Mono: "IBM Plex Mono",
+  IBM_Plex_Sans: "IBM Plex Sans",
+  DM_Sans: "DM Sans",
+  Space_Grotesk: "Space Grotesk",
+  Geist: "Geist",
+  Geist_Mono: "Geist Mono",
+  Manrope: "Manrope",
+  Outfit: "Outfit",
+  Plus_Jakarta_Sans: "Plus Jakarta Sans",
+  Work_Sans: "Work Sans",
+  Rubik: "Rubik",
+  Sora: "Sora",
+  Lexend: "Lexend"
+};
+function resolveVarFontReferences(result, targetDir) {
+  const typo = result.config.typography;
+  if (!typo) return;
+  const hasVarRef = typo.heading?.family?.startsWith("var(") || typo.body?.family?.startsWith("var(") || typo.mono?.family?.startsWith("var(");
+  if (!hasVarRef) return;
+  const fontMap = parseNextFontFromLayouts(targetDir);
+  if (fontMap.size === 0) return;
+  if (typo.heading?.family?.startsWith("var(")) {
+    const varName = extractVarName(typo.heading.family);
+    const resolved = fontMap.get(varName);
+    if (resolved) typo.heading.family = resolved;
+  }
+  if (typo.body?.family?.startsWith("var(")) {
+    const varName = extractVarName(typo.body.family);
+    const resolved = fontMap.get(varName);
+    if (resolved) typo.body.family = resolved;
+  }
+  if (typo.mono?.family?.startsWith("var(")) {
+    const varName = extractVarName(typo.mono.family);
+    const resolved = fontMap.get(varName);
+    if (resolved) typo.mono.family = resolved;
+  }
+}
+function extractVarName(varExpr) {
+  const match = varExpr.match(/var\(\s*(--[\w-]+)/);
+  return match ? match[1] : varExpr;
+}
+function parseNextFontFromLayouts(targetDir) {
+  const fontMap = /* @__PURE__ */ new Map();
+  for (const relPath of LAYOUT_FILE_PATHS) {
+    const fullPath = join6(targetDir, relPath);
+    if (!existsSync5(fullPath)) continue;
+    try {
+      const content = readFileSync8(fullPath, "utf-8");
+      parseNextFontDeclarations(content, fontMap);
+    } catch {
+    }
+  }
+  return fontMap;
+}
+function parseNextFontDeclarations(content, fontMap) {
+  const googleImportRe = /import\s*\{([^}]+)\}\s*from\s*["']next\/font\/google["']/g;
+  let importMatch;
+  const importedFonts = [];
+  const googleImportMatches = content.matchAll(googleImportRe);
+  for (const m of googleImportMatches) {
+    const names = m[1].split(",").map((n) => n.trim()).filter(Boolean);
+    importedFonts.push(...names);
+  }
+  for (const fontName of importedFonts) {
+    const family = NEXT_FONT_MAP[fontName] ?? fontName.replace(/_/g, " ");
+    const callRe = new RegExp(
+      `(?:const|let|var)\\s+\\w+\\s*=\\s*${fontName}\\s*\\(\\s*\\{([\\s\\S]*?)\\}\\s*\\)`,
+      "m"
+    );
+    const callMatch = content.match(callRe);
+    if (callMatch) {
+      const varMatch = callMatch[1].match(/variable\s*:\s*["'](--[\w-]+)["']/);
+      if (varMatch) {
+        fontMap.set(varMatch[1], family);
+      }
+    }
+  }
+  const localImportRe = /import\s+(\w+)\s+from\s*["']next\/font\/local["']/;
+  const localImportMatch = content.match(localImportRe);
+  if (localImportMatch) {
+    const localFnName = localImportMatch[1];
+    const localCallRe = new RegExp(
+      `(?:const|let|var)\\s+\\w+\\s*=\\s*${localFnName}\\s*\\(\\s*\\{([\\s\\S]*?)\\}\\s*\\)`,
+      "gm"
+    );
+    const localCallMatches = content.matchAll(localCallRe);
+    for (const localCallMatch of localCallMatches) {
+      const block = localCallMatch[1];
+      const varMatch = block.match(/variable\s*:\s*["'](--[\w-]+)["']/);
+      if (!varMatch) continue;
+      const varName = varMatch[1];
+      const srcMatch = block.match(/src\s*:\s*["']([^"']+)["']/);
+      if (srcMatch) {
+        const srcPath = srcMatch[1];
+        const fileName = basename(srcPath, extname(srcPath));
+        const fontBaseName = fileName.replace(/[-_](Variable|Regular|Bold|Light|Medium|SemiBold|ExtraBold|Thin|Black|Italic).*$/i, "").replace(/[-_]/g, " ").trim();
+        if (fontBaseName) {
+          fontMap.set(varName, fontBaseName);
+        }
+      }
+    }
+  }
+}
+var FONT_PACKAGE_MAP = {
+  "@fontsource/inter": "Inter",
+  "@fontsource/roboto": "Roboto",
+  "@fontsource/open-sans": "Open Sans",
+  "@fontsource/lato": "Lato",
+  "@fontsource/poppins": "Poppins",
+  "@fontsource/montserrat": "Montserrat",
+  "@fontsource/raleway": "Raleway",
+  "@fontsource/nunito": "Nunito",
+  "@fontsource/playfair-display": "Playfair Display",
+  "@fontsource/source-code-pro": "Source Code Pro",
+  "@fontsource/fira-code": "Fira Code",
+  "@fontsource/jetbrains-mono": "JetBrains Mono",
+  "@fontsource-variable/inter": "Inter",
+  "@fontsource-variable/roboto": "Roboto",
+  "@fontsource-variable/open-sans": "Open Sans",
+  "next/font": ""
+  // handled separately
+};
+var MONO_FONT_NAMES = /* @__PURE__ */ new Set([
+  "Source Code Pro",
+  "Fira Code",
+  "JetBrains Mono",
+  "Roboto Mono",
+  "SF Mono",
+  "Cascadia Code",
+  "IBM Plex Mono"
+]);
+function extractFontHints(targetDir) {
+  const pkgPath = join6(targetDir, "package.json");
+  if (!existsSync5(pkgPath)) return void 0;
+  try {
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const fonts2 = [];
+    for (const [dep, _] of Object.entries(allDeps)) {
+      const family = FONT_PACKAGE_MAP[dep];
+      if (family) fonts2.push(family);
+      if (dep.startsWith("@fontsource/") && !FONT_PACKAGE_MAP[dep]) {
+        const name = dep.replace("@fontsource/", "").split("-").map(
+          (w) => w.charAt(0).toUpperCase() + w.slice(1)
+        ).join(" ");
+        fonts2.push(name);
+      }
+      if (dep.startsWith("@fontsource-variable/") && !FONT_PACKAGE_MAP[dep]) {
+        const name = dep.replace("@fontsource-variable/", "").split("-").map(
+          (w) => w.charAt(0).toUpperCase() + w.slice(1)
+        ).join(" ");
+        fonts2.push(name);
+      }
+    }
+    if (fonts2.length === 0) return void 0;
+    const result = {};
+    const monoFonts = fonts2.filter((f) => MONO_FONT_NAMES.has(f));
+    const bodyFonts = fonts2.filter((f) => !MONO_FONT_NAMES.has(f));
+    if (bodyFonts.length > 0) {
+      result.heading = { family: bodyFonts[0] };
+      result.body = { family: bodyFonts[0] };
+    }
+    if (monoFonts.length > 0) {
+      result.mono = { family: monoFonts[0] };
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function inferThemeName(targetDir) {
+  const pkgPath = join6(targetDir, "package.json");
+  if (existsSync5(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+      if (pkg.name) {
+        const name = pkg.name.replace(/^@[\w-]+\//, "");
+        return `${name}-theme`;
+      }
+    } catch {
+    }
+  }
+  return `${basename(targetDir)}-theme`;
+}
+function confidenceComment(confidence) {
+  return `# confidence: ${confidence}`;
+}
+function outputJSON(result, validationResult) {
+  const output = {
+    success: true,
+    config: result.config,
+    extraction: {
+      tokens: result.tokens,
+      unmapped: result.unmapped,
+      warnings: result.warnings,
+      summary: {
+        totalTokens: result.tokens.length,
+        highConfidence: result.tokens.filter((t) => t.confidence === "high").length,
+        mediumConfidence: result.tokens.filter((t) => t.confidence === "medium").length,
+        lowConfidence: result.tokens.filter((t) => t.confidence === "low").length,
+        unmappedCount: result.unmapped.length
+      }
+    }
+  };
+  if (validationResult) {
+    output.validation = validationResult;
+  }
+  console.log(JSON.stringify(output, null, 2));
+}
+function outputYAML(result, outputPath, cwd, validationResult) {
+  const yamlStr = buildAnnotatedYAML(result);
+  const outFile = resolve4(cwd, outputPath ?? ".visor.yaml");
+  const high = result.tokens.filter((t) => t.confidence === "high").length;
+  const med = result.tokens.filter((t) => t.confidence === "medium").length;
+  const low = result.tokens.filter((t) => t.confidence === "low").length;
+  logger.info("Extraction summary:");
+  logger.item(`${result.tokens.length} tokens extracted`);
+  logger.item(`  High confidence: ${high}`);
+  logger.item(`  Medium confidence: ${med}`);
+  logger.item(`  Low confidence: ${low}`);
+  logger.item(`${result.unmapped.length} unmapped tokens`);
+  logger.blank();
+  if (result.warnings.length > 0) {
+    logger.warn("Warnings:");
+    for (const w of result.warnings) {
+      logger.item(w);
+    }
+    logger.blank();
+  }
+  if (result.unmapped.length > 0) {
+    logger.info("Unmapped tokens (review manually):");
+    for (const u of result.unmapped.slice(0, 10)) {
+      logger.item(`${u.name}: ${u.value} (${u.context})`);
+    }
+    if (result.unmapped.length > 10) {
+      logger.item(`... and ${result.unmapped.length - 10} more`);
+    }
+    logger.blank();
+  }
+  writeFileSync5(outFile, yamlStr, "utf-8");
+  logger.success(`Theme written to ${relative(cwd, outFile)}`);
+  if (validationResult) {
+    logger.blank();
+    if (validationResult.valid) {
+      logger.success("Validation passed");
+    } else {
+      logger.warn("Validation issues:");
+      for (const err of validationResult.errors) {
+        logger.error(`  ${err.code}: ${err.message}`);
+      }
+    }
+    if (validationResult.warnings.length > 0) {
+      for (const w of validationResult.warnings) {
+        logger.warn(`  ${w.code}: ${w.message}`);
+      }
+    }
+  }
+}
+function buildAnnotatedYAML(result) {
+  const baseYaml = stringifyYaml(result.config, { lineWidth: 0 });
+  const confidenceMap = /* @__PURE__ */ new Map();
+  for (const token of result.tokens) {
+    confidenceMap.set(token.name, token.confidence);
+  }
+  const lines = baseYaml.split("\n");
+  const annotated = [];
+  let inColors = false;
+  let inColorsDark = false;
+  for (const line of lines) {
+    if (/^colors:/.test(line)) {
+      inColors = true;
+      inColorsDark = false;
+    } else if (/^colors-dark:/.test(line)) {
+      inColorsDark = true;
+      inColors = false;
+    } else if (/^\S/.test(line) && !line.startsWith(" ")) {
+      inColors = false;
+      inColorsDark = false;
+    }
+    if (inColors || inColorsDark) {
+      const match = line.match(/^\s+([\w-]+):\s/);
+      if (match) {
+        const role = match[1];
+        const key = `colors.${role}`;
+        const confidence = confidenceMap.get(key);
+        if (confidence) {
+          annotated.push(`${line} ${confidenceComment(confidence)}`);
+          continue;
+        }
+      }
+    }
+    annotated.push(line);
+  }
+  return annotated.join("\n");
+}
+
+// src/commands/theme-register.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "fs";
+import { resolve as resolve6, join as join8 } from "path";
+import { generateThemeData as generateThemeData3 } from "@loworbitstudio/visor-theme-engine";
+import { docsAdapter as docsAdapter2 } from "@loworbitstudio/visor-theme-engine/adapters";
+
+// src/utils/theme-helpers.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve5, dirname as dirname5, join as join7 } from "path";
+function toSlug(name) {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+function toLabel(name) {
+  return name.split(/[\s-]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function findRepoRoot(startDir) {
+  let current = resolve5(startDir);
+  while (true) {
+    if (existsSync6(join7(current, "packages", "docs"))) {
+      return current;
+    }
+    const parent = dirname5(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+// src/commands/theme-register.ts
+function insertGlobalsImport(content, slug) {
+  const importLine = `@import './${slug}-theme.css';`;
+  if (content.includes(importLine)) {
+    return { updated: content, changed: false };
+  }
+  const lines = content.split("\n");
+  const themeImportPattern = /^@import '\.\/[\w-]+-theme\.css';/;
+  const themeImportIndices = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (themeImportPattern.test(lines[i])) {
+      themeImportIndices.push(i);
+    }
+  }
+  if (themeImportIndices.length === 0) {
+    const lastImportIdx = lines.reduce(
+      (last, line, i) => line.startsWith("@import") ? i : last,
+      -1
+    );
+    const insertAt2 = lastImportIdx + 1;
+    lines.splice(insertAt2, 0, importLine);
+    return { updated: lines.join("\n"), changed: true };
+  }
+  let insertAt = themeImportIndices[themeImportIndices.length - 1] + 1;
+  for (const idx of themeImportIndices) {
+    if (importLine < lines[idx]) {
+      insertAt = idx;
+      break;
+    }
+  }
+  lines.splice(insertAt, 0, importLine);
+  return { updated: lines.join("\n"), changed: true };
+}
+function insertThemeConfig(content, slug, label, group) {
+  if (content.includes(`value: "${slug}"`)) {
+    return { updated: content, changed: false };
+  }
+  const escapedGroup = group.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const groupPattern = new RegExp(`label:\\s*"${escapedGroup}"`);
+  const groupMatch = groupPattern.exec(content);
+  if (!groupMatch) {
+    return {
+      updated: content,
+      changed: false,
+      error: `Group "${group}" not found in theme-config.ts. Available groups: Visor, Client, Low Orbit.`
+    };
+  }
+  const afterGroup = content.slice(groupMatch.index);
+  const themesMatch = /themes:\s*\[/.exec(afterGroup);
+  if (!themesMatch) {
+    return { updated: content, changed: false, error: `Could not find themes array for group "${group}".` };
+  }
+  const themesStart = groupMatch.index + themesMatch.index + themesMatch[0].length;
+  const closingBracket = content.indexOf("]", themesStart);
+  const themesContent = content.slice(themesStart, closingBracket);
+  const entryPattern = /\{\s*value:\s*"([\w-]+)"[^}]*\}/g;
+  const entries = [];
+  let m;
+  while ((m = entryPattern.exec(themesContent)) !== null) {
+    entries.push({
+      value: m[1],
+      start: themesStart + m.index,
+      end: themesStart + m.index + m[0].length
+    });
+  }
+  let insertPos = closingBracket;
+  for (const e of entries) {
+    if (slug < e.value) {
+      insertPos = e.start;
+      break;
+    }
+  }
+  const prevNewline = content.lastIndexOf("\n", insertPos);
+  const lineContent = content.slice(prevNewline + 1, insertPos);
+  const indentMatch = /^(\s*)/.exec(lineContent);
+  const indent = indentMatch ? indentMatch[1] : "      ";
+  const newEntry = `{ value: "${slug}", label: "${label}" }`;
+  const insertion = entries.length === 0 ? `
+${indent}${newEntry},
+    ` : `${indent}${newEntry},
+`;
+  const updated = content.slice(0, insertPos) + insertion + content.slice(insertPos);
+  return { updated, changed: true };
+}
+function themeRegisterCommand(file, cwd, options) {
+  const filePath = resolve6(cwd, file);
+  let yamlContent;
+  try {
+    yamlContent = readFileSync9(filePath, "utf-8");
+  } catch {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: `Could not read file: ${filePath}` }));
+    } else {
+      logger.error(`Could not read file: ${filePath}`);
+    }
+    process.exit(2);
+    return;
+  }
+  let data;
+  try {
+    data = generateThemeData3(yamlContent);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error parsing theme";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: message }));
+    } else {
+      logger.error("Failed to parse theme.");
+      logger.info(message);
+    }
+    process.exit(1);
+    return;
+  }
+  const slug = toSlug(data.config.name);
+  const label = toLabel(data.config.name);
+  const adapterInput = {
+    primitives: data.primitives,
+    tokens: data.tokens,
+    config: data.config
+  };
+  const css = docsAdapter2(adapterInput);
+  const repoRoot = findRepoRoot(cwd);
+  if (!repoRoot) {
+    const msg = "Could not locate repo root (packages/docs/ not found). Run from within the visor repo.";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  const docsAppDir = join8(repoRoot, "packages", "docs", "app");
+  const cssFilePath = join8(docsAppDir, `${slug}-theme.css`);
+  const globalsPath = join8(docsAppDir, "globals.css");
+  const themeConfigPath = join8(repoRoot, "packages", "docs", "lib", "theme-config.ts");
+  if (!existsSync7(docsAppDir)) {
+    const msg = `Docs app directory not found: ${docsAppDir}`;
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  let globalsContent = "";
+  let themeConfigContent = "";
+  try {
+    globalsContent = readFileSync9(globalsPath, "utf-8");
+    themeConfigContent = readFileSync9(themeConfigPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Could not read docs files";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  const cssExists = existsSync7(cssFilePath);
+  const cssChanged = !cssExists || readFileSync9(cssFilePath, "utf-8") !== css;
+  const { updated: newGlobals, changed: globalsChanged } = insertGlobalsImport(globalsContent, slug);
+  const { updated: newThemeConfig, changed: themeConfigChanged, error: configError } = insertThemeConfig(
+    themeConfigContent,
+    slug,
+    label,
+    options.group
+  );
+  if (configError) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: configError }));
+    } else {
+      logger.error(configError);
+    }
+    process.exit(1);
+    return;
+  }
+  if (options.dryRun) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        dryRun: true,
+        slug,
+        label,
+        group: options.group,
+        changes: {
+          cssFile: { path: cssFilePath, changed: cssChanged },
+          globalsCSS: { path: globalsPath, changed: globalsChanged },
+          themeConfig: { path: themeConfigPath, changed: themeConfigChanged }
+        }
+      }));
+    } else {
+      logger.info("Dry run \u2014 no files written");
+      logger.item(`Theme: ${label} (${slug})`);
+      logger.item(`Group: ${options.group}`);
+      logger.item(`CSS file: ${cssFilePath} \u2014 ${cssChanged ? cssExists ? "update" : "create" : "no change"}`);
+      logger.item(`globals.css: ${globalsChanged ? "add import" : "already registered"}`);
+      logger.item(`theme-config.ts: ${themeConfigChanged ? "add entry" : "already registered"}`);
+    }
+    return;
+  }
+  try {
+    if (cssChanged) {
+      mkdirSync4(docsAppDir, { recursive: true });
+      writeFileSync6(cssFilePath, css, "utf-8");
+    }
+    if (globalsChanged) {
+      writeFileSync6(globalsPath, newGlobals, "utf-8");
+    }
+    if (themeConfigChanged) {
+      writeFileSync6(themeConfigPath, newThemeConfig, "utf-8");
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Write failed";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(2);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: true,
+      slug,
+      label,
+      group: options.group,
+      files: { css: cssFilePath, globals: globalsPath, themeConfig: themeConfigPath },
+      changes: { cssFile: cssChanged, globalsCSS: globalsChanged, themeConfig: themeConfigChanged }
+    }));
+  } else {
+    logger.success(`Theme registered: ${label} (${slug})`);
+    logger.item(`Group: ${options.group}`);
+    if (cssChanged) logger.item(`CSS: ${cssFilePath}`);
+    if (globalsChanged) logger.item(`globals.css updated`);
+    if (themeConfigChanged) logger.item(`theme-config.ts updated`);
+    if (!cssChanged && !globalsChanged && !themeConfigChanged) {
+      logger.info("Already registered \u2014 no changes needed.");
+    }
+  }
+}
+
+// src/commands/theme-unregister.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync8, unlinkSync } from "fs";
+import { join as join9 } from "path";
+function removeGlobalsImport(content, slug) {
+  const importLine = `@import './${slug}-theme.css';`;
+  if (!content.includes(importLine)) {
+    return { updated: content, changed: false };
+  }
+  const updated = content.split("\n").filter((line) => line !== importLine).join("\n");
+  return { updated, changed: true };
+}
+function removeThemeConfigEntry(content, slug) {
+  if (!content.includes(`value: "${slug}"`)) {
+    return { updated: content, changed: false };
+  }
+  const entryPattern = new RegExp(
+    `\\s*\\{\\s*value:\\s*"${slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"[^}]*\\},?`,
+    "g"
+  );
+  const updated = content.replace(entryPattern, "");
+  return { updated, changed: true };
+}
+function themeUnregisterCommand(slug, cwd, options) {
+  const repoRoot = findRepoRoot(cwd);
+  if (!repoRoot) {
+    const msg = "Could not locate repo root (packages/docs/ not found). Run from within the visor repo.";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  const docsAppDir = join9(repoRoot, "packages", "docs", "app");
+  const cssFilePath = join9(docsAppDir, `${slug}-theme.css`);
+  const globalsPath = join9(docsAppDir, "globals.css");
+  const themeConfigPath = join9(repoRoot, "packages", "docs", "lib", "theme-config.ts");
+  if (!existsSync8(docsAppDir)) {
+    const msg = `Docs app directory not found: ${docsAppDir}`;
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  let globalsContent = "";
+  let themeConfigContent = "";
+  try {
+    globalsContent = readFileSync10(globalsPath, "utf-8");
+    themeConfigContent = readFileSync10(themeConfigPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Could not read docs files";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  const cssExists = existsSync8(cssFilePath);
+  const { updated: newGlobals, changed: globalsChanged } = removeGlobalsImport(globalsContent, slug);
+  const { updated: newThemeConfig, changed: themeConfigChanged } = removeThemeConfigEntry(themeConfigContent, slug);
+  if (!cssExists && !globalsChanged && !themeConfigChanged) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, slug, changes: { cssFile: false, globalsCSS: false, themeConfig: false } }));
+    } else {
+      logger.info(`Theme "${slug}" is not registered \u2014 nothing to remove.`);
+    }
+    return;
+  }
+  try {
+    if (cssExists) unlinkSync(cssFilePath);
+    if (globalsChanged) writeFileSync7(globalsPath, newGlobals, "utf-8");
+    if (themeConfigChanged) writeFileSync7(themeConfigPath, newThemeConfig, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Write failed";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(2);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: true,
+      slug,
+      changes: { cssFile: cssExists, globalsCSS: globalsChanged, themeConfig: themeConfigChanged }
+    }));
+  } else {
+    logger.success(`Theme unregistered: ${slug}`);
+    if (cssExists) logger.item(`CSS file removed: ${cssFilePath}`);
+    if (globalsChanged) logger.item(`globals.css updated`);
+    if (themeConfigChanged) logger.item(`theme-config.ts updated`);
+  }
+}
+
+// src/commands/theme-sync.ts
+import {
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync8,
+  mkdirSync as mkdirSync5,
+  existsSync as existsSync9,
+  readdirSync as readdirSync2,
+  unlinkSync as unlinkSync2,
+  copyFileSync
+} from "fs";
+import { join as join10, basename as basename2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+import { generateThemeData as generateThemeData4 } from "@loworbitstudio/visor-theme-engine";
+import { docsAdapter as docsAdapter3 } from "@loworbitstudio/visor-theme-engine/adapters";
+var GLOBALS_BEGIN_MARKER = "/* BEGIN visor-theme-imports \u2014 generated by `visor theme sync` */";
+var GLOBALS_END_MARKER = "/* END visor-theme-imports */";
+var GITIGNORE_BEGIN_MARKER = "# BEGIN visor-custom-theme-css (managed by `visor theme sync` \u2014 do not edit manually)";
+var GITIGNORE_END_MARKER = "# END visor-custom-theme-css";
+var THEME_CONFIG_HEADER = "// This file is auto-generated by `visor theme sync`. Do not edit manually.\n";
+function scanThemeDir(dir) {
+  if (!existsSync9(dir)) return [];
+  return readdirSync2(dir).filter((f) => f.endsWith(".visor.yaml")).map((f) => join10(dir, f));
+}
+function extractGroup(yamlContent) {
+  const parsed = parseYaml2(yamlContent);
+  if (typeof parsed?.group === "string") return parsed.group;
+  return void 0;
+}
+function sortGroups(groups) {
+  return [...groups].sort((a, b) => {
+    if (a === "Visor") return -1;
+    if (b === "Visor") return 1;
+    return a.localeCompare(b);
+  });
+}
+function generateThemeConfig(entries) {
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!groupMap.has(entry.group)) groupMap.set(entry.group, []);
+    groupMap.get(entry.group).push(entry);
+  }
+  const sortedGroupNames = sortGroups([...groupMap.keys()]);
+  for (const [, groupEntries] of groupMap) {
+    groupEntries.sort((a, b) => a.slug.localeCompare(b.slug));
+  }
+  const groupsTs = sortedGroupNames.map((groupName) => {
+    const groupEntries = groupMap.get(groupName);
+    const themesTs = groupEntries.map((e) => `    { value: "${e.slug}", label: "${e.label}", yamlFile: "${e.yamlFilename}" },`).join("\n");
+    return `  {
+    label: "${groupName}",
+    themes: [
+${themesTs}
+    ],
+  },`;
+  }).join("\n");
+  return `${THEME_CONFIG_HEADER}
+export interface ThemeEntry {
+  value: string;
+  label: string;
+  /** Filename (without .visor.yaml extension) if a YAML config exists in /public/themes/ */
+  yamlFile?: string;
+}
+
+export interface ThemeGroup {
+  label: string;
+  themes: ThemeEntry[];
+}
+
+export const THEME_GROUPS: ThemeGroup[] = [
+${groupsTs}
+];
+
+export const ALL_THEMES = THEME_GROUPS.flatMap((g) => g.themes.map((t) => t.value));
+`;
+}
+function updateGlobalsImports(content, slugs) {
+  const importLines = [...slugs].sort().map((slug) => `@import './${slug}-theme.css';`).join("\n");
+  const newBlock = `${GLOBALS_BEGIN_MARKER}
+${importLines}
+${GLOBALS_END_MARKER}`;
+  const beginIdx = content.indexOf(GLOBALS_BEGIN_MARKER);
+  const endIdx = content.indexOf(GLOBALS_END_MARKER);
+  if (beginIdx !== -1 && endIdx !== -1) {
+    return content.slice(0, beginIdx) + newBlock + content.slice(endIdx + GLOBALS_END_MARKER.length);
+  }
+  const themeImportPattern = /^@import '\.\/[\w-]+-theme\.css';\n?/gm;
+  const lines = content.split("\n");
+  let firstThemeIdx = -1;
+  let lastThemeIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^@import '\.\/[\w-]+-theme\.css';/.test(lines[i])) {
+      if (firstThemeIdx === -1) firstThemeIdx = i;
+      lastThemeIdx = i;
+    }
+  }
+  if (firstThemeIdx !== -1) {
+    const before = lines.slice(0, firstThemeIdx);
+    const after = lines.slice(lastThemeIdx + 1);
+    return [...before, newBlock, ...after].join("\n");
+  }
+  void themeImportPattern;
+  const lastImportIdx = lines.reduce(
+    (last, line, i) => line.startsWith("@import") ? i : last,
+    -1
+  );
+  const insertAt = lastImportIdx + 1;
+  lines.splice(insertAt, 0, newBlock);
+  return lines.join("\n");
+}
+function updateGitignoreBlock(content, customSlugs) {
+  const cssLines = customSlugs.sort().map((slug) => `packages/docs/app/${slug}-theme.css`).join("\n");
+  const newBlock = `${GITIGNORE_BEGIN_MARKER}
+${cssLines}
+${GITIGNORE_END_MARKER}`;
+  const beginIdx = content.indexOf(GITIGNORE_BEGIN_MARKER);
+  const endIdx = content.indexOf(GITIGNORE_END_MARKER);
+  if (beginIdx !== -1 && endIdx !== -1) {
+    return content.slice(0, beginIdx) + newBlock + content.slice(endIdx + GITIGNORE_END_MARKER.length);
+  }
+  return content.trimEnd() + "\n\n" + newBlock + "\n";
+}
+function themeSyncCommand(cwd, options) {
+  const repoRoot = findRepoRoot(cwd);
+  if (!repoRoot) {
+    const msg = "Could not locate repo root (packages/docs/ not found). Run from within the visor repo.";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  const themesDir = join10(repoRoot, "themes");
+  const customThemesDir = join10(repoRoot, "custom-themes");
+  const docsAppDir = join10(repoRoot, "packages", "docs", "app");
+  const docsPublicThemesDir = join10(repoRoot, "packages", "docs", "public", "themes");
+  const themeConfigPath = join10(repoRoot, "packages", "docs", "lib", "theme-config.ts");
+  const globalsPath = join10(docsAppDir, "globals.css");
+  const gitignorePath = join10(repoRoot, ".gitignore");
+  const stockFiles = scanThemeDir(themesDir);
+  const customFiles = scanThemeDir(customThemesDir);
+  if (stockFiles.length === 0 && customFiles.length === 0) {
+    const msg = `No .visor.yaml files found in themes/ or custom-themes/. Nothing to sync.`;
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.warn(msg);
+    }
+    return;
+  }
+  const manifest = [];
+  const errors = [];
+  const processFile = (filePath, isCustom) => {
+    let yamlContent;
+    try {
+      yamlContent = readFileSync11(filePath, "utf-8");
+    } catch {
+      errors.push(`Could not read: ${filePath}`);
+      return;
+    }
+    let data;
+    try {
+      data = generateThemeData4(yamlContent);
+    } catch (err) {
+      errors.push(`Failed to parse ${basename2(filePath)}: ${err instanceof Error ? err.message : "Unknown error"}`);
+      return;
+    }
+    const slug = toSlug(data.config.name);
+    const label = toLabel(data.config.name);
+    const group = extractGroup(yamlContent) ?? (isCustom ? "Custom" : "Visor");
+    const css = docsAdapter3({ primitives: data.primitives, tokens: data.tokens, config: data.config });
+    const yamlFilename = basename2(filePath).replace(/\.visor\.yaml$/, "");
+    manifest.push({ slug, label, group, css, yamlFilename, isCustom });
+  };
+  for (const f of stockFiles) processFile(f, false);
+  for (const f of customFiles) processFile(f, true);
+  if (errors.length > 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, errors }));
+    } else {
+      errors.forEach((e) => logger.error(e));
+    }
+    process.exit(1);
+    return;
+  }
+  const newThemeConfig = generateThemeConfig(manifest);
+  const allSlugs = manifest.map((e) => e.slug);
+  const customSlugs = manifest.filter((e) => e.isCustom).map((e) => e.slug);
+  let globalsContent;
+  let gitignoreContent;
+  try {
+    globalsContent = readFileSync11(globalsPath, "utf-8");
+    gitignoreContent = existsSync9(gitignorePath) ? readFileSync11(gitignorePath, "utf-8") : "";
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Could not read docs files";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+  const newGlobals = updateGlobalsImports(globalsContent, allSlugs);
+  const newGitignore = customSlugs.length > 0 ? updateGitignoreBlock(gitignoreContent, customSlugs) : gitignoreContent;
+  const existingCssFiles = existsSync9(docsAppDir) ? readdirSync2(docsAppDir).filter((f) => f.endsWith("-theme.css")) : [];
+  const newCssSet = new Set(allSlugs.map((s) => `${s}-theme.css`));
+  const staleCssFiles = existingCssFiles.filter((f) => !newCssSet.has(f));
+  const existingPublicYamls = existsSync9(docsPublicThemesDir) ? readdirSync2(docsPublicThemesDir).filter((f) => f.endsWith(".visor.yaml")) : [];
+  const newPublicYamlSet = new Set(manifest.map((e) => `${e.yamlFilename}.visor.yaml`));
+  const stalePublicYamls = existingPublicYamls.filter((f) => !newPublicYamlSet.has(f));
+  if (options.dryRun) {
+    const changes = {
+      themesDiscovered: manifest.map((e) => ({ slug: e.slug, group: e.group, isCustom: e.isCustom })),
+      cssFilesGenerated: allSlugs.map((s) => `packages/docs/app/${s}-theme.css`),
+      cssFilesDeleted: staleCssFiles.map((f) => `packages/docs/app/${f}`),
+      themeConfig: themeConfigPath,
+      globalsCSS: globalsPath,
+      gitignore: gitignorePath,
+      publicYamlsCopied: manifest.map((e) => `packages/docs/public/themes/${e.yamlFilename}.visor.yaml`),
+      publicYamlsDeleted: stalePublicYamls.map((f) => `packages/docs/public/themes/${f}`)
+    };
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, dryRun: true, changes }));
+    } else {
+      logger.info("Dry run \u2014 no files written");
+      logger.item(`Themes discovered: ${manifest.length} (${manifest.filter((e) => !e.isCustom).length} stock, ${manifest.filter((e) => e.isCustom).length} custom)`);
+      manifest.forEach((e) => logger.item(`  ${e.slug} \u2014 group: ${e.group}`));
+      if (staleCssFiles.length > 0) logger.item(`CSS files to delete: ${staleCssFiles.join(", ")}`);
+      if (stalePublicYamls.length > 0) logger.item(`Public YAMLs to delete: ${stalePublicYamls.join(", ")}`);
+    }
+    return;
+  }
+  try {
+    mkdirSync5(docsAppDir, { recursive: true });
+    mkdirSync5(docsPublicThemesDir, { recursive: true });
+    for (const entry of manifest) {
+      writeFileSync8(join10(docsAppDir, `${entry.slug}-theme.css`), entry.css, "utf-8");
+    }
+    for (const stale of staleCssFiles) {
+      unlinkSync2(join10(docsAppDir, stale));
+    }
+    writeFileSync8(themeConfigPath, newThemeConfig, "utf-8");
+    writeFileSync8(globalsPath, newGlobals, "utf-8");
+    if (existsSync9(gitignorePath)) {
+      writeFileSync8(gitignorePath, newGitignore, "utf-8");
+    }
+    const allSourceFiles = [...stockFiles, ...customFiles];
+    for (const srcFile of allSourceFiles) {
+      const filename = basename2(srcFile);
+      copyFileSync(srcFile, join10(docsPublicThemesDir, filename));
+    }
+    for (const stale of stalePublicYamls) {
+      unlinkSync2(join10(docsPublicThemesDir, stale));
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Write failed";
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: msg }));
+    } else {
+      logger.error(msg);
+    }
+    process.exit(2);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: true,
+      themes: manifest.length,
+      stock: manifest.filter((e) => !e.isCustom).length,
+      custom: manifest.filter((e) => e.isCustom).length,
+      staleCssDeleted: staleCssFiles.length,
+      staleYamlsDeleted: stalePublicYamls.length,
+      slugs: allSlugs
+    }));
+  } else {
+    logger.success(`Theme sync complete \u2014 ${manifest.length} themes registered`);
+    logger.item(`Stock: ${manifest.filter((e) => !e.isCustom).map((e) => e.slug).join(", ")}`);
+    if (manifest.filter((e) => e.isCustom).length > 0) {
+      logger.item(`Custom: ${manifest.filter((e) => e.isCustom).map((e) => e.slug).join(", ")}`);
+    }
+    if (staleCssFiles.length > 0) {
+      logger.item(`Removed stale CSS: ${staleCssFiles.join(", ")}`);
+    }
+  }
+}
+
+// src/commands/fonts-add.ts
+import { existsSync as existsSync10, statSync as statSync2, readdirSync as readdirSync3, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve7, basename as basename3, extname as extname2 } from "path";
+import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
+function deriveFamilySlug(filename) {
+  const name = basename3(filename, extname2(filename));
+  const WEIGHT_STYLE_SUFFIXES = /* @__PURE__ */ new Set([
+    "thin",
+    "hairline",
+    "extralight",
+    "ultralight",
+    "light",
+    "regular",
+    "normal",
+    "medium",
+    "semibold",
+    "demibold",
+    "bold",
+    "extrabold",
+    "ultrabold",
+    "black",
+    "heavy",
+    "italic",
+    "oblique",
+    "bolditalic",
+    "semibolditalic",
+    "lightitalic",
+    "mediumitalic",
+    "thinitalic",
+    "extrabolditanic",
+    "extrabolditalic",
+    "blackitalic",
+    "heavyitalic",
+    "extralightitalic",
+    "ultralightitalic",
+    "ultrabolditalic",
+    "demibolditalic",
+    "regularitalic"
+  ]);
+  const parts = name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").split("-");
+  while (parts.length > 1 && WEIGHT_STYLE_SUFFIXES.has(parts[parts.length - 1].toLowerCase())) {
+    parts.pop();
+  }
+  return parts.join("-").toLowerCase();
+}
+function collectWoff2Files(inputPath) {
+  const resolved = resolve7(inputPath);
+  if (!existsSync10(resolved)) {
+    throw new Error(`Path not found: ${resolved}`);
+  }
+  const stat = statSync2(resolved);
+  if (stat.isFile()) {
+    if (extname2(resolved).toLowerCase() !== ".woff2") {
+      throw new Error(
+        `Invalid file format: ${basename3(resolved)}. Only .woff2 files are accepted.`
+      );
+    }
+    return [resolved];
+  }
+  if (stat.isDirectory()) {
+    const files = readdirSync3(resolved).filter((f) => extname2(f).toLowerCase() === ".woff2").map((f) => resolve7(resolved, f));
+    if (files.length === 0) {
+      throw new Error(
+        `No .woff2 files found in directory: ${resolved}`
+      );
+    }
+    const nonWoff2Fonts = readdirSync3(resolved).filter((f) => {
+      const ext = extname2(f).toLowerCase();
+      return [".ttf", ".otf", ".woff", ".eot"].includes(ext);
+    });
+    return files.sort();
+  }
+  throw new Error(`Path is neither a file nor a directory: ${resolved}`);
+}
+function getNonWoff2Fonts(inputPath) {
+  const resolved = resolve7(inputPath);
+  if (!existsSync10(resolved) || !statSync2(resolved).isDirectory()) {
+    return [];
+  }
+  return readdirSync3(resolved).filter((f) => {
+    const ext = extname2(f).toLowerCase();
+    return [".ttf", ".otf", ".woff", ".eot"].includes(ext);
+  });
+}
+function buildS3Key(org, familySlug, filename) {
+  return `${org}/${familySlug}/${filename}`;
+}
+function getR2Config() {
+  const accessKeyId = process.env.VISOR_R2_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.VISOR_R2_SECRET_ACCESS_KEY;
+  const endpoint = process.env.VISOR_R2_ENDPOINT;
+  if (!accessKeyId || !secretAccessKey || !endpoint) {
+    const missing = [];
+    if (!accessKeyId) missing.push("VISOR_R2_ACCESS_KEY_ID");
+    if (!secretAccessKey) missing.push("VISOR_R2_SECRET_ACCESS_KEY");
+    if (!endpoint) missing.push("VISOR_R2_ENDPOINT");
+    throw new Error(
+      `Missing required environment variables: ${missing.join(", ")}`
+    );
+  }
+  return { accessKeyId, secretAccessKey, endpoint };
+}
+function createR2Client(config) {
+  return new S3Client({
+    region: "auto",
+    endpoint: config.endpoint,
+    credentials: {
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey
+    }
+  });
+}
+async function uploadFile(client, bucket, key, filePath) {
+  const body = readFileSync12(filePath);
+  await client.send(
+    new PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: body,
+      ContentType: "font/woff2"
+    })
+  );
+}
+async function fontsAddCommand(inputPath, options) {
+  const { org, json } = options;
+  try {
+    const r2Config = getR2Config();
+    const files = collectWoff2Files(inputPath);
+    const familySlug = options.family ?? deriveFamilySlug(basename3(files[0]));
+    const resolved = resolve7(inputPath);
+    const nonWoff2 = statSync2(resolved).isDirectory() ? getNonWoff2Fonts(resolved) : [];
+    if (!json) {
+      logger.heading("Visor Font Upload");
+      logger.info(`Organization: ${org}`);
+      logger.info(`Font family: ${familySlug}`);
+      logger.info(`Files to upload: ${files.length}`);
+      logger.blank();
+      if (nonWoff2.length > 0) {
+        logger.warn(
+          `Skipping ${nonWoff2.length} non-woff2 file(s): ${nonWoff2.join(", ")}`
+        );
+        logger.blank();
+      }
+    }
+    const client = createR2Client(r2Config);
+    const bucket = "visor-fonts";
+    const results = [];
+    for (const filePath of files) {
+      const filename = basename3(filePath);
+      const key = buildS3Key(org, familySlug, filename);
+      if (!json) {
+        logger.info(`Uploading ${filename}...`);
+      }
+      await uploadFile(client, bucket, key, filePath);
+      const size = statSync2(filePath).size;
+      results.push({ file: filename, key, size });
+      if (!json) {
+        logger.success(`Uploaded: ${key} (${formatBytes(size)})`);
+      }
+    }
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: true,
+            org,
+            family: familySlug,
+            uploaded: results,
+            totalFiles: results.length,
+            totalBytes: results.reduce((sum, r) => sum + r.size, 0)
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      logger.blank();
+      logger.success(
+        `${results.length} file(s) uploaded to ${org}/${familySlug}/`
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (json) {
+      console.log(
+        JSON.stringify({ success: false, error: message })
+      );
+    } else {
+      logger.error(message);
+    }
+    process.exit(2);
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)} KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(1)} MB`;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("visor").description("CLI for the Visor design system").version("0.1.0");
+program.command("init").description("Initialize Visor in the current project").option("--template <name>", "scaffold a themed project (nextjs)").option("--json", "output structured JSON (for AI agents)").action((options) => {
+  initCommand(process.cwd(), options);
+});
+program.command("list").description("List all available registry items").option("--json", "output structured JSON (for AI agents)").option("--category <name>", "filter items by category").action((options) => {
+  listCommand(process.cwd(), options);
+});
+program.command("add").description("Add components, hooks, blocks, or utilities to your project").argument("[items...]", "names of registry items to add").option("--overwrite", "overwrite existing files", false).option("--category <name>", "install all items from a category").option("--block", "install blocks instead of components").option("--json", "output structured JSON (for AI agents)").action((items, options) => {
+  addCommand(items, process.cwd(), { overwrite: options.overwrite, category: options.category, block: options.block, json: options.json });
+});
+program.command("diff").description(
+  "Show differences between local files and the registry"
+).argument("[component]", "component name to diff (all if omitted)").option("--json", "output structured JSON (for AI agents)").action((component, options) => {
+  diffCommand(component, process.cwd(), options);
+});
+var theme = program.command("theme").description("Theme management commands");
+theme.command("apply").description(
+  "Read a .visor.yaml file and generate full CSS token overrides"
+).argument("<file>", "path to .visor.yaml file").option("-o, --output <path>", "output CSS file path").option("--json", "output structured JSON (for AI agents)").option("--adapter <name>", "target adapter: nextjs, fumadocs, deck").action(
+  (file, options) => {
+    themeApplyCommand(file, process.cwd(), {
+      ...options,
+      adapter: options.adapter
+    });
+  }
+);
+theme.command("export").description(
+  "Read current theme tokens and produce a .visor.yaml (or other format)"
+).argument("[file]", "path to source .visor.yaml file").option(
+  "--format <format>",
+  "output format: yaml or json",
+  "yaml"
+).option("--json", "output structured JSON (for AI agents)").action(
+  (file, options) => {
+    themeExportCommand(file, process.cwd(), options);
+  }
+);
+theme.command("validate").description("Run full validation ruleset on a .visor.yaml file").argument("<file>", "path to .visor.yaml file").option("--json", "output structured JSON (for AI agents)").action(
+  (file, options) => {
+    themeValidateCommand(file, process.cwd(), options);
+  }
+);
+theme.command("extract").description(
+  "Scan an existing project's CSS and produce a best-effort .visor.yaml theme file"
+).option("--from <path>", "path to project directory to scan").option("--json", "output structured JSON (for AI agents)").option("-o, --output <path>", "output file path (default: .visor.yaml)").option("--validate", "run validator on the extracted theme").action(
+  (options) => {
+    themeExtractCommand(process.cwd(), {
+      ...options,
+      runValidation: options.validate
+    });
+  }
+);
+theme.command("register").description(
+  "Register a theme in the docs site \u2014 creates CSS, updates globals.css and theme-config.ts"
+).argument("<file>", "path to .visor.yaml file").requiredOption("--group <name>", "theme group to register in (e.g. Visor, Client, Low Orbit)").option("--dry-run", "show what would change without writing files").option("--json", "output structured JSON (for AI agents)").action(
+  (file, options) => {
+    themeRegisterCommand(file, process.cwd(), options);
+  }
+);
+theme.command("unregister").description(
+  "Remove a theme from the docs site \u2014 deletes CSS file, removes globals.css import and theme-config.ts entry"
+).argument("<slug>", "theme slug to unregister (e.g. entr, kaiah)").option("--json", "output structured JSON (for AI agents)").action(
+  (slug, options) => {
+    themeUnregisterCommand(slug, process.cwd(), options);
+  }
+);
+theme.command("sync").description(
+  "Scan themes/ and custom-themes/ directories, regenerate all theme CSS, globals.css imports, and theme-config.ts"
+).option("--dry-run", "show what would change without writing files").option("--json", "output structured JSON (for AI agents)").action(
+  (options) => {
+    themeSyncCommand(process.cwd(), options);
+  }
+);
+var fonts = program.command("fonts").description("Font library management commands");
+fonts.command("add").description("Upload woff2 font files to the Visor Font Library on R2").argument("<path>", "path to a .woff2 file or directory containing .woff2 files").requiredOption("--org <org>", "organization namespace (e.g. low-orbit)").option("--family <name>", "font family slug (auto-inferred from filename if omitted)").option("--json", "output structured JSON (for AI agents)").action(
+  (path, options) => {
+    fontsAddCommand(path, options);
+  }
+);
+program.parse();