@nikkory/vibe-engine 4.0.0

package/dist/utils/CodeUtils.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Code Generation Utilities
+ *
+ * Helper functions for generating TypeScript/React code.
+ *
+ * Powered by Nikkory
+ */
+/**
+ * Generate import statements
+ *
+ * @example
+ * generateImports(['react', 'clsx', 'cva'])
+ * // import React from 'react';
+ * // import { clsx } from 'clsx';
+ * // import { cva, type VariantProps } from 'class-variance-authority';
+ */
+export declare function generateImports(dependencies: string[]): string;
+/**
+ * Generate TypeScript interface
+ *
+ * @example
+ * generateInterface('Button', {
+ *   variant: "'filled' | 'outlined'",
+ *   size: "'sm' | 'md' | 'lg'",
+ *   disabled: 'boolean',
+ * })
+ */
+export declare function generateInterface(name: string, props: Record<string, string>, options?: {
+    extends?: string;
+    description?: string;
+    optional?: string[];
+}): string;
+/**
+ * Generate TypeScript type alias
+ */
+export declare function generateType(name: string, type: string): string;
+/**
+ * Generate union type from array
+ *
+ * @example
+ * generateUnionType(['sm', 'md', 'lg']) // "'sm' | 'md' | 'lg'"
+ */
+export declare function generateUnionType(values: string[]): string;
+/**
+ * Generate JSDoc comment
+ */
+export declare function generateJSDoc(options: {
+    description?: string;
+    params?: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }>;
+    returns?: {
+        type: string;
+        description: string;
+    };
+    example?: string;
+    since?: string;
+    deprecated?: string;
+}): string;
+/**
+ * Generate React component skeleton
+ */
+export declare function generateComponentSkeleton(name: string, options?: {
+    withForwardRef?: boolean;
+    withMemo?: boolean;
+    withDisplayName?: boolean;
+}): string;
+/**
+ * Generate file header comment
+ */
+export declare function generateFileHeader(options: {
+    name: string;
+    description?: string;
+    designSystem?: string;
+    tier?: string;
+}): string;
+/**
+ * Generate component file path
+ *
+ * @example
+ * generateComponentPath('button', 'material-design', 'standard')
+ * // 'components/button/material-design/standard.tsx'
+ */
+export declare function generateComponentPath(component: string, designSystem: string, tier: string): string;
+/**
+ * Generate component name
+ *
+ * @example
+ * generateComponentName('button', 'material-design', 'standard')
+ * // 'MaterialButtonStandard'
+ */
+export declare function generateComponentName(component: string, designSystem: string, tier: string): string;
+/**
+ * Indent code by specified number of spaces
+ */
+export declare function indent(code: string, spaces?: number): string;
+/**
+ * Remove extra blank lines
+ */
+export declare function normalizeWhitespace(code: string): string;
+//# sourceMappingURL=CodeUtils.d.ts.map

package/dist/utils/GenerateComponentValidator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generate Component Validator
+ *
+ * Validates GenerateComponentDto before processing.
+ *
+ * Powered by Nikkory
+ */
+import { Result } from '../types/Result';
+import { ValidationError } from './errors';
+import type { GenerateComponentDto } from '../types';
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+}
+/**
+ * Validate GenerateComponentDto
+ */
+export declare function validateGenerateComponentDto(dto: GenerateComponentDto): Result<void, ValidationError>;
+/**
+ * Get list of valid templates
+ */
+export declare function getValidTemplates(): string[];
+/**
+ * Get list of valid design systems
+ */
+export declare function getValidDesignSystems(): string[];
+/**
+ * Get list of valid tiers
+ */
+export declare function getValidTiers(): string[];
+/**
+ * Get list of valid frameworks
+ */
+export declare function getValidFrameworks(): string[];
+//# sourceMappingURL=GenerateComponentValidator.d.ts.map

package/dist/utils/Logger.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Logger Utility
+ *
+ * Logging abstraction for consistent logging across the application.
+ *
+ * Powered by Nikkory
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: Date;
+    context?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ILogger {
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    setContext(context: string): void;
+    setLevel(level: LogLevel): void;
+}
+/**
+ * Console Logger Implementation
+ */
+export declare class ConsoleLogger implements ILogger {
+    private context;
+    private level;
+    constructor(options?: {
+        context?: string;
+        level?: LogLevel;
+    });
+    setContext(context: string): void;
+    setLevel(level: LogLevel): void;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    private log;
+    private formatPrefix;
+}
+/**
+ * Silent Logger (for testing)
+ */
+export declare class SilentLogger implements ILogger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+    setContext(): void;
+    setLevel(): void;
+}
+/**
+ * Memory Logger (for testing - stores logs in memory)
+ */
+export declare class MemoryLogger implements ILogger {
+    private logs;
+    private context;
+    private level;
+    setContext(context: string): void;
+    setLevel(level: LogLevel): void;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    private addLog;
+    /**
+     * Get all logs
+     */
+    getLogs(): LogEntry[];
+    /**
+     * Get logs by level
+     */
+    getLogsByLevel(level: LogLevel): LogEntry[];
+    /**
+     * Clear all logs
+     */
+    clear(): void;
+    /**
+     * Check if any errors were logged
+     */
+    hasErrors(): boolean;
+    /**
+     * Check if any warnings were logged
+     */
+    hasWarnings(): boolean;
+}
+/**
+ * Create default logger
+ */
+export declare function createLogger(options?: {
+    context?: string;
+    level?: LogLevel;
+    silent?: boolean;
+}): ILogger;
+/**
+ * Default logger instance
+ */
+export declare const logger: ILogger;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/utils/StringUtils.d.ts

@@ -0,0 +1,120 @@
+/**
+ * String Utilities
+ *
+ * Common string manipulation functions.
+ *
+ * Powered by Nikkory
+ */
+/**
+ * Convert string to PascalCase
+ *
+ * @example
+ * toPascalCase('hello-world') // 'HelloWorld'
+ * toPascalCase('hello_world') // 'HelloWorld'
+ * toPascalCase('hello world') // 'HelloWorld'
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Convert string to camelCase
+ *
+ * @example
+ * toCamelCase('hello-world') // 'helloWorld'
+ * toCamelCase('HelloWorld') // 'helloWorld'
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Convert string to kebab-case
+ *
+ * @example
+ * toKebabCase('HelloWorld') // 'hello-world'
+ * toKebabCase('helloWorld') // 'hello-world'
+ */
+export declare function toKebabCase(str: string): string;
+/**
+ * Convert string to snake_case
+ *
+ * @example
+ * toSnakeCase('HelloWorld') // 'hello_world'
+ * toSnakeCase('hello-world') // 'hello_world'
+ */
+export declare function toSnakeCase(str: string): string;
+/**
+ * Convert string to CONSTANT_CASE
+ *
+ * @example
+ * toConstantCase('HelloWorld') // 'HELLO_WORLD'
+ */
+export declare function toConstantCase(str: string): string;
+/**
+ * Capitalize first letter
+ *
+ * @example
+ * capitalize('hello') // 'Hello'
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Uncapitalize first letter
+ *
+ * @example
+ * uncapitalize('Hello') // 'hello'
+ */
+export declare function uncapitalize(str: string): string;
+/**
+ * Check if string is PascalCase
+ */
+export declare function isPascalCase(str: string): boolean;
+/**
+ * Check if string is camelCase
+ */
+export declare function isCamelCase(str: string): boolean;
+/**
+ * Check if string is kebab-case
+ */
+export declare function isKebabCase(str: string): boolean;
+/**
+ * Check if string is snake_case
+ */
+export declare function isSnakeCase(str: string): boolean;
+/**
+ * Pluralize a word (simple version)
+ *
+ * @example
+ * pluralize('button') // 'buttons'
+ * pluralize('category') // 'categories'
+ */
+export declare function pluralize(word: string): string;
+/**
+ * Singularize a word (simple version)
+ *
+ * @example
+ * singularize('buttons') // 'button'
+ * singularize('categories') // 'category'
+ */
+export declare function singularize(word: string): string;
+/**
+ * Truncate string with ellipsis
+ *
+ * @example
+ * truncate('Hello World', 8) // 'Hello...'
+ */
+export declare function truncate(str: string, maxLength: number, suffix?: string): string;
+/**
+ * Escape HTML special characters
+ */
+export declare function escapeHtml(str: string): string;
+/**
+ * Escape string for use in template literals
+ */
+export declare function escapeTemplate(str: string): string;
+/**
+ * Generate random string
+ */
+export declare function randomString(length: number, charset?: string): string;
+/**
+ * Generate slug from string
+ *
+ * @example
+ * slugify('Hello World!') // 'hello-world'
+ */
+export declare function slugify(str: string): string;
+//# sourceMappingURL=StringUtils.d.ts.map

package/dist/utils/ValidationUtils.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Validation Utilities
+ *
+ * Input validation functions for security and data integrity.
+ *
+ * Powered by Nikkory
+ */
+import { Result } from '../types/Result';
+import { ValidationError } from './errors';
+/**
+ * Validate component name (PascalCase)
+ *
+ * Rules:
+ * - Must start with uppercase letter
+ * - Only alphanumeric characters
+ * - Max 100 characters
+ * - No reserved keywords
+ */
+export declare function validateComponentName(name: string): Result<void, ValidationError>;
+/**
+ * Validate file path
+ *
+ * Security checks:
+ * - No path traversal (..)
+ * - No absolute paths
+ * - Valid extension
+ * - No null bytes
+ */
+export declare function validateFilePath(path: string, allowedExtensions?: string[]): Result<void, ValidationError>;
+/**
+ * Validate design system name
+ */
+export declare function validateDesignSystem(designSystem: string): Result<void, ValidationError>;
+/**
+ * Validate tier
+ */
+export declare function validateTier(tier: string): Result<void, ValidationError>;
+/**
+ * Validate URL
+ *
+ * Security checks:
+ * - Must be http or https
+ * - No internal/private IPs
+ */
+export declare function validateUrl(url: string): Result<void, ValidationError>;
+/**
+ * Validate email
+ */
+export declare function validateEmail(email: string): Result<void, ValidationError>;
+/**
+ * Sanitize string input
+ *
+ * Removes potentially dangerous characters.
+ */
+export declare function sanitize(input: string): string;
+/**
+ * Sanitize for HTML output
+ */
+export declare function sanitizeHtml(input: string): string;
+/**
+ * Check if value is within allowed list
+ */
+export declare function isAllowedValue<T>(value: T, allowed: T[]): boolean;
+/**
+ * Validate object against schema (simple version)
+ */
+export declare function validateObject(obj: Record<string, unknown>, schema: Record<string, {
+    type: string;
+    required?: boolean;
+}>): Result<void, ValidationError>;
+//# sourceMappingURL=ValidationUtils.d.ts.map

package/dist/utils/errors/BaseError.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Base Error Class
+ *
+ * All custom errors extend this class.
+ * Provides stack trace, error codes, and metadata.
+ *
+ * Powered by Nikkory
+ */
+export declare abstract class BaseError extends Error {
+    readonly timestamp: Date;
+    readonly errorCode: string;
+    readonly metadata?: Record<string, unknown>;
+    constructor(message: string, errorCode: string, metadata?: Record<string, unknown>);
+    /**
+     * Serialize error to JSON
+     */
+    toJSON(): object;
+    /**
+     * Get user-friendly message
+     */
+    abstract getUserMessage(): string;
+}
+//# sourceMappingURL=BaseError.d.ts.map

package/dist/utils/errors/GenerationError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generation Error
+ *
+ * Thrown when code generation fails.
+ *
+ * Powered by Nikkory
+ */
+import { BaseError } from './BaseError';
+export declare class GenerationError extends BaseError {
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+    getUserMessage(): string;
+}
+//# sourceMappingURL=GenerationError.d.ts.map

package/dist/utils/errors/TemplateNotFoundError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Template Not Found Error
+ *
+ * Thrown when a requested template doesn't exist.
+ *
+ * Powered by Nikkory
+ */
+import { BaseError } from './BaseError';
+export declare class TemplateNotFoundError extends BaseError {
+    constructor(templateName: string);
+    getUserMessage(): string;
+}
+//# sourceMappingURL=TemplateNotFoundError.d.ts.map

package/dist/utils/errors/ValidationError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validation Error
+ *
+ * Thrown when input validation fails.
+ *
+ * Powered by Nikkory
+ */
+import { BaseError } from './BaseError';
+export declare class ValidationError extends BaseError {
+    constructor(message: string, metadata?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+//# sourceMappingURL=ValidationError.d.ts.map

package/dist/utils/errors/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Error Classes
+ *
+ * Centralized error handling for Nikkory Vibe.
+ *
+ * Powered by Nikkory
+ */
+export { BaseError } from './BaseError';
+export { ValidationError } from './ValidationError';
+export { GenerationError } from './GenerationError';
+export { TemplateNotFoundError } from './TemplateNotFoundError';
+//# sourceMappingURL=index.d.ts.map