@nikkory/vibe-cli 2.2.0 → 2.3.0

package/dist/index.js

@@ -24,8 +24,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_commander4 = require("commander");
-var import_chalk3 = __toESM(require("chalk"));
+var import_commander6 = require("commander");
+var import_chalk5 = __toESM(require("chalk"));
 
 // src/commands/init.ts
 var fs = __toESM(require("fs/promises"));
@@ -1060,11 +1060,515 @@ var matrixGenerateCommand = new import_commander3.Command("add").alias("gen").al
   }
 });
 
+// src/commands/section-generate.ts
+var import_commander4 = require("commander");
+var import_chalk3 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
+
+// src/generators/section-generator.ts
+var path3 = __toESM(require("path"));
+
+// src/generators/matrix-engine.ts
+var fs2 = __toESM(require("fs/promises"));
+var path2 = __toESM(require("path"));
+var import_handlebars = __toESM(require("handlebars"));
+var MatrixEngine = class {
+  handlebars;
+  constructor() {
+    this.handlebars = import_handlebars.default.create();
+    this.registerHelpers();
+  }
+  /**
+   * Register Handlebars helpers for conditional logic
+   */
+  registerHelpers() {
+    this.handlebars.registerHelper("eq", (a, b) => a === b);
+    this.handlebars.registerHelper("ne", (a, b) => a !== b);
+    this.handlebars.registerHelper("or", (...args) => {
+      const _options = args[args.length - 1];
+      return args.slice(0, -1).some(Boolean);
+    });
+    this.handlebars.registerHelper("and", (...args) => {
+      const _options = args[args.length - 1];
+      return args.slice(0, -1).every(Boolean);
+    });
+  }
+  /**
+   * Load matrix configuration from config.json
+   *
+   * @param templateDir - Path to template directory
+   * @returns Matrix configuration
+   * @throws Error if config.json not found or invalid
+   */
+  async loadConfig(templateDir) {
+    const configPath = path2.join(templateDir, "config.json");
+    try {
+      const content = await fs2.readFile(configPath, "utf-8");
+      const config = JSON.parse(content);
+      if (!config.templateName || !config.dimensions || !config.variables) {
+        throw new Error("Invalid matrix config: missing required fields");
+      }
+      return config;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Matrix config not found: ${configPath}`);
+      }
+      throw new Error(`Failed to load matrix config: ${error.message}`);
+    }
+  }
+  /**
+   * Validate dimension values against configuration
+   *
+   * @param dimensions - Dimension values to validate
+   * @param config - Matrix configuration
+   * @throws Error if invalid dimension values
+   */
+  validateDimensions(dimensions, config) {
+    for (const [dimName, dimValue] of Object.entries(dimensions)) {
+      const dimDef = config.dimensions[dimName];
+      if (!dimDef) {
+        throw new Error(`Unknown dimension: ${dimName}`);
+      }
+      if (!dimDef.values.includes(dimValue)) {
+        throw new Error(
+          `Invalid value "${dimValue}" for dimension "${dimName}". Valid values: ${dimDef.values.join(", ")}`
+        );
+      }
+    }
+  }
+  /**
+   * Validate variable values against configuration
+   *
+   * @param variables - Variable values to validate
+   * @param config - Matrix configuration
+   * @throws Error if required variables missing
+   */
+  validateVariables(variables, config) {
+    for (const [varName, varDef] of Object.entries(config.variables)) {
+      if (varDef.required && !varDef.auto && !variables[varName]) {
+        throw new Error(`Required variable missing: ${varName}`);
+      }
+    }
+  }
+  /**
+   * Apply defaults to dimensions
+   *
+   * @param dimensions - User-provided dimension values
+   * @param config - Matrix configuration
+   * @returns Dimensions with defaults applied
+   */
+  applyDimensionDefaults(dimensions, config) {
+    const result = { ...dimensions };
+    for (const [dimName, dimDef] of Object.entries(config.dimensions)) {
+      if (!result[dimName] && dimDef.default) {
+        result[dimName] = dimDef.default;
+      }
+    }
+    return result;
+  }
+  /**
+   * Apply auto-filled variables (timestamp, templateVersion)
+   *
+   * @param variables - User-provided variables
+   * @param config - Matrix configuration
+   * @returns Variables with auto-filled values
+   */
+  applyAutoVariables(variables, config) {
+    const result = { ...variables };
+    for (const [varName, varDef] of Object.entries(config.variables)) {
+      if (varDef.auto) {
+        if (varName === "timestamp") {
+          result[varName] = (/* @__PURE__ */ new Date()).toISOString();
+        } else if (varName === "templateVersion" && varDef.value) {
+          result[varName] = varDef.value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Determine which template file to use based on quality tier
+   *
+   * @param qualityTier - Quality tier (basic, standard, enterprise)
+   * @param config - Matrix configuration
+   * @returns Template definition
+   * @throws Error if template not found
+   */
+  selectTemplate(qualityTier, config) {
+    const template = config.templates[qualityTier];
+    if (!template) {
+      throw new Error(`No template found for quality tier: ${qualityTier}`);
+    }
+    return template;
+  }
+  /**
+   * Read and compile template file
+   *
+   * @param templateDir - Template directory path
+   * @param templateFile - Template filename
+   * @returns Compiled Handlebars template
+   */
+  async compileTemplate(templateDir, templateFile) {
+    const templatePath = path2.join(templateDir, templateFile);
+    try {
+      const content = await fs2.readFile(templatePath, "utf-8");
+      return this.handlebars.compile(content);
+    } catch (error) {
+      throw new Error(`Failed to read template ${templateFile}: ${error.message}`);
+    }
+  }
+  /**
+   * Generate code from template
+   *
+   * @param genConfig - Generation configuration
+   * @returns Generation result with all files
+   */
+  async generate(genConfig) {
+    try {
+      const config = await this.loadConfig(genConfig.templateDir);
+      const dimensions = this.applyDimensionDefaults(genConfig.dimensions, config);
+      this.validateDimensions(dimensions, config);
+      const variables = this.applyAutoVariables(genConfig.variables, config);
+      this.validateVariables(variables, config);
+      const qualityTier = dimensions.qualityTier || "enterprise";
+      const template = this.selectTemplate(qualityTier, config);
+      const context = {
+        ...variables,
+        ...dimensions
+      };
+      const componentTemplate = await this.compileTemplate(
+        genConfig.templateDir,
+        template.file
+      );
+      const componentContent = componentTemplate(context);
+      const files = [];
+      const componentOutputDef = config.output.component;
+      const componentFilename = this.handlebars.compile(componentOutputDef.pattern)(context);
+      const componentPath = path2.join(
+        genConfig.outputDir || componentOutputDef.path,
+        componentFilename
+      );
+      files.push({
+        type: "component",
+        path: componentPath,
+        content: componentContent,
+        template: template.file
+      });
+      if (config.templates.types) {
+        const typesTemplate = await this.compileTemplate(
+          genConfig.templateDir,
+          config.templates.types.file
+        );
+        const typesContent = typesTemplate(context);
+        const typesOutputDef = config.output.types;
+        const typesFilename = this.handlebars.compile(typesOutputDef.pattern)(context);
+        const typesPath = path2.join(
+          genConfig.outputDir || typesOutputDef.path,
+          typesFilename
+        );
+        files.push({
+          type: "types",
+          path: typesPath,
+          content: typesContent,
+          template: config.templates.types.file
+        });
+      }
+      if (config.templates.test) {
+        const testTemplate = await this.compileTemplate(
+          genConfig.templateDir,
+          config.templates.test.file
+        );
+        const testContent = testTemplate(context);
+        const testOutputDef = config.output.test;
+        const testFilename = this.handlebars.compile(testOutputDef.pattern)(context);
+        const testPath = path2.join(
+          genConfig.outputDir || testOutputDef.path,
+          testFilename
+        );
+        files.push({
+          type: "test",
+          path: testPath,
+          content: testContent,
+          template: config.templates.test.file
+        });
+      }
+      return {
+        success: true,
+        files,
+        config,
+        metadata: {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          dimensions,
+          variables
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        files: [],
+        error: error.message,
+        config: {},
+        metadata: {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          dimensions: genConfig.dimensions,
+          variables: genConfig.variables
+        }
+      };
+    }
+  }
+  /**
+   * Write generated files to disk
+   *
+   * @param result - Generation result
+   * @returns Array of written file paths
+   */
+  async writeFiles(result) {
+    if (!result.success) {
+      throw new Error(`Cannot write files: ${result.error}`);
+    }
+    const writtenPaths = [];
+    for (const file of result.files) {
+      const dir = path2.dirname(file.path);
+      await fs2.mkdir(dir, { recursive: true });
+      await fs2.writeFile(file.path, file.content, "utf-8");
+      writtenPaths.push(file.path);
+    }
+    return writtenPaths;
+  }
+};
+
+// src/generators/section-generator.ts
+var SectionGenerator = class {
+  engine;
+  templateDir;
+  constructor(templateDir) {
+    this.engine = new MatrixEngine();
+    this.templateDir = templateDir || path3.join(process.cwd(), ".claude", "templates", "settings-section");
+  }
+  /**
+   * Generate settings section component
+   *
+   * @param options - Section generation options
+   * @returns Generation result
+   */
+  async generate(options) {
+    const dimensions = {
+      sectionType: options.sectionType,
+      dataPattern: options.dataPattern || "global-inheritance",
+      uiComplexity: options.uiComplexity || "medium",
+      qualityTier: options.qualityTier || "enterprise",
+      framework: options.framework || "react"
+    };
+    const variables = {
+      SectionName: options.sectionName,
+      SectionTitle: options.sectionTitle,
+      Icon: options.icon,
+      DataType: options.dataType,
+      apiMethod: options.apiMethod,
+      saveMethod: options.saveMethod,
+      sectionName: this.toKebabCase(options.sectionName),
+      ...options.additionalVariables
+    };
+    const genConfig = {
+      templateDir: this.templateDir,
+      dimensions,
+      variables,
+      outputDir: options.outputDir
+    };
+    return await this.engine.generate(genConfig);
+  }
+  /**
+   * Write generated files to disk
+   *
+   * @param result - Generation result
+   * @returns Array of written file paths
+   */
+  async write(result) {
+    return await this.engine.writeFiles(result);
+  }
+  /**
+   * Convert PascalCase to kebab-case
+   *
+   * @param str - PascalCase string
+   * @returns kebab-case string
+   *
+   * @example
+   * ```typescript
+   * toKebabCase('AIProviderSettings') // 'ai-provider-settings'
+   * ```
+   */
+  toKebabCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+  }
+};
+
+// src/commands/section-generate.ts
+var sectionGenerateCommand = new import_commander4.Command("add:section").alias("section").description("Add/Generate section using Orchestrator (50 sections, composition-based)").argument("<section>", "Section ID (e.g., hero-centered, pricing-cards)").option(
+  "-s, --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(
+  "-o, --output <path>",
+  "Output file path"
+).action(async (sectionId, options) => {
+  const spinner = (0, import_ora3.default)("Generating section...").start();
+  try {
+    const generator = new SectionGenerator();
+    const result = await generator.generate({
+      sectionId,
+      designSystem: options.designSystem,
+      tier: options.tier
+    });
+    if (!result.success) {
+      spinner.fail(import_chalk3.default.red("Section generation failed"));
+      result.errors.forEach((error) => {
+        console.error(import_chalk3.default.gray(`  \u2022 ${error}`));
+      });
+      process.exit(1);
+    }
+    if (options.output) {
+      await generator.writeToFile(options.output, result.composedCode);
+      spinner.succeed(import_chalk3.default.green(`Generated ${result.metadata.sectionId} \u2192 ${options.output}`));
+    } else {
+      spinner.succeed(import_chalk3.default.green(`Generated ${result.metadata.sectionId}`));
+      console.log(result.composedCode);
+    }
+    console.log(import_chalk3.default.cyan("\nSection Info:"));
+    console.log(`  ${import_chalk3.default.gray("ID:")} ${result.metadata.sectionId}`);
+    console.log(`  ${import_chalk3.default.gray("Type:")} ${result.metadata.sectionType}`);
+    console.log(`  ${import_chalk3.default.gray("Tier:")} ${result.metadata.tier}`);
+    console.log(`  ${import_chalk3.default.gray("Design System:")} ${result.metadata.designSystem}`);
+    console.log(`  ${import_chalk3.default.gray("Components:")} ${result.metadata.componentsGenerated}`);
+    console.log(`  ${import_chalk3.default.gray("Lines of Code:")} ${result.metadata.totalLinesOfCode}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(import_chalk3.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/page-generate.ts
+var import_commander5 = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+var import_ora4 = __toESM(require("ora"));
+
+// src/generators/page-generator.ts
+var path4 = __toESM(require("path"));
+var PageGenerator = class {
+  engine;
+  templateDir;
+  constructor(templateDir) {
+    this.engine = new MatrixEngine();
+    this.templateDir = templateDir || path4.join(process.cwd(), ".claude", "templates", "page");
+  }
+  /**
+   * Generate page component
+   *
+   * @param options - Page generation options
+   * @returns Generation result
+   */
+  async generate(options) {
+    const dimensions = {
+      pageType: options.pageType,
+      qualityTier: options.qualityTier || "enterprise",
+      framework: options.framework || "react"
+    };
+    const variables = {
+      PageName: options.pageName,
+      PageTitle: options.pageTitle,
+      PageDescription: options.pageDescription || "",
+      pageName: this.toKebabCase(options.pageName),
+      sectionsArray: JSON.stringify(options.sections || []),
+      ...options.additionalVariables
+    };
+    const genConfig = {
+      templateDir: this.templateDir,
+      dimensions,
+      variables,
+      outputDir: options.outputDir
+    };
+    return await this.engine.generate(genConfig);
+  }
+  /**
+   * Write generated files to disk
+   *
+   * @param result - Generation result
+   * @returns Array of written file paths
+   */
+  async write(result) {
+    return await this.engine.writeFiles(result);
+  }
+  /**
+   * Convert PascalCase to kebab-case
+   *
+   * @param str - PascalCase string
+   * @returns kebab-case string
+   */
+  toKebabCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+  }
+};
+
+// src/commands/page-generate.ts
+var pageGenerateCommand = new import_commander5.Command("add:page").alias("page").description("Add/Generate full page (multi-section composition)").argument("<page>", "Page ID (e.g., landing, dashboard, auth)").option(
+  "-s, --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(
+  "-o, --output <path>",
+  "Output file path"
+).action(async (pageId, options) => {
+  const spinner = (0, import_ora4.default)("Generating page...").start();
+  try {
+    const generator = new PageGenerator();
+    const result = await generator.generate({
+      pageId,
+      designSystem: options.designSystem,
+      tier: options.tier
+    });
+    if (!result.success) {
+      spinner.fail(import_chalk4.default.red("Page generation failed"));
+      result.errors.forEach((error) => {
+        console.error(import_chalk4.default.gray(`  \u2022 ${error}`));
+      });
+      process.exit(1);
+    }
+    if (options.output) {
+      await generator.writeToFile(options.output, result.composedCode);
+      spinner.succeed(import_chalk4.default.green(`Generated ${result.metadata.pageId} \u2192 ${options.output}`));
+    } else {
+      spinner.succeed(import_chalk4.default.green(`Generated ${result.metadata.pageId}`));
+      console.log(result.composedCode);
+    }
+    console.log(import_chalk4.default.cyan("\nPage Info:"));
+    console.log(`  ${import_chalk4.default.gray("ID:")} ${result.metadata.pageId}`);
+    console.log(`  ${import_chalk4.default.gray("Type:")} ${result.metadata.pageType}`);
+    console.log(`  ${import_chalk4.default.gray("Tier:")} ${result.metadata.tier}`);
+    console.log(`  ${import_chalk4.default.gray("Design System:")} ${result.metadata.designSystem}`);
+    console.log(`  ${import_chalk4.default.gray("Sections:")} ${result.metadata.sectionsGenerated}`);
+    console.log(`  ${import_chalk4.default.gray("Components:")} ${result.metadata.componentsGenerated}`);
+    console.log(`  ${import_chalk4.default.gray("Lines of Code:")} ${result.metadata.totalLinesOfCode}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(import_chalk4.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+
 // src/index.ts
 var componentCount = 169;
+var sectionCount = 50;
 var designSystemCount = 12;
 var tierCount = 3;
-var y = import_chalk3.default.hex("#fcb800");
+var y = import_chalk5.default.hex("#fcb800");
 var banner = `
 ${y.bold("\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557")}
 ${y.bold("\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D")}
@@ -1080,15 +1584,18 @@ ${y.bold("             \u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u2588\u
 ${y.bold("              \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557              ")}
 ${y.bold("               \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D              ")}
 
-${y("                 happy together")} ${import_chalk3.default.white("\u2022 v2.2.0")}
+${y("                 happy together")} ${import_chalk5.default.white("\u2022 v2.3.0")}
 
-${import_chalk3.default.gray("    Production-ready code in seconds")}
+${import_chalk5.default.gray("    Production-ready code in seconds")}
+${import_chalk5.default.gray("           https://nikkory.com")}
 
-${y(`  ${componentCount} Components`)} ${import_chalk3.default.gray("\xD7")} ${y(`${designSystemCount} Design Systems`)} ${import_chalk3.default.gray("\xD7")} ${y(`${tierCount} Tiers`)} ${import_chalk3.default.gray("=")} ${import_chalk3.default.white.bold(`${componentCount * designSystemCount * tierCount}+ variations`)}
+${y(`  ${componentCount} Components`)} ${import_chalk5.default.gray("+")} ${y(`${sectionCount} Sections`)} ${import_chalk5.default.gray("\xD7")} ${y(`${designSystemCount} Systems`)} ${import_chalk5.default.gray("\xD7")} ${y(`${tierCount} Tiers`)}
 `;
-var program = new import_commander4.Command();
-program.name("nikkory-vibe").description("Nikkory Vibe - Production-ready code in seconds").version("2.2.0").addHelpText("before", banner);
+var program = new import_commander6.Command();
+program.name("nikkory-vibe").description("Nikkory Vibe - Production-ready code in seconds").version("2.3.0").addHelpText("before", banner);
 program.addCommand(matrixGenerateCommand);
+program.addCommand(sectionGenerateCommand);
+program.addCommand(pageGenerateCommand);
 program.addCommand(listCommand);
 program.addCommand(initCommand);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nikkory/vibe-cli",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "CLI tool for Nikkory Vibe - Generate production-ready code in seconds",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",