@nikkory/vibe-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,2371 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander7 = require("commander");
+
+// src/commands/add.ts
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var import_commander = require("commander");
+var import_inquirer = __toESM(require("inquirer"));
+
+// src/utils/logger.ts
+var import_boxen = __toESM(require("boxen"));
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var Logger = class {
+  spinner = null;
+  /**
+   * Success message (green checkmark)
+   */
+  success(message) {
+    console.log(import_chalk.default.green("\u2713"), message);
+  }
+  /**
+   * Error message (red cross)
+   */
+  error(message) {
+    console.log(import_chalk.default.red("\u2717"), message);
+  }
+  /**
+   * Warning message (yellow exclamation)
+   */
+  warn(message) {
+    console.log(import_chalk.default.yellow("\u26A0"), message);
+  }
+  /**
+   * Info message (blue dot)
+   */
+  info(message) {
+    console.log(import_chalk.default.blue("\u2139"), message);
+  }
+  /**
+   * Debug message (gray)
+   */
+  debug(message) {
+    if (process.env["DEBUG"]) {
+      console.log(import_chalk.default.gray("\u2022"), import_chalk.default.gray(message));
+    }
+  }
+  /**
+   * Start loading spinner
+   */
+  startSpinner(message) {
+    this.spinner = (0, import_ora.default)(message).start();
+  }
+  /**
+   * Update spinner message
+   */
+  updateSpinner(message) {
+    if (this.spinner) {
+      this.spinner.text = message;
+    }
+  }
+  /**
+   * Stop spinner with success
+   */
+  stopSpinnerSuccess(message) {
+    if (this.spinner) {
+      this.spinner.succeed(message);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with failure
+   */
+  stopSpinnerFail(message) {
+    if (this.spinner) {
+      this.spinner.fail(message);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner
+   */
+  stopSpinner() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+  /**
+   * Print box message
+   */
+  box(message, options) {
+    console.log(
+      (0, import_boxen.default)(message, {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: options?.borderColor || "cyan",
+        title: options?.title,
+        titleAlignment: "center"
+      })
+    );
+  }
+  /**
+   * Print separator line
+   */
+  separator() {
+    console.log(import_chalk.default.gray("\u2500".repeat(50)));
+  }
+  /**
+   * Print newline
+   */
+  newline() {
+    console.log();
+  }
+  /**
+   * Print header
+   */
+  header(title) {
+    console.log();
+    console.log(import_chalk.default.bold.cyan(title));
+    this.separator();
+  }
+  /**
+   * Print code block
+   */
+  code(code) {
+    console.log(import_chalk.default.gray(code));
+  }
+  /**
+   * Print table
+   */
+  table(data) {
+    if (data.length === 0) return;
+    const firstRow = data[0];
+    if (!firstRow) return;
+    const headers = Object.keys(firstRow);
+    const columnWidths = headers.map((header) => {
+      const maxDataWidth = Math.max(...data.map((row) => String(row[header] ?? "").length));
+      return Math.max(header.length, maxDataWidth);
+    });
+    const headerRow = headers.map((header, i) => import_chalk.default.bold(header.padEnd(columnWidths[i] ?? 10))).join(" \u2502 ");
+    console.log(headerRow);
+    const separator = columnWidths.map((width) => "\u2500".repeat(width)).join("\u2500\u253C\u2500");
+    console.log(import_chalk.default.gray(separator));
+    data.forEach((row) => {
+      const dataRow = headers.map((header, i) => String(row[header] ?? "").padEnd(columnWidths[i] ?? 10)).join(" \u2502 ");
+      console.log(dataRow);
+    });
+  }
+};
+var logger = new Logger();
+
+// src/commands/add.ts
+var AVAILABLE_COMPONENTS = [
+  "button",
+  "input",
+  "card",
+  "badge",
+  "toast",
+  "modal",
+  "dropdown",
+  "tabs",
+  "accordion",
+  "avatar"
+];
+var COLORS = [
+  "primary",
+  "secondary",
+  "success",
+  "warning",
+  "error",
+  "info",
+  "blue",
+  "red",
+  "green",
+  "yellow",
+  "purple",
+  "gray",
+  "orange",
+  "amber",
+  "lime",
+  "emerald",
+  "teal",
+  "cyan",
+  "sky",
+  "indigo",
+  "violet",
+  "fuchsia",
+  "pink",
+  "rose",
+  "slate",
+  "zinc",
+  "neutral",
+  "stone"
+];
+var SIZES = ["xs", "sm", "md", "lg", "xl", "2xl"];
+var VARIANTS = {
+  button: ["solid", "outline", "ghost", "soft", "link"],
+  input: ["outlined", "filled", "underlined", "ghost"],
+  card: ["elevated", "outlined", "filled", "ghost"],
+  badge: ["solid", "soft", "outline", "dot"],
+  toast: ["solid", "soft", "outlined", "minimal"]
+};
+var SHAPES = ["square", "rounded", "pill", "circle"];
+var POSITIONS = [
+  "top-left",
+  "top-center",
+  "top-right",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right",
+  "left",
+  "center",
+  "right"
+];
+var ANIMATIONS = ["none", "subtle", "standard", "smooth", "bounce", "pulse"];
+var ELEVATIONS = ["none", "xs", "sm", "md", "lg", "xl", "2xl", "glow"];
+var A11Y_LEVELS = ["standard", "enhanced", "maximum"];
+var PRESETS = {
+  primary: { color: "blue", variant: "solid", size: "md" },
+  secondary: { color: "gray", variant: "outline", size: "md" },
+  danger: { color: "red", variant: "solid", size: "md" },
+  success: { color: "green", variant: "solid", size: "md" },
+  warning: { color: "yellow", variant: "solid", size: "md" },
+  ghost: { color: "gray", variant: "ghost", size: "md" },
+  pill: { color: "blue", variant: "solid", shape: "pill", size: "md" },
+  large: { color: "blue", variant: "solid", size: "lg" },
+  small: { color: "blue", variant: "solid", size: "sm" }
+};
+var addCommand = new import_commander.Command("add").description("Add a component with variant configuration").argument("[component]", "Component to add (button, input, card, etc.)").option("-c, --color <color>", "Color theme", "blue").option("-s, --size <size>", "Component size", "md").option("-v, --variant <variant>", "Visual style").option("--shape <shape>", "Border radius style", "rounded").option("-p, --position <position>", "Position (for toast, modal)").option("-a, --animation <animation>", "Animation style", "standard").option("-e, --elevation <elevation>", "Shadow depth", "md").option("--a11y <level>", "Accessibility level", "standard").option("--preset <preset>", "Use a preset configuration").option("-i, --interactive", "Interactive mode").option("-o, --output <path>", "Output directory", "./components").option("--dry-run", "Preview without writing files").action(async (component, options) => {
+  try {
+    logger.header("\u{1F3A8} Nikkory Vibe - Add Component");
+    if (options.interactive || !component) {
+      const config = await promptVariantConfig();
+      component = config.component;
+      Object.assign(options, config);
+    }
+    if (!component || !AVAILABLE_COMPONENTS.includes(component)) {
+      logger.error(`Unknown component: ${component ?? "none"}`);
+      logger.info(`Available: ${AVAILABLE_COMPONENTS.join(", ")}`);
+      process.exit(1);
+    }
+    const validatedComponent = component;
+    if (options.preset) {
+      const preset = PRESETS[options.preset];
+      if (!preset) {
+        logger.error(`Unknown preset: ${options.preset}`);
+        logger.info(`Available: ${Object.keys(PRESETS).join(", ")}`);
+        process.exit(1);
+      }
+      Object.assign(options, preset);
+    }
+    if (options.color && !COLORS.includes(options.color)) {
+      logger.warn(`Unknown color: ${options.color}. Using default.`);
+    }
+    if (options.size && !SIZES.includes(options.size)) {
+      logger.warn(`Unknown size: ${options.size}. Using default.`);
+    }
+    if (options.position && !POSITIONS.includes(options.position)) {
+      logger.warn(`Unknown position: ${options.position}. Using default.`);
+    }
+    if (options.a11y && !A11Y_LEVELS.includes(options.a11y)) {
+      logger.warn(`Unknown accessibility level: ${options.a11y}. Using default.`);
+    }
+    logger.newline();
+    logger.info(`Component: ${validatedComponent}`);
+    logger.info(`Color: ${options.color ?? "default"}`);
+    logger.info(`Size: ${options.size ?? "default"}`);
+    logger.info(`Variant: ${options.variant ?? "default"}`);
+    logger.info(`Shape: ${options.shape ?? "default"}`);
+    if (options.position) {
+      logger.info(`Position: ${options.position}`);
+    }
+    logger.info(`Animation: ${options.animation ?? "default"}`);
+    logger.info(`Elevation: ${options.elevation ?? "default"}`);
+    logger.info(`Accessibility: ${options.a11y ?? "default"}`);
+    logger.newline();
+    logger.startSpinner("Generating component...");
+    const variantConfig = {
+      color: options.color,
+      size: options.size,
+      variant: options.variant,
+      shape: options.shape,
+      position: options.position,
+      animation: options.animation,
+      elevation: options.elevation,
+      a11y: options.a11y
+    };
+    const code = generateComponentCode(validatedComponent, variantConfig);
+    logger.stopSpinnerSuccess("Component generated");
+    if (options.dryRun) {
+      logger.newline();
+      logger.header("Generated Code (Preview)");
+      logger.code(code);
+      logger.newline();
+      logger.info("Dry run mode - No files written");
+      return;
+    }
+    const componentName = capitalize(validatedComponent);
+    const outputPath = path.join(process.cwd(), options.output, `${componentName}.tsx`);
+    logger.startSpinner(`Writing to ${outputPath}...`);
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, code, "utf-8");
+    logger.stopSpinnerSuccess(`Created: ${outputPath}`);
+    logger.newline();
+    logger.box(
+      `\u2728 ${componentName} component added!
+
+File: ${outputPath}
+Color: ${options.color ?? "default"}
+Size: ${options.size ?? "default"}`,
+      { title: "Success", borderColor: "green" }
+    );
+    logger.newline();
+    logger.info("Usage:");
+    logger.code(`  import { ${componentName} } from './components/${componentName}';`);
+    logger.code(
+      `  <${componentName} color="${options.color ?? "primary"}" size="${options.size ?? "md"}" />`
+    );
+    logger.newline();
+  } catch (error) {
+    logger.stopSpinner();
+    logger.error("Failed to add component");
+    if (error instanceof Error) {
+      logger.debug(error.stack || error.message);
+    }
+    process.exit(1);
+  }
+});
+async function promptVariantConfig() {
+  const answers = await import_inquirer.default.prompt([
+    {
+      type: "list",
+      name: "component",
+      message: "Select component:",
+      choices: AVAILABLE_COMPONENTS.map((c) => ({ name: capitalize(c), value: c }))
+    },
+    {
+      type: "list",
+      name: "color",
+      message: "Color:",
+      choices: [
+        new import_inquirer.default.Separator("--- Semantic ---"),
+        { name: "Primary (Blue)", value: "primary" },
+        { name: "Secondary (Purple)", value: "secondary" },
+        { name: "Success (Green)", value: "success" },
+        { name: "Warning (Yellow)", value: "warning" },
+        { name: "Error (Red)", value: "error" },
+        { name: "Info (Cyan)", value: "info" },
+        new import_inquirer.default.Separator("--- Palette ---"),
+        { name: "Blue", value: "blue" },
+        { name: "Red", value: "red" },
+        { name: "Green", value: "green" },
+        { name: "Yellow", value: "yellow" },
+        { name: "Purple", value: "purple" },
+        { name: "Gray", value: "gray" },
+        { name: "Orange", value: "orange" },
+        { name: "Pink", value: "pink" }
+      ],
+      default: "blue"
+    },
+    {
+      type: "list",
+      name: "size",
+      message: "Size:",
+      choices: [
+        { name: "Extra Small (xs)", value: "xs" },
+        { name: "Small (sm)", value: "sm" },
+        { name: "Medium (md)", value: "md" },
+        { name: "Large (lg)", value: "lg" },
+        { name: "Extra Large (xl)", value: "xl" },
+        { name: "2X Large (2xl)", value: "2xl" }
+      ],
+      default: "md"
+    },
+    {
+      type: "list",
+      name: "variant",
+      message: "Variant:",
+      choices: (answers2) => {
+        const comp = answers2.component;
+        return (VARIANTS[comp] || ["solid", "outline", "ghost"]).map((v) => ({
+          name: capitalize(v),
+          value: v
+        }));
+      }
+    },
+    {
+      type: "list",
+      name: "shape",
+      message: "Shape:",
+      choices: SHAPES.map((s) => ({ name: capitalize(s), value: s })),
+      default: "rounded"
+    },
+    {
+      type: "list",
+      name: "animation",
+      message: "Animation:",
+      choices: ANIMATIONS.map((a) => ({ name: capitalize(a), value: a })),
+      default: "standard"
+    },
+    {
+      type: "list",
+      name: "elevation",
+      message: "Elevation/Shadow:",
+      choices: ELEVATIONS.map((e) => ({ name: e === "none" ? "None" : e.toUpperCase(), value: e })),
+      default: "md"
+    }
+  ]);
+  return answers;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function generateComponentCode(component, config) {
+  const name = capitalize(component);
+  const propsInterface = `${name}Props`;
+  return `/**
+ * ${name} Component
+ *
+ * Generated with Nikkory Vibe CLI
+ * Configuration: color=${config.color}, size=${config.size}, variant=${config.variant || "default"}
+ */
+
+'use client';
+
+import React, { forwardRef } from 'react';
+import { ${name} as Vibe${name} } from '@nikkory/vibe-library/core';
+
+export interface ${propsInterface} {
+  children?: React.ReactNode;
+  className?: string;
+  // Override default config
+  color?: string;
+  size?: string;
+  variant?: string;
+  shape?: string;
+  animation?: string;
+  elevation?: string;
+}
+
+/**
+ * Pre-configured ${name} with:
+ * - Color: ${config.color}
+ * - Size: ${config.size}
+ * - Variant: ${config.variant || "default"}
+ * - Shape: ${config.shape}
+ * - Animation: ${config.animation}
+ * - Elevation: ${config.elevation}
+ */
+export const ${name} = forwardRef<HTMLElement, ${propsInterface}>(
+  (
+    {
+      children,
+      className = '',
+      color = '${config.color}',
+      size = '${config.size}',
+      variant = '${config.variant || "solid"}',
+      shape = '${config.shape}',
+      animation = '${config.animation}',
+      elevation = '${config.elevation}',
+      ...props
+    },
+    ref
+  ) => {
+    return (
+      <Vibe${name}
+        ref={ref}
+        color={color}
+        size={size}
+        variant={variant}
+        shape={shape}
+        animation={animation}
+        elevation={elevation}
+        className={className}
+        {...props}
+      >
+        {children}
+      </Vibe${name}>
+    );
+  }
+);
+
+${name}.displayName = '${name}';
+
+export default ${name};
+`;
+}
+
+// src/commands/copy.ts
+var fsSync = __toESM(require("fs"));
+var fs2 = __toESM(require("fs/promises"));
+var path2 = __toESM(require("path"));
+var import_commander2 = require("commander");
+var DESIGN_SYSTEMS = [
+  "material-design",
+  "ios-hig",
+  "glassmorphism",
+  "neumorphism",
+  "minimalism",
+  "brutalism"
+];
+var TIERS = ["basic", "standard", "enterprise"];
+var COMPONENTS = [
+  // Core
+  "button",
+  "input",
+  "textarea",
+  "select",
+  "checkbox",
+  "radio",
+  "switch",
+  "slider",
+  // Display
+  "badge",
+  "avatar",
+  "card",
+  "tooltip",
+  "popover",
+  // Feedback
+  "alert",
+  "toast",
+  "progress",
+  "spinner",
+  "skeleton",
+  // Navigation
+  "tabs",
+  "breadcrumb",
+  "pagination",
+  "stepper",
+  "menu",
+  // Overlay
+  "modal",
+  "drawer",
+  "dropdown",
+  "dialog",
+  // Data
+  "table",
+  "list",
+  "tree",
+  "timeline",
+  // Media
+  "image",
+  "video",
+  "audio",
+  "carousel",
+  "gallery",
+  // Form
+  "form",
+  "field",
+  "label",
+  "error-message",
+  // Layout
+  "container",
+  "grid",
+  "flex",
+  "divider",
+  "spacer",
+  // Typography
+  "heading",
+  "text",
+  "link",
+  "code",
+  // Charts
+  "chart",
+  "sparkline",
+  "gauge",
+  // Special
+  "rating",
+  "transfer",
+  "color-picker",
+  "date-picker",
+  "file-upload"
+];
+var DESIGN_ALIASES = {
+  material: "material-design",
+  md: "material-design",
+  ios: "ios-hig",
+  hig: "ios-hig",
+  glass: "glassmorphism",
+  neu: "neumorphism",
+  neomorphism: "neumorphism",
+  minimal: "minimalism",
+  min: "minimalism",
+  brutal: "brutalism"
+};
+var copyCommand = new import_commander2.Command("copy").alias("cp").description("Copy pre-built components from the library (zero-token)").argument(
+  "[component]",
+  "Component to copy (button, card, etc. or path like button/glassmorphism/enterprise)"
+).option("-d, --design <design>", "Design system", "material-design").option("-t, --tier <tier>", "Quality tier", "standard").option("-o, --output <path>", "Output directory", "./components").option("--overwrite", "Overwrite existing files").option("--dry-run", "Preview without copying").option("--all", "Copy all components for the design/tier").action(async (component, options) => {
+  try {
+    logger.header("\u{1F4CB} Nikkory Vibe - Zero-Token Copy");
+    if (options.all) {
+      await copyAllComponents(options);
+      return;
+    }
+    if (!component) {
+      logger.error("Please specify a component to copy");
+      logger.newline();
+      logger.info("Usage:");
+      logger.code("  vibe copy button");
+      logger.code("  vibe copy button/glassmorphism");
+      logger.code("  vibe copy button/glassmorphism/enterprise");
+      logger.code("  vibe copy --all --design=brutalism");
+      logger.newline();
+      logger.info("Available components:");
+      logger.code(`  ${COMPONENTS.slice(0, 10).join(", ")}...`);
+      logger.info(`  Run 'vibe list templates' for full list`);
+      process.exit(1);
+    }
+    const parsed = parseComponentPath(component, options);
+    if (!validateComponentPath(parsed)) {
+      process.exit(1);
+    }
+    logger.newline();
+    logger.info(`Component: ${capitalize2(parsed.component)}`);
+    logger.info(`Design System: ${formatDesignSystem(parsed.designSystem)}`);
+    logger.info(`Tier: ${capitalize2(parsed.tier)}`);
+    logger.newline();
+    await copyComponent(parsed, options);
+  } catch (error) {
+    logger.stopSpinner();
+    logger.error("Copy failed");
+    if (error instanceof Error) {
+      logger.debug(error.stack || error.message);
+    }
+    process.exit(1);
+  }
+});
+function parseComponentPath(input, options) {
+  const parts = input.split("/").filter(Boolean);
+  const component = parts[0] ?? "";
+  let designSystem = options.design ?? "material-design";
+  let tier = options.tier ?? "standard";
+  if (parts.length === 2 && parts[1]) {
+    designSystem = normalizeDesignSystem(parts[1]);
+  } else if (parts.length >= 3 && parts[1] && parts[2]) {
+    designSystem = normalizeDesignSystem(parts[1]);
+    tier = parts[2];
+  }
+  designSystem = normalizeDesignSystem(designSystem);
+  return { component, designSystem, tier };
+}
+function normalizeDesignSystem(design) {
+  const lower = design.toLowerCase();
+  return DESIGN_ALIASES[lower] || lower;
+}
+function validateComponentPath(parsed) {
+  if (!COMPONENTS.includes(parsed.component)) {
+    logger.error(`Unknown component: ${parsed.component}`);
+    logger.info(`Available: ${COMPONENTS.slice(0, 8).join(", ")}...`);
+    return false;
+  }
+  if (!DESIGN_SYSTEMS.includes(parsed.designSystem)) {
+    logger.error(`Unknown design system: ${parsed.designSystem}`);
+    logger.info(`Available: ${DESIGN_SYSTEMS.join(", ")}`);
+    return false;
+  }
+  if (!TIERS.includes(parsed.tier)) {
+    logger.error(`Unknown tier: ${parsed.tier}`);
+    logger.info(`Available: ${TIERS.join(", ")}`);
+    return false;
+  }
+  return true;
+}
+async function copyComponent(parsed, options) {
+  const { component, designSystem, tier } = parsed;
+  const libraryRoot = findLibraryRoot();
+  const sourcePath = path2.join(
+    libraryRoot,
+    "src",
+    "components",
+    component,
+    designSystem,
+    `${tier}.tsx`
+  );
+  const sourceExists = await fileExists(sourcePath);
+  if (!sourceExists) {
+    logger.error(`Component not found: ${sourcePath}`);
+    logger.info("This component may not be available yet.");
+    logger.info("Run `vibe list templates` to see available components.");
+    process.exit(1);
+  }
+  const outputDir = path2.join(process.cwd(), options.output || "./components");
+  const fileName = `${capitalize2(component)}.tsx`;
+  const outputPath = path2.join(outputDir, fileName);
+  const outputExists = await fileExists(outputPath);
+  if (outputExists && !options.overwrite) {
+    logger.error(`File already exists: ${outputPath}`);
+    logger.info("Use --overwrite to replace it");
+    process.exit(1);
+  }
+  logger.startSpinner(`Reading ${component}...`);
+  const sourceCode = await fs2.readFile(sourcePath, "utf-8");
+  logger.stopSpinnerSuccess("Source loaded");
+  const transformedCode = transformComponent(sourceCode, parsed);
+  if (options.dryRun) {
+    logger.newline();
+    logger.header("Preview (Dry Run)");
+    logger.code(`${transformedCode.slice(0, 1e3)}
+...`);
+    logger.newline();
+    logger.info(`Would write to: ${outputPath}`);
+    logger.info(`Lines: ${transformedCode.split("\n").length}`);
+    return;
+  }
+  logger.startSpinner(`Writing to ${outputPath}...`);
+  await fs2.mkdir(outputDir, { recursive: true });
+  await fs2.writeFile(outputPath, transformedCode, "utf-8");
+  logger.stopSpinnerSuccess("Component copied");
+  logger.newline();
+  logger.box(
+    `\u2728 ${capitalize2(component)} copied successfully!
+
+File: ${outputPath}
+Design: ${formatDesignSystem(designSystem)}
+Tier: ${capitalize2(tier)}
+Lines: ${transformedCode.split("\n").length}`,
+    { title: "Success", borderColor: "green" }
+  );
+  logger.newline();
+  logger.info("Usage:");
+  logger.code(
+    `  import { ${capitalize2(component)} } from './components/${capitalize2(component)}';`
+  );
+  logger.newline();
+}
+async function copyAllComponents(options) {
+  const designSystem = normalizeDesignSystem(options.design || "material-design");
+  const tier = options.tier || "standard";
+  logger.newline();
+  logger.info(`Copying all components...`);
+  logger.info(`Design System: ${formatDesignSystem(designSystem)}`);
+  logger.info(`Tier: ${capitalize2(tier)}`);
+  logger.newline();
+  const libraryRoot = findLibraryRoot();
+  let copied = 0;
+  let skipped = 0;
+  const errors = [];
+  for (const component of COMPONENTS) {
+    const sourcePath = path2.join(
+      libraryRoot,
+      "src",
+      "components",
+      component,
+      designSystem,
+      `${tier}.tsx`
+    );
+    const exists = await fileExists(sourcePath);
+    if (!exists) {
+      skipped++;
+      continue;
+    }
+    try {
+      await copyComponent({ component, designSystem, tier }, { ...options, all: false });
+      copied++;
+    } catch (error) {
+      errors.push(component);
+    }
+  }
+  logger.newline();
+  logger.box(
+    `\u{1F4E6} Bulk Copy Complete
+
+Copied: ${copied} components
+Skipped: ${skipped} (not available)
+Errors: ${errors.length}`,
+    { title: "Summary", borderColor: copied > 0 ? "green" : "yellow" }
+  );
+  if (errors.length > 0) {
+    logger.warn(`Failed: ${errors.join(", ")}`);
+  }
+}
+function transformComponent(code, parsed) {
+  const { component, designSystem, tier } = parsed;
+  const header = `/**
+ * ${capitalize2(component)} Component
+ *
+ * Copied from @nikkory/vibe-library
+ * Design System: ${formatDesignSystem(designSystem)}
+ * Tier: ${capitalize2(tier)}
+ *
+ * Zero-token generation - No AI needed
+ * Just copy, paste, and customize!
+ */
+
+`;
+  let transformed = code;
+  transformed = transformed.replace(/from ['"]@nikkory\/vibe-library\/core['"]/g, "from './core'");
+  transformed = transformed.replace(/from ['"]@nikkory\/vibe-library['"]/g, "from './index'");
+  if (!transformed.includes("'use client'")) {
+    transformed = `'use client';
+
+${transformed}`;
+  }
+  return `${header}${transformed}`;
+}
+function findLibraryRoot() {
+  const possiblePaths = [
+    path2.join(process.cwd(), "node_modules", "@nikkory", "vibe-library"),
+    path2.join(process.cwd(), "..", "..", "packages", "library"),
+    path2.join(__dirname, "..", "..", "..", "library"),
+    // Development path
+    "m:/AI Workspace/nikkory-vibe/packages/library"
+  ];
+  for (const p of possiblePaths) {
+    try {
+      fsSync.accessSync(p);
+      return p;
+    } catch {
+    }
+  }
+  return possiblePaths[possiblePaths.length - 1] ?? "m:/AI Workspace/nikkory-vibe/packages/library";
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function capitalize2(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatDesignSystem(design) {
+  const names = {
+    "material-design": "Material Design",
+    "ios-hig": "iOS HIG",
+    glassmorphism: "Glassmorphism",
+    neumorphism: "Neumorphism",
+    minimalism: "Minimalism",
+    brutalism: "Brutalism"
+  };
+  return names[design] || capitalize2(design);
+}
+
+// src/commands/generate.ts
+var fs3 = __toESM(require("fs/promises"));
+var path3 = __toESM(require("path"));
+var import_vibe_core = require("@nikkory/vibe-core");
+var import_commander3 = require("commander");
+
+// src/utils/prompts.ts
+var import_inquirer2 = __toESM(require("inquirer"));
+async function promptComponentConfig() {
+  const answers = await import_inquirer2.default.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Component name (PascalCase):",
+      validate: (input) => {
+        if (!input) return "Component name is required";
+        if (!/^[A-Z][a-zA-Z0-9]*$/.test(input)) {
+          return "Component name must be PascalCase (e.g., MyButton)";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "template",
+      message: "Template type:",
+      choices: [
+        { name: "Button", value: "button" },
+        { name: "Card", value: "card" },
+        { name: "Input", value: "input" },
+        { name: "Modal", value: "modal" },
+        { name: "Table", value: "table" }
+      ]
+    },
+    {
+      type: "list",
+      name: "designSystem",
+      message: "Design system:",
+      choices: [
+        { name: "Material Design 3", value: "material-design" },
+        { name: "iOS Human Interface Guidelines", value: "ios-hig" },
+        { name: "Glassmorphism", value: "glassmorphism" },
+        { name: "Neumorphism", value: "neumorphism" },
+        { name: "Minimalism", value: "minimalism" }
+      ]
+    },
+    {
+      type: "list",
+      name: "tier",
+      message: "Quality tier:",
+      choices: [
+        { name: "Basic (Prototype)", value: "basic" },
+        { name: "Standard (Production)", value: "standard" },
+        { name: "Enterprise (Mission-critical)", value: "enterprise" }
+      ],
+      default: "standard"
+    },
+    {
+      type: "list",
+      name: "framework",
+      message: "Framework:",
+      choices: [
+        { name: "React", value: "react" },
+        { name: "Vue", value: "vue" },
+        { name: "Angular", value: "angular" },
+        { name: "Svelte", value: "svelte" },
+        { name: "Solid", value: "solid" }
+      ],
+      default: "react"
+    }
+  ]);
+  return answers;
+}
+async function promptProjectInit() {
+  const answers = await import_inquirer2.default.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      validate: (input) => {
+        if (!input) return "Project name is required";
+        if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+          return "Project name must be lowercase kebab-case (e.g., my-app)";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "framework",
+      message: "Frontend framework:",
+      choices: [
+        { name: "React (Next.js)", value: "react" },
+        { name: "Vue (Nuxt)", value: "vue" },
+        { name: "Angular", value: "angular" },
+        { name: "Svelte (SvelteKit)", value: "svelte" },
+        { name: "Solid (SolidStart)", value: "solid" }
+      ],
+      default: "react"
+    },
+    {
+      type: "list",
+      name: "designSystem",
+      message: "Default design system:",
+      choices: [
+        { name: "Material Design 3", value: "material-design" },
+        { name: "iOS HIG", value: "ios-hig" },
+        { name: "Glassmorphism", value: "glassmorphism" },
+        { name: "Custom", value: "custom" }
+      ],
+      default: "material-design"
+    },
+    {
+      type: "confirm",
+      name: "includeBackend",
+      message: "Include backend (NestJS)?",
+      default: false
+    }
+  ]);
+  return answers;
+}
+async function promptSectionConfig() {
+  const answers = await import_inquirer2.default.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Section name (PascalCase):",
+      validate: (input) => {
+        if (!input) return "Section name is required";
+        if (!/^[A-Z][a-zA-Z0-9]*$/.test(input)) {
+          return "Section name must be PascalCase (e.g., HeroSection)";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "template",
+      message: "Section template:",
+      choices: [
+        // Hero sections
+        { name: "Hero - Centered", value: "hero-centered" },
+        { name: "Hero - Split (Image + Text)", value: "hero-split" },
+        { name: "Hero - Background Image", value: "hero-background" },
+        { name: "Hero - Video Background", value: "hero-video" },
+        // Features sections
+        { name: "Features - Grid", value: "features-grid" },
+        { name: "Features - List", value: "features-list" },
+        { name: "Features - Alternating", value: "features-alternating" },
+        // CTA sections
+        { name: "CTA - Banner", value: "cta-banner" },
+        { name: "CTA - Centered", value: "cta-centered" },
+        { name: "CTA - Split", value: "cta-split" },
+        // Pricing sections
+        { name: "Pricing - Cards", value: "pricing-cards" },
+        { name: "Pricing - Table", value: "pricing-table" },
+        // Testimonial sections
+        { name: "Testimonials - Grid", value: "testimonials-grid" },
+        { name: "Testimonials - Carousel", value: "testimonials-carousel" },
+        // Other sections
+        { name: "FAQ - Accordion", value: "faq-accordion" },
+        { name: "Team - Grid", value: "team-grid" },
+        { name: "Stats - Grid", value: "stats-grid" },
+        { name: "Logo Cloud", value: "logo-cloud" },
+        { name: "Newsletter", value: "newsletter" },
+        { name: "Contact Form", value: "contact-form" }
+      ]
+    },
+    {
+      type: "list",
+      name: "designSystem",
+      message: "Design system:",
+      choices: [
+        { name: "Material Design 3", value: "material-design" },
+        { name: "iOS Human Interface Guidelines", value: "ios-hig" },
+        { name: "Glassmorphism", value: "glassmorphism" },
+        { name: "Neumorphism", value: "neumorphism" },
+        { name: "Brutalism", value: "brutalism" },
+        { name: "Minimalism", value: "minimalism" }
+      ]
+    },
+    {
+      type: "list",
+      name: "tier",
+      message: "Quality tier:",
+      choices: [
+        { name: "Basic (Prototype)", value: "basic" },
+        { name: "Standard (Production)", value: "standard" },
+        { name: "Enterprise (Mission-critical)", value: "enterprise" }
+      ],
+      default: "standard"
+    },
+    {
+      type: "list",
+      name: "framework",
+      message: "Framework:",
+      choices: [
+        { name: "React", value: "react" },
+        { name: "Vue", value: "vue" },
+        { name: "Angular", value: "angular" },
+        { name: "Svelte", value: "svelte" },
+        { name: "Solid", value: "solid" }
+      ],
+      default: "react"
+    },
+    {
+      type: "input",
+      name: "heading",
+      message: "Section heading:",
+      default: "Welcome to Your App"
+    },
+    {
+      type: "input",
+      name: "subheading",
+      message: "Section subheading (optional):",
+      default: ""
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Section description (optional):",
+      default: ""
+    },
+    {
+      type: "input",
+      name: "ctaText",
+      message: "Call-to-action button text:",
+      default: "Get Started"
+    },
+    {
+      type: "input",
+      name: "ctaHref",
+      message: "Call-to-action button link:",
+      default: "#"
+    }
+  ]);
+  return answers;
+}
+async function promptGenerationType() {
+  const answer = await import_inquirer2.default.prompt([
+    {
+      type: "list",
+      name: "type",
+      message: "What do you want to generate?",
+      choices: [
+        { name: "Component (Button, Card, Input, etc.)", value: "component" },
+        { name: "Section (Hero, Features, CTA, etc.)", value: "section" },
+        { name: "Page (Landing, Dashboard, Auth, etc.)", value: "page" }
+      ]
+    }
+  ]);
+  return answer.type;
+}
+async function promptPageConfig() {
+  const answers = await import_inquirer2.default.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Page name (PascalCase):",
+      validate: (input) => {
+        if (!input) return "Page name is required";
+        if (!/^[A-Z][a-zA-Z0-9]*$/.test(input)) {
+          return "Page name must be PascalCase (e.g., HomePage)";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "template",
+      message: "Page template:",
+      choices: [
+        // Landing pages
+        { name: "Landing - SaaS Product", value: "landing-saas" },
+        { name: "Landing - Product Showcase", value: "landing-product" },
+        { name: "Landing - Agency", value: "landing-agency" },
+        { name: "Landing - Startup", value: "landing-startup" },
+        { name: "Landing - Mobile App", value: "landing-app" },
+        // Marketing pages
+        { name: "Marketing - Simple", value: "marketing-simple" },
+        { name: "Marketing - Feature", value: "marketing-feature" },
+        { name: "Marketing - Pricing", value: "marketing-pricing" },
+        // Dashboard pages
+        { name: "Dashboard - Overview", value: "dashboard-overview" },
+        { name: "Dashboard - Analytics", value: "dashboard-analytics" },
+        { name: "Dashboard - Settings", value: "dashboard-settings" },
+        // Auth pages
+        { name: "Auth - Login", value: "auth-login" },
+        { name: "Auth - Register", value: "auth-register" },
+        { name: "Auth - Forgot Password", value: "auth-forgot-password" },
+        // E-commerce pages
+        { name: "E-commerce - Home", value: "ecommerce-home" },
+        { name: "E-commerce - Product", value: "ecommerce-product" },
+        { name: "E-commerce - Cart", value: "ecommerce-cart" },
+        // Error pages
+        { name: "Error - 404 Not Found", value: "error-404" },
+        { name: "Error - 500 Server Error", value: "error-500" },
+        { name: "Error - Maintenance", value: "error-maintenance" },
+        // Content pages
+        { name: "Content - Blog List", value: "content-blog-list" },
+        { name: "Content - Blog Post", value: "content-blog-post" },
+        { name: "Content - About", value: "content-about" },
+        { name: "Content - Contact", value: "content-contact" }
+      ]
+    },
+    {
+      type: "list",
+      name: "designSystem",
+      message: "Design system:",
+      choices: [
+        { name: "Material Design 3", value: "material-design" },
+        { name: "iOS Human Interface Guidelines", value: "ios-hig" },
+        { name: "Glassmorphism", value: "glassmorphism" },
+        { name: "Neumorphism", value: "neumorphism" },
+        { name: "Brutalism", value: "brutalism" },
+        { name: "Minimalism", value: "minimalism" }
+      ]
+    },
+    {
+      type: "list",
+      name: "tier",
+      message: "Quality tier:",
+      choices: [
+        { name: "Basic (Prototype)", value: "basic" },
+        { name: "Standard (Production)", value: "standard" },
+        { name: "Enterprise (Mission-critical)", value: "enterprise" }
+      ],
+      default: "standard"
+    },
+    {
+      type: "list",
+      name: "framework",
+      message: "Framework:",
+      choices: [
+        { name: "React", value: "react" },
+        { name: "Next.js", value: "nextjs" },
+        { name: "Remix", value: "remix" },
+        { name: "Astro", value: "astro" }
+      ],
+      default: "react"
+    },
+    {
+      type: "input",
+      name: "title",
+      message: "Page title (for SEO):",
+      default: "My Page"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Page description (for SEO):",
+      default: "A great page built with Nikkory Vibe"
+    }
+  ]);
+  return answers;
+}
+
+// src/commands/generate.ts
+var generateCommand = new import_commander3.Command("generate").alias("g").description("Generate components, sections, or pages from templates").argument("[type]", "Type to generate (component, section, page)").option("-n, --name <name>", "Name (PascalCase)").option("-t, --template <template>", "Template type").option("-d, --design <system>", "Design system", "material-design").option("--tier <tier>", "Quality tier (basic, standard, enterprise)", "standard").option("-f, --framework <framework>", "Framework (react, vue, etc.)", "react").option("-o, --output <path>", "Output file path").option("--dry-run", "Preview generated code without writing").option("--interactive", "Interactive mode with prompts").option("--heading <text>", "Section heading (for sections)").option("--subheading <text>", "Section subheading (for sections)").option("--description <text>", "Section description (for sections)").option("--cta-text <text>", "CTA button text (for sections)").option("--cta-href <url>", "CTA button link (for sections)").option("--title <text>", "Page title for SEO (for pages)").action(async (type, options) => {
+  try {
+    logger.header("\u{1F3A8} Nikkory Vibe - Code Generator");
+    let generationType = type;
+    if (!generationType || options.interactive) {
+      generationType = await promptGenerationType();
+    }
+    switch (generationType) {
+      case "component":
+        await generateComponent(options);
+        break;
+      case "section":
+        await generateSection(options);
+        break;
+      case "page":
+        await generatePage(options);
+        break;
+      default:
+        await generateComponent(options);
+    }
+  } catch (error) {
+    logger.stopSpinner();
+    logger.error("Unexpected error occurred");
+    if (error instanceof Error) {
+      logger.debug(error.stack || error.message);
+    }
+    process.exit(1);
+  }
+});
+async function generateComponent(options) {
+  let config;
+  if (options.interactive ?? !options.name) {
+    config = await promptComponentConfig();
+  } else {
+    config = {
+      name: options.name ?? "",
+      template: options.template ?? "button",
+      framework: options.framework ?? "react",
+      designSystem: options.design ?? "material-design",
+      tier: options.tier ?? "standard"
+    };
+  }
+  if (!config.name) {
+    logger.error("Component name is required");
+    process.exit(1);
+  }
+  logger.newline();
+  logger.info(`Generating ${config.tier} ${config.template} component...`);
+  logger.info(`Design System: ${config.designSystem}`);
+  logger.info(`Framework: ${config.framework}`);
+  logger.newline();
+  logger.startSpinner("Loading template...");
+  const generator = new import_vibe_core.ComponentGenerator();
+  const result = await generator.generate({
+    name: config.name,
+    template: config.template,
+    designSystem: config.designSystem,
+    tier: config.tier,
+    framework: config.framework,
+    outputPath: options.output
+  });
+  if (result.isFailure()) {
+    logger.stopSpinnerFail("Generation failed");
+    logger.error(result.getError().message);
+    process.exit(1);
+  }
+  logger.stopSpinnerSuccess("Template loaded");
+  const code = result.getValue();
+  if (options.dryRun) {
+    logger.newline();
+    logger.header("Generated Code (Preview)");
+    logger.code(code);
+    logger.newline();
+    logger.info("Dry run mode - No files written");
+    return;
+  }
+  const outputPath = options.output ?? generateComponentPath(config);
+  logger.startSpinner(`Writing to ${outputPath}...`);
+  await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+  await fs3.writeFile(outputPath, code, "utf-8");
+  logger.stopSpinnerSuccess(`Component created: ${outputPath}`);
+  logger.newline();
+  logger.box(
+    `\u2728 ${config.name} component generated successfully!
+
+File: ${outputPath}
+Lines: ${code.split("\n").length}
+Design: ${config.designSystem}
+Tier: ${config.tier}`,
+    { title: "Success", borderColor: "green" }
+  );
+  printNextSteps("component");
+}
+async function generateSection(options) {
+  let config;
+  if (options.interactive ?? !options.name) {
+    config = await promptSectionConfig();
+  } else {
+    config = {
+      name: options.name ?? "",
+      template: options.template ?? "hero-centered",
+      framework: options.framework ?? "react",
+      designSystem: options.design ?? "material-design",
+      tier: options.tier ?? "standard",
+      heading: options.heading ?? "Welcome to Your App",
+      subheading: options.subheading ?? "",
+      description: options.description ?? "",
+      ctaText: options.ctaText ?? "Get Started",
+      ctaHref: options.ctaHref ?? "#"
+    };
+  }
+  if (!config.name) {
+    logger.error("Section name is required");
+    process.exit(1);
+  }
+  logger.newline();
+  logger.info(`Generating ${config.tier} ${config.template} section...`);
+  logger.info(`Design System: ${config.designSystem}`);
+  logger.info(`Framework: ${config.framework}`);
+  logger.newline();
+  const sectionConfig = {
+    name: config.name,
+    template: config.template,
+    designSystem: config.designSystem,
+    tier: config.tier,
+    framework: config.framework,
+    outputPath: options.output,
+    content: {
+      heading: config.heading,
+      subheading: config.subheading || void 0,
+      description: config.description || void 0,
+      cta: config.ctaText ? {
+        text: config.ctaText,
+        href: config.ctaHref || "#"
+      } : void 0
+    }
+  };
+  logger.startSpinner("Generating section...");
+  const generator = new import_vibe_core.SectionGenerator();
+  const result = await generator.generateSection(sectionConfig);
+  if (result.isFailure()) {
+    logger.stopSpinnerFail("Generation failed");
+    logger.error(result.getError().message);
+    process.exit(1);
+  }
+  logger.stopSpinnerSuccess("Section generated");
+  const sectionResult = result.getValue();
+  if (options.dryRun) {
+    logger.newline();
+    logger.header("Generated Code (Preview)");
+    logger.code(sectionResult.code);
+    logger.newline();
+    logger.info("Dry run mode - No files written");
+    logger.newline();
+    logger.info("Metadata:");
+    logger.info(`  Template: ${sectionResult.metadata.template}`);
+    logger.info(`  Lines of code: ${sectionResult.metadata.linesOfCode}`);
+    logger.info(`  Child components: ${sectionResult.metadata.childComponentCount}`);
+    return;
+  }
+  const outputPath = options.output ?? generateSectionPath(config);
+  logger.startSpinner(`Writing to ${outputPath}...`);
+  await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+  await fs3.writeFile(outputPath, sectionResult.code, "utf-8");
+  logger.stopSpinnerSuccess(`Section created: ${outputPath}`);
+  logger.newline();
+  logger.box(
+    `\u2728 ${config.name} section generated successfully!
+
+File: ${outputPath}
+Template: ${config.template}
+Lines: ${sectionResult.metadata.linesOfCode}
+Design: ${config.designSystem}
+Tier: ${config.tier}`,
+    { title: "Success", borderColor: "green" }
+  );
+  printNextSteps("section");
+}
+async function generatePage(options) {
+  let config;
+  if (options.interactive ?? !options.name) {
+    config = await promptPageConfig();
+  } else {
+    config = {
+      name: options.name ?? "",
+      template: options.template ?? "landing-saas",
+      framework: options.framework ?? "react",
+      designSystem: options.design ?? "material-design",
+      tier: options.tier ?? "standard",
+      title: options.title ?? "My Page",
+      description: options.description ?? ""
+    };
+  }
+  if (!config.name) {
+    logger.error("Page name is required");
+    process.exit(1);
+  }
+  logger.newline();
+  logger.info(`Generating ${config.tier} ${config.template} page...`);
+  logger.info(`Design System: ${config.designSystem}`);
+  logger.info(`Framework: ${config.framework}`);
+  logger.newline();
+  const pageConfig = {
+    name: config.name,
+    template: config.template,
+    designSystem: config.designSystem,
+    tier: config.tier,
+    framework: config.framework,
+    outputPath: options.output,
+    meta: {
+      title: config.title,
+      description: config.description || void 0
+    }
+  };
+  logger.startSpinner("Generating page...");
+  const generator = new import_vibe_core.PageGenerator();
+  const result = await generator.generatePage(pageConfig);
+  if (result.isFailure()) {
+    logger.stopSpinnerFail("Generation failed");
+    logger.error(result.getError().message);
+    process.exit(1);
+  }
+  logger.stopSpinnerSuccess("Page generated");
+  const pageResult = result.getValue();
+  if (options.dryRun) {
+    logger.newline();
+    logger.header("Generated Code (Preview)");
+    logger.code(pageResult.code);
+    logger.newline();
+    logger.info("Dry run mode - No files written");
+    logger.newline();
+    logger.info("Metadata:");
+    logger.info(`  Template: ${pageResult.metadata.template}`);
+    logger.info(`  Framework: ${pageResult.metadata.framework}`);
+    logger.info(`  Lines of code: ${pageResult.metadata.linesOfCode}`);
+    logger.info(`  Sections: ${pageResult.metadata.sectionCount}`);
+    return;
+  }
+  const outputPath = options.output ?? generatePagePath(config);
+  logger.startSpinner(`Writing to ${outputPath}...`);
+  await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+  await fs3.writeFile(outputPath, pageResult.code, "utf-8");
+  logger.stopSpinnerSuccess(`Page created: ${outputPath}`);
+  logger.newline();
+  logger.box(
+    `\u2728 ${config.name} page generated successfully!
+
+File: ${outputPath}
+Template: ${config.template}
+Lines: ${pageResult.metadata.linesOfCode}
+Framework: ${config.framework}
+Design: ${config.designSystem}
+Tier: ${config.tier}`,
+    { title: "Success", borderColor: "green" }
+  );
+  printNextSteps("page");
+}
+function generateComponentPath(config) {
+  const ext = getFileExtension(config.framework);
+  const fileName = `${config.name}.${ext}`;
+  return path3.join(process.cwd(), "src", "components", fileName);
+}
+function generateSectionPath(config) {
+  const ext = getFileExtension(config.framework);
+  const fileName = `${config.name}.${ext}`;
+  return path3.join(process.cwd(), "src", "sections", fileName);
+}
+function generatePagePath(config) {
+  const ext = getFileExtension(config.framework);
+  const fileName = `${config.name}.${ext}`;
+  const pageDir = config.framework === "nextjs" ? "app" : "pages";
+  return path3.join(process.cwd(), "src", pageDir, fileName);
+}
+function getFileExtension(framework) {
+  const extensions = {
+    react: "tsx",
+    vue: "vue",
+    angular: "component.ts",
+    svelte: "svelte",
+    solid: "tsx"
+  };
+  return extensions[framework] || "tsx";
+}
+function printNextSteps(type) {
+  logger.newline();
+  logger.info("Next steps:");
+  if (type === "component") {
+    logger.code("  1. Import the component in your app");
+    logger.code("  2. Review and customize as needed");
+    logger.code("  3. Run your dev server to test");
+  } else if (type === "section") {
+    logger.code("  1. Import the section in your page");
+    logger.code("  2. Customize content props (heading, description, etc.)");
+    logger.code("  3. Add your own images and assets");
+    logger.code("  4. Run your dev server to preview");
+  } else {
+    logger.code("  1. Set up routing for your page");
+    logger.code("  2. Customize page content and sections");
+    logger.code("  3. Add SEO meta tags if needed");
+    logger.code("  4. Run your dev server to preview");
+  }
+  logger.newline();
+}
+
+// src/commands/init.ts
+var fs4 = __toESM(require("fs/promises"));
+var path4 = __toESM(require("path"));
+var import_commander4 = require("commander");
+function generateClaudeMd(config) {
+  const tier = config.tier || "standard";
+  return `# Claude Code Instructions - ${config.projectName}
+
+> Auto-generated by Nikkory Vibe. AI Agent will automatically follow these quality rules.
+
+## Project Overview
+
+- **Framework**: ${config.framework}
+- **Design System**: ${config.designSystem}
+- **Styling**: TailwindCSS
+- **Quality Tier**: ${tier}
+
+---
+
+# \u{1F534} AI AGENT INSPECTOR - MANDATORY QUALITY RULES
+
+**CRITICAL**: These rules are AUTOMATICALLY ENFORCED. AI Agent MUST follow ALL rules below for EVERY code change. No exceptions. No simplification.
+
+## ESLint Zero-Error Rules (MANDATORY)
+
+### Import Order (ALWAYS enforce)
+
+\`\`\`typescript
+// \u2705 CORRECT - React first, blank line between groups
+import React, { useState, useCallback, memo, forwardRef } from 'react';
+
+import { cn } from '@/lib/utils';
+import { Button } from '@/components';
+
+// \u274C WRONG - No blank lines, wrong order
+import { Button } from '@/components';
+import React from 'react';
+import { cn } from '@/lib/utils';
+\`\`\`
+
+### Explicit Return Types (ALWAYS add)
+
+\`\`\`typescript
+// \u2705 CORRECT
+const handleClick = (e: React.MouseEvent<HTMLButtonElement>): void => {
+  console.log(e);
+};
+
+// \u274C WRONG - Missing return type
+const handleClick = (e) => {
+  console.log(e);
+};
+\`\`\`
+
+### No Unused Variables (ALWAYS prefix with _)
+
+\`\`\`typescript
+// \u2705 CORRECT
+const { name, age: _age, email } = user;  // _age unused but valid
+
+// \u274C WRONG
+const { name, age, email } = user;  // age unused = ERROR
+\`\`\`
+
+### No \`any\` Type (ALWAYS use \`unknown\`)
+
+\`\`\`typescript
+// \u2705 CORRECT
+const handleData = (data: unknown): void => {};
+
+// \u274C WRONG
+const handleData = (data: any): void => {};
+\`\`\`
+
+### No Non-Null Assertion (ALWAYS use optional chaining)
+
+\`\`\`typescript
+// \u2705 CORRECT
+ref.current?.focus();
+
+// \u274C WRONG
+ref.current!.focus();
+\`\`\`
+
+## TypeScript Strict Mode (MANDATORY)
+
+| Pattern | Required | Example |
+|---------|----------|---------|
+| Explicit return types | YES | \`(): void\`, \`(): string\` |
+| No implicit any | YES | Always type parameters |
+| Strict null checks | YES | Use \`?.\` and \`??\` |
+| Interface over type | YES | For object shapes |
+
+## React Component Patterns
+
+### Basic Tier
+
+\`\`\`typescript
+import React from 'react';
+
+interface ComponentProps {
+  children?: React.ReactNode;
+  className?: string;
+}
+
+export const Component: React.FC<ComponentProps> = ({
+  children,
+  className,
+}) => {
+  return <div className={className}>{children}</div>;
+};
+\`\`\`
+
+### Standard Tier (forwardRef + displayName)
+
+\`\`\`typescript
+import React, { forwardRef } from 'react';
+
+interface ComponentProps {
+  children?: React.ReactNode;
+  variant?: 'primary' | 'secondary';
+}
+
+export const Component = forwardRef<HTMLDivElement, ComponentProps>(
+  ({ children, variant = 'primary', ...props }, ref) => {
+    return <div ref={ref} {...props}>{children}</div>;
+  }
+);
+
+Component.displayName = 'Component';  // REQUIRED!
+\`\`\`
+
+### Enterprise Tier (memo + forwardRef + displayName)
+
+\`\`\`typescript
+import React, { memo, forwardRef, useCallback } from 'react';
+
+interface ComponentProps {
+  children?: React.ReactNode;
+  analyticsEvent?: string;
+  onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+}
+
+export const Component = memo(
+  forwardRef<HTMLDivElement, ComponentProps>(
+    ({ children, analyticsEvent, onClick, ...props }, ref) => {
+      const handleClick = useCallback(
+        (e: React.MouseEvent<HTMLDivElement>): void => {
+          if (analyticsEvent && typeof window !== 'undefined') {
+            (window as unknown as { dataLayer?: unknown[] }).dataLayer?.push({
+              event: analyticsEvent,
+            });
+          }
+          onClick?.(e);
+        },
+        [analyticsEvent, onClick]
+      );
+
+      return <div ref={ref} onClick={handleClick} {...props}>{children}</div>;
+    }
+  )
+);
+
+Component.displayName = 'Component';  // REQUIRED!
+\`\`\`
+
+## Debugging Rules (NEVER SKIP)
+
+When debugging or fixing issues:
+
+1. **NEVER simplify code** - Fix the actual issue, don't remove features
+2. **NEVER remove types** - Keep all TypeScript annotations
+3. **NEVER use \`any\`** - Use \`unknown\` if type is unclear
+4. **ALWAYS preserve patterns** - forwardRef, memo, displayName
+5. **ALWAYS run lint check** - \`pnpm lint\` before considering done
+6. **ALWAYS check types** - \`pnpm type-check\` before considering done
+
+## Pre-Commit Checklist (AUTO-ENFORCE)
+
+Before ANY commit, AI Agent MUST verify:
+
+- [ ] All imports have correct order with blank lines
+- [ ] All functions have explicit return types
+- [ ] No unused variables (prefix with _ if intentionally unused)
+- [ ] No \`any\` types (use \`unknown\` instead)
+- [ ] No non-null assertions (use \`?.\` instead)
+- [ ] forwardRef components have displayName
+- [ ] Enterprise components use memo()
+- [ ] useEffect cleanup has \`: void\` return type
+- [ ] Event handlers have proper React event types
+
+## Quick Fix Reference
+
+| Error | Quick Fix |
+|-------|-----------|
+| \`import/order\` | Add blank line between import groups |
+| \`explicit-function-return-type\` | Add \`: void\`, \`: string\`, etc. |
+| \`no-unused-vars\` | Prefix with \`_\` |
+| \`no-explicit-any\` | Use \`unknown\` |
+| \`no-non-null-assertion\` | Use \`?.\` optional chaining |
+| \`TS2304: Cannot find name\` | Add missing import |
+| \`TS2322: Type not assignable\` | Fix type or cast properly |
+| \`TS6133: Unused declaration\` | Remove or prefix with \`_\` |
+
+---
+
+**Powered by Nikkory Vibe**
+`;
+}
+var initCommand = new import_commander4.Command("init").description("Initialize a new Nikkory Vibe project with AI Agent Inspector").argument("[project-name]", "Project name (kebab-case)").option("-f, --framework <framework>", "Frontend framework", "react").option("-d, --design <system>", "Default design system", "material-design").option("-t, --tier <tier>", "Quality tier (basic, standard, enterprise)", "standard").option("--backend", "Include backend (NestJS)").option("--no-install", "Skip dependency installation").option("--no-claude", "Skip CLAUDE.md generation").action(
+  async (projectName, options) => {
+    try {
+      logger.header("\u{1F3A8} Nikkory Vibe - Project Initialization");
+      let config;
+      if (!projectName) {
+        const promptConfig = await promptProjectInit();
+        projectName = promptConfig.projectName;
+        config = {
+          ...promptConfig,
+          tier: options.tier ?? "standard"
+        };
+      } else {
+        config = {
+          projectName,
+          framework: options.framework ?? "react",
+          designSystem: options.design ?? "material-design",
+          tier: options.tier ?? "standard",
+          includeBackend: options.backend ?? false
+        };
+      }
+      const projectPath = path4.join(process.cwd(), projectName);
+      try {
+        await fs4.access(projectPath);
+        logger.error(`Directory "${projectName}" already exists`);
+        process.exit(1);
+      } catch {
+      }
+      logger.newline();
+      logger.info(`Creating project: ${projectName}`);
+      logger.info(`Framework: ${config.framework}`);
+      logger.info(`Design System: ${config.designSystem}`);
+      logger.info(`Quality Tier: ${config.tier}`);
+      if (config.includeBackend) {
+        logger.info(`Backend: NestJS`);
+      }
+      logger.newline();
+      logger.startSpinner("Creating project structure...");
+      await fs4.mkdir(projectPath, { recursive: true });
+      await createProjectStructure(projectPath, config);
+      logger.stopSpinnerSuccess("Project structure created");
+      logger.startSpinner("Creating package.json...");
+      await createPackageJson(projectPath, config);
+      logger.stopSpinnerSuccess("package.json created");
+      logger.startSpinner("Creating configuration files...");
+      await createConfigFiles(projectPath, config);
+      logger.stopSpinnerSuccess("Configuration files created");
+      if (options.claude !== false) {
+        logger.startSpinner("Creating CLAUDE.md (AI Agent Inspector)...");
+        await createClaudeMd(projectPath, config);
+        logger.stopSpinnerSuccess("CLAUDE.md created - AI Agent Inspector enabled");
+      }
+      logger.startSpinner("Creating README.md...");
+      await createReadme(projectPath, config);
+      logger.stopSpinnerSuccess("README.md created");
+      logger.newline();
+      logger.box(
+        `\u2728 Project "${projectName}" created successfully!
+
+Location: ${projectPath}
+Framework: ${config.framework}
+Design: ${config.designSystem}
+Tier: ${config.tier}
+AI Inspector: ${options.claude !== false ? "Enabled" : "Disabled"}`,
+        { title: "Success", borderColor: "green" }
+      );
+      if (options.claude !== false) {
+        logger.newline();
+        logger.info("\u{1F534} AI Agent Inspector is enabled!");
+        logger.info("   Claude Code will automatically enforce quality rules.");
+        logger.info("   No manual commands needed - just code!");
+      }
+      logger.newline();
+      logger.info("Next steps:");
+      logger.code(`  cd ${projectName}`);
+      if (options.install ?? true) {
+        logger.code(`  pnpm install`);
+      }
+      logger.code(`  pnpm dev`);
+      logger.newline();
+      logger.info("Generate your first component:");
+      logger.code(`  vibe smart button --style glassmorphism --tier ${config.tier}`);
+      logger.newline();
+    } catch (error) {
+      logger.stopSpinner();
+      logger.error("Project initialization failed");
+      if (error instanceof Error) {
+        logger.debug(error.stack || error.message);
+      }
+      process.exit(1);
+    }
+  }
+);
+async function createProjectStructure(projectPath, config) {
+  const dirs = ["src/components", "src/pages", "src/styles", "src/utils", "public", ".claude"];
+  if (config.includeBackend) {
+    dirs.push("api/src/modules", "api/src/common", "api/prisma");
+  }
+  for (const dir of dirs) {
+    await fs4.mkdir(path4.join(projectPath, dir), { recursive: true });
+  }
+}
+async function createClaudeMd(projectPath, config) {
+  const content = generateClaudeMd(config);
+  await fs4.writeFile(path4.join(projectPath, "CLAUDE.md"), content, "utf-8");
+}
+async function createPackageJson(projectPath, config) {
+  const packageJson = {
+    name: config.projectName,
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: config.framework === "react" ? "next dev" : "vite dev",
+      build: config.framework === "react" ? "next build" : "vite build",
+      start: config.framework === "react" ? "next start" : "vite preview",
+      lint: "eslint . --ext .ts,.tsx",
+      "type-check": "tsc --noEmit"
+    },
+    dependencies: getFrameworkDependencies(config.framework),
+    devDependencies: {
+      "@types/node": "^20.0.0",
+      "@types/react": "^18.0.0",
+      "@types/react-dom": "^18.0.0",
+      typescript: "^5.0.0",
+      eslint: "^8.0.0",
+      "@nikkory/vibe-cli": "^1.0.0"
+    }
+  };
+  await fs4.writeFile(
+    path4.join(projectPath, "package.json"),
+    JSON.stringify(packageJson, null, 2),
+    "utf-8"
+  );
+}
+function getFrameworkDependencies(framework) {
+  const deps = {
+    react: {
+      react: "^18.2.0",
+      "react-dom": "^18.2.0",
+      next: "^14.0.0",
+      tailwindcss: "^3.4.0"
+    },
+    vue: {
+      vue: "^3.3.0",
+      nuxt: "^3.8.0",
+      tailwindcss: "^3.4.0"
+    },
+    angular: {
+      "@angular/core": "^17.0.0",
+      "@angular/common": "^17.0.0",
+      "@angular/platform-browser": "^17.0.0"
+    },
+    svelte: {
+      svelte: "^4.0.0",
+      "@sveltejs/kit": "^2.0.0",
+      tailwindcss: "^3.4.0"
+    },
+    solid: {
+      "solid-js": "^1.8.0",
+      "solid-start": "^0.4.0",
+      tailwindcss: "^3.4.0"
+    }
+  };
+  return deps[framework] ?? deps["react"] ?? {};
+}
+async function createConfigFiles(projectPath, _config) {
+  const tsConfig = {
+    compilerOptions: {
+      target: "ES2020",
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      jsx: "preserve",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      allowJs: true,
+      strict: true,
+      noImplicitAny: true,
+      strictNullChecks: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      incremental: true,
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules"]
+  };
+  await fs4.writeFile(
+    path4.join(projectPath, "tsconfig.json"),
+    JSON.stringify(tsConfig, null, 2),
+    "utf-8"
+  );
+  const gitignore = `# Dependencies
+node_modules
+.pnpm-store
+
+# Build output
+dist
+.next
+out
+build
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+`;
+  await fs4.writeFile(path4.join(projectPath, ".gitignore"), gitignore, "utf-8");
+}
+async function createReadme(projectPath, config) {
+  const readme = `# ${config.projectName}
+
+Generated with **Nikkory Vibe** \u2728
+
+## Tech Stack
+
+- **Framework**: ${config.framework}
+- **Design System**: ${config.designSystem}
+- **Quality Tier**: ${config.tier}
+- **Styling**: TailwindCSS
+- **TypeScript**: 5.0+
+
+## AI Agent Inspector
+
+This project includes **AI Agent Inspector** via \`CLAUDE.md\`.
+When using Claude Code, AI will automatically:
+
+- \u2705 Follow ESLint zero-error rules
+- \u2705 Use TypeScript strict mode patterns
+- \u2705 Apply correct React component patterns for ${config.tier} tier
+- \u2705 Never simplify code when debugging
+- \u2705 Run lint/type checks before completing tasks
+
+**No manual commands needed - just code!**
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+pnpm install
+
+# Run development server
+pnpm dev
+
+# Build for production
+pnpm build
+\`\`\`
+
+## Generate Components
+
+\`\`\`bash
+# Generate a component with Smart Generator
+vibe smart button --style glassmorphism --tier ${config.tier}
+
+# List all 50 design styles
+vibe smart --list-styles
+
+# Generate all 3 tiers at once
+vibe smart card --style brutalism --all-tiers
+
+# Preview without writing
+vibe smart input --style neumorphism --dry-run
+\`\`\`
+
+## Code Quality
+
+\`\`\`bash
+# Run ESLint
+pnpm lint
+
+# Run TypeScript check
+pnpm type-check
+
+# Run Code Doctor
+vibe doctor scan ./src
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${config.projectName}/
+\u251C\u2500\u2500 src/
+\u2502   \u251C\u2500\u2500 components/    # React components
+\u2502   \u251C\u2500\u2500 pages/         # Page components
+\u2502   \u251C\u2500\u2500 styles/        # Global styles
+\u2502   \u2514\u2500\u2500 utils/         # Utilities
+\u251C\u2500\u2500 public/            # Static assets
+\u251C\u2500\u2500 CLAUDE.md          # AI Agent Inspector rules
+\u2514\u2500\u2500 package.json
+\`\`\`
+
+## Learn More
+
+- [Nikkory Vibe Documentation](https://vibe.nikkory.com/docs)
+- [Design Systems](https://vibe.nikkory.com/docs/design-systems)
+- [CLI Reference](https://vibe.nikkory.com/docs/cli)
+
+---
+
+Powered by Nikkory
+`;
+  await fs4.writeFile(path4.join(projectPath, "README.md"), readme, "utf-8");
+}
+
+// src/commands/list.ts
+var import_commander5 = require("commander");
+var listCommand = new import_commander5.Command("list").alias("ls").description("List available templates and design systems").argument("[category]", "Category to list (templates, designs, tiers)", "all").option("--json", "Output as JSON").action((category, options) => {
+  try {
+    if (options.json) {
+      const data = getAllData();
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    logger.header("\u{1F3A8} Nikkory Vibe - Available Options");
+    switch (category) {
+      case "templates":
+        listTemplates();
+        break;
+      case "designs":
+      case "design-systems":
+        listDesignSystems();
+        break;
+      case "tiers":
+        listTiers();
+        break;
+      case "frameworks":
+        listFrameworks();
+        break;
+      case "all":
+      default:
+        listTemplates();
+        logger.newline();
+        listDesignSystems();
+        logger.newline();
+        listTiers();
+        logger.newline();
+        listFrameworks();
+        break;
+    }
+    logger.newline();
+    logger.info("Generate a component:");
+    logger.code("  vibe generate component MyButton --design material-design");
+    logger.newline();
+  } catch (error) {
+    logger.error("Failed to list options");
+    if (error instanceof Error) {
+      logger.debug(error.stack || error.message);
+    }
+    process.exit(1);
+  }
+});
+function listTemplates() {
+  logger.newline();
+  logger.info("\u{1F4E6} Available Templates:");
+  logger.separator();
+  const templates = [
+    { name: "Button", value: "button", description: "Interactive button components" },
+    { name: "Card", value: "card", description: "Content container cards" },
+    { name: "Input", value: "input", description: "Form input fields" },
+    { name: "Modal", value: "modal", description: "Dialog/modal overlays" },
+    { name: "Table", value: "table", description: "Data tables" },
+    { name: "Form", value: "form", description: "Form layouts" },
+    { name: "Navigation", value: "navigation", description: "Nav bars and menus" },
+    { name: "Hero", value: "hero", description: "Hero sections" },
+    { name: "Feature", value: "feature", description: "Feature showcases" },
+    { name: "Pricing", value: "pricing", description: "Pricing tables" }
+  ];
+  logger.table(
+    templates.map((t) => ({
+      Template: t.name,
+      ID: t.value,
+      Description: t.description
+    }))
+  );
+}
+function listDesignSystems() {
+  logger.newline();
+  logger.info("\u{1F3A8} Available Design Systems:");
+  logger.separator();
+  const designs = [
+    {
+      name: "Material Design 3",
+      value: "material-design",
+      category: "Modern"
+    },
+    {
+      name: "iOS Human Interface Guidelines",
+      value: "ios-hig",
+      category: "Mobile"
+    },
+    {
+      name: "Glassmorphism",
+      value: "glassmorphism",
+      category: "Modern"
+    },
+    {
+      name: "Neumorphism",
+      value: "neumorphism",
+      category: "Modern"
+    },
+    {
+      name: "Minimalism",
+      value: "minimalism",
+      category: "Clean"
+    },
+    {
+      name: "Brutalism",
+      value: "brutalism",
+      category: "Bold"
+    },
+    {
+      name: "Cyberpunk",
+      value: "cyberpunk",
+      category: "Futuristic"
+    },
+    {
+      name: "Retro",
+      value: "retro",
+      category: "Vintage"
+    }
+  ];
+  logger.table(
+    designs.map((d) => ({
+      "Design System": d.name,
+      ID: d.value,
+      Category: d.category
+    }))
+  );
+}
+function listTiers() {
+  logger.newline();
+  logger.info("\u2B50 Quality Tiers:");
+  logger.separator();
+  const tiers = [
+    {
+      tier: "Basic",
+      id: "basic",
+      description: "Prototype/demo quality",
+      features: "2-3 variants, basic styling",
+      loc: "~60 LOC"
+    },
+    {
+      tier: "Standard",
+      id: "standard",
+      description: "Production-ready",
+      features: "5+ variants, accessibility, dark mode",
+      loc: "~200 LOC"
+    },
+    {
+      tier: "Enterprise",
+      id: "enterprise",
+      description: "Mission-critical",
+      features: "All features + analytics + advanced animations",
+      loc: "~350 LOC"
+    }
+  ];
+  logger.table(
+    tiers.map((t) => ({
+      Tier: t.tier,
+      ID: t.id,
+      Description: t.description,
+      Features: t.features,
+      Size: t.loc
+    }))
+  );
+}
+function listFrameworks() {
+  logger.newline();
+  logger.info("\u{1F680} Supported Frameworks:");
+  logger.separator();
+  const frameworks = [
+    { name: "React", value: "react", extension: ".tsx" },
+    { name: "Vue", value: "vue", extension: ".vue" },
+    { name: "Angular", value: "angular", extension: ".component.ts" },
+    { name: "Svelte", value: "svelte", extension: ".svelte" },
+    { name: "Solid", value: "solid", extension: ".tsx" }
+  ];
+  logger.table(
+    frameworks.map((f) => ({
+      Framework: f.name,
+      ID: f.value,
+      Extension: f.extension
+    }))
+  );
+}
+function getAllData() {
+  return {
+    templates: [
+      "button",
+      "card",
+      "input",
+      "modal",
+      "table",
+      "form",
+      "navigation",
+      "hero",
+      "feature",
+      "pricing"
+    ],
+    designSystems: [
+      "material-design",
+      "ios-hig",
+      "glassmorphism",
+      "neumorphism",
+      "minimalism",
+      "brutalism",
+      "cyberpunk",
+      "retro"
+    ],
+    tiers: ["basic", "standard", "enterprise"],
+    frameworks: ["react", "vue", "angular", "svelte", "solid"]
+  };
+}
+
+// src/commands/matrix-generate.ts
+var import_commander6 = require("commander");
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora2 = __toESM(require("ora"));
+var import_vibe_engine = require("@nikkory/vibe-engine");
+
+// src/generators/component-generator.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var ComponentGenerator2 = class {
+  /**
+   * Write generated code to file
+   *
+   * @param filePath - Absolute file path
+   * @param code - Generated code content
+   * @returns Promise<void>
+   */
+  async writeToFile(filePath, code) {
+    await (0, import_promises.mkdir)((0, import_path.dirname)(filePath), { recursive: true });
+    await (0, import_promises.writeFile)(filePath, code, "utf-8");
+  }
+  /**
+   * Format code with syntax highlighting (for terminal output)
+   *
+   * @param code - Code to format
+   * @returns Formatted code string
+   *
+   * Note: Simple pass-through for now. Could use chalk for syntax highlighting.
+   */
+  formatCode(code) {
+    return code;
+  }
+};
+
+// src/commands/matrix-generate.ts
+var matrixGenerateCommand = new import_commander6.Command("matrix-generate").description("Generate UI component using Matrix Multiplication (24-Factor System)").argument("<component>", "Component ID (e.g., button, input, card)").option(
+  "-d, --design-system <system>",
+  "Design system (material-design, ios-hig, glassmorphism, neumorphism, brutalism, minimalism, fluent, carbon, ant-design, chakra, atlassian, blueprint)",
+  "material-design"
+).option(
+  "-t, --tier <tier>",
+  "Quality tier (basic, standard, enterprise)",
+  "standard"
+).option(
+  "-f, --factor-overrides <json>",
+  `Factor overrides as JSON (e.g., '{"4":"xl","17":"lg"}')`
+).option(
+  "-o, --output <path>",
+  "Output file path"
+).action(async (componentId, options) => {
+  const spinner = (0, import_ora2.default)("Generating component...").start();
+  try {
+    const resolver = new import_vibe_engine.MatrixResolver();
+    const templateEngine = new import_vibe_engine.TemplateEngine();
+    let factor24Config;
+    if (options.factorOverrides) {
+      try {
+        factor24Config = JSON.parse(options.factorOverrides);
+      } catch (parseError) {
+        spinner.fail(import_chalk2.default.red("Invalid JSON in --factor-overrides"));
+        if (parseError instanceof Error) {
+          console.error(import_chalk2.default.gray(parseError.message));
+        }
+        process.exit(1);
+      }
+    }
+    const input = {
+      componentId,
+      designSystem: options.designSystem,
+      tier: options.tier,
+      factor24Config
+    };
+    const config = resolver.resolve(input);
+    const code = templateEngine.generate(config);
+    const generator = new ComponentGenerator2();
+    if (options.output) {
+      await generator.writeToFile(options.output, code);
+      spinner.succeed(import_chalk2.default.green(`Generated ${config.componentName} \u2192 ${options.output}`));
+    } else {
+      spinner.succeed(import_chalk2.default.green(`Generated ${config.componentName}`));
+      console.log(code);
+    }
+    console.log(import_chalk2.default.cyan("\nComponent Info:"));
+    console.log(`  ${import_chalk2.default.gray("Name:")} ${config.componentName}`);
+    console.log(`  ${import_chalk2.default.gray("Tier:")} ${config.tier}`);
+    console.log(`  ${import_chalk2.default.gray("Design System:")} ${config.designSystem}`);
+    console.log(`  ${import_chalk2.default.gray("HTML Element:")} <${config.elementType}>`);
+    console.log(`  ${import_chalk2.default.gray("Class Names:")} ${config.classNames.join(" ")}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(import_chalk2.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new import_commander7.Command();
+program.name("vibe").description("Nikkory Vibe - Production-ready code in seconds").version("1.0.0");
+program.addCommand(generateCommand);
+program.addCommand(matrixGenerateCommand);
+program.addCommand(initCommand);
+program.addCommand(listCommand);
+program.addCommand(addCommand);
+program.addCommand(copyCommand);
+program.parse(process.argv);