@vibe-validate/config 0.9.0

package/README.md

@@ -0,0 +1,235 @@
+# @vibe-validate/config
+
+TypeScript-first configuration system for vibe-validate with Zod schema validation and framework presets.
+
+## Features
+
+- ✅ **TypeScript-First**: Full type safety with IDE autocomplete
+- ✅ **Zod Validation**: Runtime schema validation with detailed error messages
+- ✅ **Framework Presets**: Pre-configured setups for common TypeScript project types
+- ✅ **Preset Override**: Extend and customize presets easily
+- ✅ **Multiple File Formats**: Support for `.ts`, `.mts`, `.js`, `.mjs`, and `.json` configs
+- ✅ **Config Extension**: Extend other config files
+
+## Installation
+
+```bash
+npm install @vibe-validate/config
+```
+
+## Usage
+
+### Basic Configuration
+
+Create a `vibe-validate.config.ts` file in your project root:
+
+```typescript
+import { defineConfig } from '@vibe-validate/config';
+
+export default defineConfig({
+  validation: {
+    phases: [
+      {
+        name: 'Type Checking',
+        parallel: false,
+        steps: [
+          { name: 'TypeScript', command: 'tsc --noEmit' }
+        ]
+      }
+    ]
+  }
+});
+```
+
+### Using a Preset
+
+Start with a framework-specific preset:
+
+```typescript
+import { defineConfig } from '@vibe-validate/config';
+
+export default defineConfig({
+  preset: 'typescript-nodejs',
+  // Optional: Override or extend preset configuration
+  validation: {
+    phases: [
+      // Add custom phases or override preset phases
+    ]
+  }
+});
+```
+
+### Available Presets
+
+#### `typescript-library`
+
+Default preset for TypeScript npm libraries:
+- TypeScript type checking
+- ESLint linting
+- Unit tests
+- Build validation
+
+#### `typescript-nodejs`
+
+Preset for Node.js applications:
+- TypeScript type checking + build
+- ESLint linting
+- Unit + integration tests
+
+#### `typescript-react`
+
+Preset for React applications:
+- TypeScript type checking
+- ESLint linting
+- Unit + component tests
+- Production build (10min timeout)
+
+## Configuration Schema
+
+### Full Configuration Example
+
+```typescript
+import { defineConfig } from '@vibe-validate/config';
+
+export default defineConfig({
+  validation: {
+    phases: [
+      {
+        name: 'Phase 1: Pre-Qualification',
+        parallel: true,
+        timeout: 300000, // 5 minutes (default)
+        failFast: true,  // Stop on first error (default)
+        steps: [
+          {
+            name: 'TypeScript',
+            command: 'tsc --noEmit',
+            timeout: 60000, // Step-specific timeout
+            continueOnError: false,
+            env: { NODE_ENV: 'test' },
+            cwd: './packages/core'
+          }
+        ]
+      }
+    ],
+    caching: {
+      strategy: 'git-tree-hash', // 'git-tree-hash' | 'timestamp' | 'disabled'
+      enabled: true,
+      statePath: '.vibe-validate-state.yaml'
+    }
+  },
+  git: {
+    mainBranch: 'main',
+    autoSync: false,
+    warnIfBehind: true
+  },
+  output: {
+    format: 'auto', // 'auto' | 'human' | 'yaml' | 'json'
+    showProgress: true,
+    verbose: false,
+    noColor: false
+  }
+});
+```
+
+### Config Extension
+
+Extend another config file:
+
+```typescript
+import { defineConfig } from '@vibe-validate/config';
+
+export default defineConfig({
+  extends: '../base-config.ts',
+  validation: {
+    // Overrides merged with base config
+  }
+});
+```
+
+## API
+
+### `defineConfig(config)`
+
+Type-safe configuration helper providing IDE autocomplete and validation.
+
+### `getPreset(name)`
+
+Get a preset by name:
+
+```typescript
+import { getPreset } from '@vibe-validate/config';
+
+const preset = getPreset('typescript-library');
+```
+
+### `listPresets()`
+
+List all available presets:
+
+```typescript
+import { listPresets } from '@vibe-validate/config';
+
+console.log(listPresets()); // ['typescript-library', 'typescript-nodejs', 'typescript-react']
+```
+
+### `loadConfigFromFile(path)`
+
+Load and validate configuration from a file:
+
+```typescript
+import { loadConfigFromFile } from '@vibe-validate/config';
+
+const config = await loadConfigFromFile('./vibe-validate.config.ts');
+```
+
+### `findAndLoadConfig(cwd?)`
+
+Find and load configuration from working directory:
+
+```typescript
+import { findAndLoadConfig } from '@vibe-validate/config';
+
+const config = await findAndLoadConfig(); // Searches for config in cwd
+```
+
+### `loadConfigWithFallback(cwd?)`
+
+Load configuration with fallback to default preset:
+
+```typescript
+import { loadConfigWithFallback } from '@vibe-validate/config';
+
+const config = await loadConfigWithFallback(); // Uses typescript-library preset if no config found
+```
+
+## Configuration File Discovery
+
+The loader searches for config files in this order:
+
+1. `vibe-validate.config.ts`
+2. `vibe-validate.config.mts`
+3. `vibe-validate.config.js`
+4. `vibe-validate.config.mjs`
+5. `vibe-validate.config.json`
+6. `.vibe-validate.json`
+
+## Validation
+
+Zod schemas provide runtime validation with detailed error messages:
+
+```typescript
+import { validateConfig, safeValidateConfig } from '@vibe-validate/config';
+
+// Throws ZodError on invalid config
+const config = validateConfig(rawConfig);
+
+// Returns { success, data?, errors? }
+const result = safeValidateConfig(rawConfig);
+if (!result.success) {
+  console.error(result.errors);
+}
+```
+
+## License
+
+MIT

package/dist/define-config.d.ts

@@ -0,0 +1,49 @@
+/**
+ * TypeScript-First Config Helper
+ *
+ * Provides a type-safe way to define vibe-validate configuration
+ * with full IDE autocomplete and validation.
+ */
+import type { VibeValidateConfig } from './schema.js';
+/**
+ * Define a vibe-validate configuration
+ *
+ * This is a type-safe helper that provides IDE autocomplete and validation.
+ * It performs no runtime operations - just returns the config object.
+ *
+ * @param config - Configuration object
+ * @returns The same configuration object (type-checked)
+ *
+ * @example
+ * ```typescript
+ * // vibe-validate.config.ts
+ * import { defineConfig } from '@vibe-validate/config';
+ *
+ * export default defineConfig({
+ *   validation: {
+ *     phases: [
+ *       {
+ *         name: 'Type Checking',
+ *         parallel: false,
+ *         steps: [
+ *           { name: 'TypeScript', command: 'tsc --noEmit' }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * });
+ * ```
+ */
+export declare function defineConfig(config: VibeValidateConfig): VibeValidateConfig;
+/**
+ * Deep merge two configuration objects
+ *
+ * Used for preset overrides - allows users to extend a preset
+ * while overriding specific values.
+ *
+ * @param base - Base configuration (preset)
+ * @param override - Override configuration (user customizations)
+ * @returns Merged configuration
+ */
+export declare function mergeConfig(base: VibeValidateConfig, override: Partial<VibeValidateConfig>): VibeValidateConfig;
+//# sourceMappingURL=define-config.d.ts.map

package/dist/define-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-config.d.ts","sourceRoot":"","sources":["../src/define-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAE3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,GACpC,kBAAkB,CAuBpB"}

package/dist/define-config.js

@@ -0,0 +1,72 @@
+/**
+ * TypeScript-First Config Helper
+ *
+ * Provides a type-safe way to define vibe-validate configuration
+ * with full IDE autocomplete and validation.
+ */
+/**
+ * Define a vibe-validate configuration
+ *
+ * This is a type-safe helper that provides IDE autocomplete and validation.
+ * It performs no runtime operations - just returns the config object.
+ *
+ * @param config - Configuration object
+ * @returns The same configuration object (type-checked)
+ *
+ * @example
+ * ```typescript
+ * // vibe-validate.config.ts
+ * import { defineConfig } from '@vibe-validate/config';
+ *
+ * export default defineConfig({
+ *   validation: {
+ *     phases: [
+ *       {
+ *         name: 'Type Checking',
+ *         parallel: false,
+ *         steps: [
+ *           { name: 'TypeScript', command: 'tsc --noEmit' }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * });
+ * ```
+ */
+export function defineConfig(config) {
+    return config;
+}
+/**
+ * Deep merge two configuration objects
+ *
+ * Used for preset overrides - allows users to extend a preset
+ * while overriding specific values.
+ *
+ * @param base - Base configuration (preset)
+ * @param override - Override configuration (user customizations)
+ * @returns Merged configuration
+ */
+export function mergeConfig(base, override) {
+    return {
+        ...base,
+        validation: {
+            ...base.validation,
+            ...(override.validation || {}),
+            phases: override.validation?.phases || base.validation.phases,
+            caching: {
+                ...base.validation.caching,
+                ...(override.validation?.caching || {}),
+            },
+        },
+        git: {
+            ...base.git,
+            ...(override.git || {}),
+        },
+        output: {
+            ...base.output,
+            ...(override.output || {}),
+        },
+        preset: override.preset || base.preset,
+        extends: override.extends || base.extends,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @vibe-validate/config
+ *
+ * Configuration system for vibe-validate with TypeScript-first design,
+ * Zod schema validation, and framework presets.
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from '@vibe-validate/config';
+ *
+ * export default defineConfig({
+ *   validation: {
+ *     phases: [
+ *       {
+ *         name: 'Type Checking',
+ *         parallel: false,
+ *         steps: [
+ *           { name: 'TypeScript', command: 'tsc --noEmit' }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * });
+ * ```
+ *
+ * @example Using a preset
+ * ```typescript
+ * import { defineConfig } from '@vibe-validate/config';
+ *
+ * export default defineConfig({
+ *   preset: 'typescript-nodejs',
+ *   validation: {
+ *     phases: [
+ *       // Override or extend preset phases
+ *     ]
+ *   }
+ * });
+ * ```
+ */
+export { type ValidationStep, type ValidationPhase, type ValidationConfig, type CachingStrategy, type OutputFormat, type GitConfig, type OutputConfig, type VibeValidateConfig, ValidationStepSchema, ValidationPhaseSchema, ValidationConfigSchema, CachingStrategySchema, OutputFormatSchema, GitConfigSchema, OutputConfigSchema, VibeValidateConfigSchema, validateConfig, safeValidateConfig, } from './schema.js';
+export { defineConfig, mergeConfig } from './define-config.js';
+export { typescriptLibraryPreset, typescriptNodejsPreset, typescriptReactPreset, PRESETS, getPreset, listPresets, } from './presets/index.js';
+export { CONFIG_FILE_NAMES, loadConfigFromFile, findAndLoadConfig, loadConfigWithFallback, } from './loader.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,wBAAwB,EACxB,cAAc,EACd,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,OAAO,EACP,SAAS,EACT,WAAW,GACZ,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,47 @@
+/**
+ * @vibe-validate/config
+ *
+ * Configuration system for vibe-validate with TypeScript-first design,
+ * Zod schema validation, and framework presets.
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from '@vibe-validate/config';
+ *
+ * export default defineConfig({
+ *   validation: {
+ *     phases: [
+ *       {
+ *         name: 'Type Checking',
+ *         parallel: false,
+ *         steps: [
+ *           { name: 'TypeScript', command: 'tsc --noEmit' }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * });
+ * ```
+ *
+ * @example Using a preset
+ * ```typescript
+ * import { defineConfig } from '@vibe-validate/config';
+ *
+ * export default defineConfig({
+ *   preset: 'typescript-nodejs',
+ *   validation: {
+ *     phases: [
+ *       // Override or extend preset phases
+ *     ]
+ *   }
+ * });
+ * ```
+ */
+// Core schema types and validation
+export { ValidationStepSchema, ValidationPhaseSchema, ValidationConfigSchema, CachingStrategySchema, OutputFormatSchema, GitConfigSchema, OutputConfigSchema, VibeValidateConfigSchema, validateConfig, safeValidateConfig, } from './schema.js';
+// Config definition helper
+export { defineConfig, mergeConfig } from './define-config.js';
+// Presets
+export { typescriptLibraryPreset, typescriptNodejsPreset, typescriptReactPreset, PRESETS, getPreset, listPresets, } from './presets/index.js';
+// Config loading
+export { CONFIG_FILE_NAMES, loadConfigFromFile, findAndLoadConfig, loadConfigWithFallback, } from './loader.js';

package/dist/loader.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Configuration Loader
+ *
+ * Loads and resolves vibe-validate configuration from files,
+ * including preset resolution and config extension.
+ */
+import { type VibeValidateConfig } from './schema.js';
+/**
+ * Configuration file names to search for (in order)
+ */
+export declare const CONFIG_FILE_NAMES: string[];
+/**
+ * Load configuration from a file path
+ *
+ * @param configPath - Absolute path to config file
+ * @returns Loaded and validated configuration
+ * @throws Error if file cannot be loaded or is invalid
+ */
+export declare function loadConfigFromFile(configPath: string): Promise<VibeValidateConfig>;
+/**
+ * Find and load configuration from current working directory
+ *
+ * Searches for config files in order and loads the first one found.
+ *
+ * @param cwd - Working directory to search (default: process.cwd())
+ * @returns Loaded configuration or undefined if no config found
+ */
+export declare function findAndLoadConfig(cwd?: string): Promise<VibeValidateConfig | undefined>;
+/**
+ * Load configuration with fallback to default preset
+ *
+ * Searches for config file, falls back to typescript-library preset if not found.
+ *
+ * @param cwd - Working directory (default: process.cwd())
+ * @returns Configuration (user config or default preset)
+ */
+export declare function loadConfigWithFallback(cwd?: string): Promise<VibeValidateConfig>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItE;;GAEG;AACH,eAAO,MAAM,iBAAiB,UAO7B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,kBAAkB,CAAC,CAiC7B;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAazC;AA0DD;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,kBAAkB,CAAC,CAc7B"}

package/dist/loader.js

@@ -0,0 +1,147 @@
+/**
+ * Configuration Loader
+ *
+ * Loads and resolves vibe-validate configuration from files,
+ * including preset resolution and config extension.
+ */
+import { resolve, dirname } from 'path';
+import { readFileSync } from 'fs';
+import { pathToFileURL } from 'url';
+import { validateConfig } from './schema.js';
+import { mergeConfig } from './define-config.js';
+import { getPreset } from './presets/index.js';
+/**
+ * Configuration file names to search for (in order)
+ */
+export const CONFIG_FILE_NAMES = [
+    'vibe-validate.config.ts',
+    'vibe-validate.config.mts',
+    'vibe-validate.config.js',
+    'vibe-validate.config.mjs',
+    'vibe-validate.config.json',
+    '.vibe-validate.json',
+];
+/**
+ * Load configuration from a file path
+ *
+ * @param configPath - Absolute path to config file
+ * @returns Loaded and validated configuration
+ * @throws Error if file cannot be loaded or is invalid
+ */
+export async function loadConfigFromFile(configPath) {
+    const absolutePath = resolve(configPath);
+    // JSON files
+    if (absolutePath.endsWith('.json')) {
+        const content = readFileSync(absolutePath, 'utf-8');
+        const raw = JSON.parse(content);
+        return await resolveConfig(raw, dirname(absolutePath));
+    }
+    // TypeScript files - use tsx for loading
+    if (absolutePath.endsWith('.ts') || absolutePath.endsWith('.mts')) {
+        // Use tsx to load TypeScript files
+        const { register } = await import('tsx/esm/api');
+        const unregister = register();
+        try {
+            // Add cache-busting timestamp to force fresh load
+            const fileUrl = pathToFileURL(absolutePath).href + '?t=' + Date.now();
+            const module = await import(fileUrl);
+            const raw = module.default || module;
+            return await resolveConfig(raw, dirname(absolutePath));
+        }
+        finally {
+            unregister();
+        }
+    }
+    // JavaScript files (ES modules)
+    const fileUrl = pathToFileURL(absolutePath).href;
+    const module = await import(fileUrl);
+    const raw = module.default || module;
+    return await resolveConfig(raw, dirname(absolutePath));
+}
+/**
+ * Find and load configuration from current working directory
+ *
+ * Searches for config files in order and loads the first one found.
+ *
+ * @param cwd - Working directory to search (default: process.cwd())
+ * @returns Loaded configuration or undefined if no config found
+ */
+export async function findAndLoadConfig(cwd = process.cwd()) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+        const configPath = resolve(cwd, fileName);
+        try {
+            return await loadConfigFromFile(configPath);
+        }
+        catch (err) {
+            // File doesn't exist or can't be loaded - try next
+            continue;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve configuration with preset and extends support
+ *
+ * @param raw - Raw configuration object
+ * @param basePath - Base directory for resolving extends paths
+ * @returns Resolved and validated configuration
+ */
+async function resolveConfig(raw, basePath) {
+    if (typeof raw !== 'object' || raw === null) {
+        throw new Error('Configuration must be an object');
+    }
+    const config = raw;
+    // Step 1: Resolve preset if specified
+    let baseConfig;
+    if (config.preset) {
+        baseConfig = getPreset(config.preset);
+        if (!baseConfig) {
+            throw new Error(`Unknown preset: ${config.preset}`);
+        }
+    }
+    // Step 2: Resolve extends if specified
+    if (config.extends) {
+        // Check if extends is a preset name or a file path
+        const extendedConfig = getPreset(config.extends);
+        if (extendedConfig) {
+            // It's a preset name
+            baseConfig = baseConfig
+                ? mergeConfig(baseConfig, extendedConfig)
+                : extendedConfig;
+        }
+        else {
+            // It's a file path - resolve relative to basePath
+            const extendsPath = resolve(basePath, config.extends);
+            const fileConfig = await loadConfigFromFile(extendsPath);
+            baseConfig = baseConfig
+                ? mergeConfig(baseConfig, fileConfig)
+                : fileConfig;
+        }
+    }
+    // Step 3: Merge user config with base
+    const finalConfig = baseConfig
+        ? mergeConfig(baseConfig, config)
+        : config;
+    // Step 4: Validate final configuration
+    return validateConfig(finalConfig);
+}
+/**
+ * Load configuration with fallback to default preset
+ *
+ * Searches for config file, falls back to typescript-library preset if not found.
+ *
+ * @param cwd - Working directory (default: process.cwd())
+ * @returns Configuration (user config or default preset)
+ */
+export async function loadConfigWithFallback(cwd = process.cwd()) {
+    const config = await findAndLoadConfig(cwd);
+    if (config) {
+        return config;
+    }
+    // Fallback to default preset
+    const defaultPreset = getPreset('typescript-library');
+    if (!defaultPreset) {
+        throw new Error('Default preset not found');
+    }
+    return defaultPreset;
+}

package/dist/presets/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Built-in Framework Presets
+ *
+ * Pre-configured validation setups for common TypeScript project types.
+ */
+export { typescriptLibraryPreset } from './typescript-library.js';
+export { typescriptNodejsPreset } from './typescript-nodejs.js';
+export { typescriptReactPreset } from './typescript-react.js';
+import type { VibeValidateConfig } from '../schema.js';
+/**
+ * Map of preset name to configuration
+ */
+export declare const PRESETS: Record<string, VibeValidateConfig>;
+/**
+ * Get a preset by name
+ *
+ * @param name - Preset name
+ * @returns Preset configuration or undefined if not found
+ */
+export declare function getPreset(name: string): VibeValidateConfig | undefined;
+/**
+ * List all available preset names
+ *
+ * @returns Array of preset names
+ */
+export declare function listPresets(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/presets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/presets/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAKvD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAItD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEtE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,MAAM,EAAE,CAEtC"}