@vibe-validate/config 0.9.0

package/dist/schema.d.ts

@@ -0,0 +1,580 @@
+/**
+ * Configuration Schema with Zod Validation
+ *
+ * TypeScript-first configuration system for vibe-validate.
+ * Provides runtime validation and type safety for all configuration options.
+ */
+import { z } from 'zod';
+/**
+ * Validation Step Schema
+ *
+ * Defines a single validation step (typecheck, lint, test, etc.)
+ */
+export declare const ValidationStepSchema: z.ZodObject<{
+    /** Human-readable step name (e.g., "TypeScript type checking") */
+    name: z.ZodString;
+    /** Command to execute (e.g., "npm run typecheck") */
+    command: z.ZodString;
+    /** Optional: Custom timeout in milliseconds (default: inherited from phase) */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /** Optional: Continue on failure (default: false) */
+    continueOnError: z.ZodOptional<z.ZodBoolean>;
+    /** Optional: Environment variables for this step */
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /** Optional: Working directory for this step (default: project root) */
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    command: string;
+    timeout?: number | undefined;
+    continueOnError?: boolean | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+}, {
+    name: string;
+    command: string;
+    timeout?: number | undefined;
+    continueOnError?: boolean | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+}>;
+export type ValidationStep = z.infer<typeof ValidationStepSchema>;
+/**
+ * Validation Phase Schema
+ *
+ * Defines a phase containing one or more validation steps.
+ * Phases are executed sequentially, but steps within a phase can be parallel.
+ */
+export declare const ValidationPhaseSchema: z.ZodObject<{
+    /** Phase name (e.g., "Pre-Qualification", "Testing") */
+    name: z.ZodString;
+    /** Execute steps in parallel (default: false) */
+    parallel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Optional: Phase names this phase depends on */
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Steps to execute in this phase */
+    steps: z.ZodArray<z.ZodObject<{
+        /** Human-readable step name (e.g., "TypeScript type checking") */
+        name: z.ZodString;
+        /** Command to execute (e.g., "npm run typecheck") */
+        command: z.ZodString;
+        /** Optional: Custom timeout in milliseconds (default: inherited from phase) */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /** Optional: Continue on failure (default: false) */
+        continueOnError: z.ZodOptional<z.ZodBoolean>;
+        /** Optional: Environment variables for this step */
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /** Optional: Working directory for this step (default: project root) */
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        command: string;
+        timeout?: number | undefined;
+        continueOnError?: boolean | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }, {
+        name: string;
+        command: string;
+        timeout?: number | undefined;
+        continueOnError?: boolean | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }>, "many">;
+    /** Optional: Default timeout for all steps (milliseconds, default: 300000 = 5min) */
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /** Optional: Fail fast - stop on first error (default: true) */
+    failFast: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    timeout: number;
+    parallel: boolean;
+    steps: {
+        name: string;
+        command: string;
+        timeout?: number | undefined;
+        continueOnError?: boolean | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }[];
+    failFast: boolean;
+    dependsOn?: string[] | undefined;
+}, {
+    name: string;
+    steps: {
+        name: string;
+        command: string;
+        timeout?: number | undefined;
+        continueOnError?: boolean | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }[];
+    timeout?: number | undefined;
+    parallel?: boolean | undefined;
+    dependsOn?: string[] | undefined;
+    failFast?: boolean | undefined;
+}>;
+export type ValidationPhase = z.input<typeof ValidationPhaseSchema>;
+/**
+ * Caching Strategy Schema
+ */
+export declare const CachingStrategySchema: z.ZodEnum<["git-tree-hash", "timestamp", "disabled"]>;
+export type CachingStrategy = z.infer<typeof CachingStrategySchema>;
+/**
+ * Validation Config Schema
+ */
+export declare const ValidationConfigSchema: z.ZodObject<{
+    /** Validation phases to execute */
+    phases: z.ZodArray<z.ZodObject<{
+        /** Phase name (e.g., "Pre-Qualification", "Testing") */
+        name: z.ZodString;
+        /** Execute steps in parallel (default: false) */
+        parallel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /** Optional: Phase names this phase depends on */
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Steps to execute in this phase */
+        steps: z.ZodArray<z.ZodObject<{
+            /** Human-readable step name (e.g., "TypeScript type checking") */
+            name: z.ZodString;
+            /** Command to execute (e.g., "npm run typecheck") */
+            command: z.ZodString;
+            /** Optional: Custom timeout in milliseconds (default: inherited from phase) */
+            timeout: z.ZodOptional<z.ZodNumber>;
+            /** Optional: Continue on failure (default: false) */
+            continueOnError: z.ZodOptional<z.ZodBoolean>;
+            /** Optional: Environment variables for this step */
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            /** Optional: Working directory for this step (default: project root) */
+            cwd: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            command: string;
+            timeout?: number | undefined;
+            continueOnError?: boolean | undefined;
+            env?: Record<string, string> | undefined;
+            cwd?: string | undefined;
+        }, {
+            name: string;
+            command: string;
+            timeout?: number | undefined;
+            continueOnError?: boolean | undefined;
+            env?: Record<string, string> | undefined;
+            cwd?: string | undefined;
+        }>, "many">;
+        /** Optional: Default timeout for all steps (milliseconds, default: 300000 = 5min) */
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /** Optional: Fail fast - stop on first error (default: true) */
+        failFast: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        timeout: number;
+        parallel: boolean;
+        steps: {
+            name: string;
+            command: string;
+            timeout?: number | undefined;
+            continueOnError?: boolean | undefined;
+            env?: Record<string, string> | undefined;
+            cwd?: string | undefined;
+        }[];
+        failFast: boolean;
+        dependsOn?: string[] | undefined;
+    }, {
+        name: string;
+        steps: {
+            name: string;
+            command: string;
+            timeout?: number | undefined;
+            continueOnError?: boolean | undefined;
+            env?: Record<string, string> | undefined;
+            cwd?: string | undefined;
+        }[];
+        timeout?: number | undefined;
+        parallel?: boolean | undefined;
+        dependsOn?: string[] | undefined;
+        failFast?: boolean | undefined;
+    }>, "many">;
+    /** Caching configuration */
+    caching: z.ZodDefault<z.ZodObject<{
+        /** Caching strategy (default: git-tree-hash) */
+        strategy: z.ZodDefault<z.ZodEnum<["git-tree-hash", "timestamp", "disabled"]>>;
+        /** Enable caching (default: true) */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** State file path (default: .vibe-validate-state.yaml) */
+        statePath: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "git-tree-hash" | "timestamp" | "disabled";
+        enabled: boolean;
+        statePath: string;
+    }, {
+        strategy?: "git-tree-hash" | "timestamp" | "disabled" | undefined;
+        enabled?: boolean | undefined;
+        statePath?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    phases: {
+        name: string;
+        timeout: number;
+        parallel: boolean;
+        steps: {
+            name: string;
+            command: string;
+            timeout?: number | undefined;
+            continueOnError?: boolean | undefined;
+            env?: Record<string, string> | undefined;
+            cwd?: string | undefined;
+        }[];
+        failFast: boolean;
+        dependsOn?: string[] | undefined;
+    }[];
+    caching: {
+        strategy: "git-tree-hash" | "timestamp" | "disabled";
+        enabled: boolean;
+        statePath: string;
+    };
+}, {
+    phases: {
+        name: string;
+        steps: {
+            name: string;
+            command: string;
+            timeout?: number | undefined;
+            continueOnError?: boolean | undefined;
+            env?: Record<string, string> | undefined;
+            cwd?: string | undefined;
+        }[];
+        timeout?: number | undefined;
+        parallel?: boolean | undefined;
+        dependsOn?: string[] | undefined;
+        failFast?: boolean | undefined;
+    }[];
+    caching?: {
+        strategy?: "git-tree-hash" | "timestamp" | "disabled" | undefined;
+        enabled?: boolean | undefined;
+        statePath?: string | undefined;
+    } | undefined;
+}>;
+export type ValidationConfig = z.infer<typeof ValidationConfigSchema>;
+/**
+ * Output Format Schema
+ */
+export declare const OutputFormatSchema: z.ZodEnum<["human", "yaml", "json", "auto"]>;
+export type OutputFormat = z.infer<typeof OutputFormatSchema>;
+/**
+ * Git Config Schema
+ */
+export declare const GitConfigSchema: z.ZodObject<{
+    /** Main branch name (default: main) */
+    mainBranch: z.ZodDefault<z.ZodString>;
+    /** Auto-sync with remote (default: false) */
+    autoSync: z.ZodDefault<z.ZodBoolean>;
+    /** Warn if branch is behind remote (default: true) */
+    warnIfBehind: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    mainBranch: string;
+    autoSync: boolean;
+    warnIfBehind: boolean;
+}, {
+    mainBranch?: string | undefined;
+    autoSync?: boolean | undefined;
+    warnIfBehind?: boolean | undefined;
+}>;
+export type GitConfig = z.infer<typeof GitConfigSchema>;
+/**
+ * Output Config Schema
+ */
+export declare const OutputConfigSchema: z.ZodObject<{
+    /** Output format (default: auto) */
+    format: z.ZodDefault<z.ZodEnum<["human", "yaml", "json", "auto"]>>;
+    /** Show progress indicators (default: true) */
+    showProgress: z.ZodDefault<z.ZodBoolean>;
+    /** Verbose logging (default: false) */
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    /** Suppress ANSI colors (default: false) */
+    noColor: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    format: "human" | "yaml" | "json" | "auto";
+    showProgress: boolean;
+    verbose: boolean;
+    noColor: boolean;
+}, {
+    format?: "human" | "yaml" | "json" | "auto" | undefined;
+    showProgress?: boolean | undefined;
+    verbose?: boolean | undefined;
+    noColor?: boolean | undefined;
+}>;
+export type OutputConfig = z.infer<typeof OutputConfigSchema>;
+/**
+ * Full Configuration Schema
+ *
+ * Root configuration object for vibe-validate.
+ */
+export declare const VibeValidateConfigSchema: z.ZodObject<{
+    /** Validation configuration */
+    validation: z.ZodObject<{
+        /** Validation phases to execute */
+        phases: z.ZodArray<z.ZodObject<{
+            /** Phase name (e.g., "Pre-Qualification", "Testing") */
+            name: z.ZodString;
+            /** Execute steps in parallel (default: false) */
+            parallel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            /** Optional: Phase names this phase depends on */
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Steps to execute in this phase */
+            steps: z.ZodArray<z.ZodObject<{
+                /** Human-readable step name (e.g., "TypeScript type checking") */
+                name: z.ZodString;
+                /** Command to execute (e.g., "npm run typecheck") */
+                command: z.ZodString;
+                /** Optional: Custom timeout in milliseconds (default: inherited from phase) */
+                timeout: z.ZodOptional<z.ZodNumber>;
+                /** Optional: Continue on failure (default: false) */
+                continueOnError: z.ZodOptional<z.ZodBoolean>;
+                /** Optional: Environment variables for this step */
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                /** Optional: Working directory for this step (default: project root) */
+                cwd: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }, {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }>, "many">;
+            /** Optional: Default timeout for all steps (milliseconds, default: 300000 = 5min) */
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /** Optional: Fail fast - stop on first error (default: true) */
+            failFast: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            timeout: number;
+            parallel: boolean;
+            steps: {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }[];
+            failFast: boolean;
+            dependsOn?: string[] | undefined;
+        }, {
+            name: string;
+            steps: {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }[];
+            timeout?: number | undefined;
+            parallel?: boolean | undefined;
+            dependsOn?: string[] | undefined;
+            failFast?: boolean | undefined;
+        }>, "many">;
+        /** Caching configuration */
+        caching: z.ZodDefault<z.ZodObject<{
+            /** Caching strategy (default: git-tree-hash) */
+            strategy: z.ZodDefault<z.ZodEnum<["git-tree-hash", "timestamp", "disabled"]>>;
+            /** Enable caching (default: true) */
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** State file path (default: .vibe-validate-state.yaml) */
+            statePath: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "git-tree-hash" | "timestamp" | "disabled";
+            enabled: boolean;
+            statePath: string;
+        }, {
+            strategy?: "git-tree-hash" | "timestamp" | "disabled" | undefined;
+            enabled?: boolean | undefined;
+            statePath?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        phases: {
+            name: string;
+            timeout: number;
+            parallel: boolean;
+            steps: {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }[];
+            failFast: boolean;
+            dependsOn?: string[] | undefined;
+        }[];
+        caching: {
+            strategy: "git-tree-hash" | "timestamp" | "disabled";
+            enabled: boolean;
+            statePath: string;
+        };
+    }, {
+        phases: {
+            name: string;
+            steps: {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }[];
+            timeout?: number | undefined;
+            parallel?: boolean | undefined;
+            dependsOn?: string[] | undefined;
+            failFast?: boolean | undefined;
+        }[];
+        caching?: {
+            strategy?: "git-tree-hash" | "timestamp" | "disabled" | undefined;
+            enabled?: boolean | undefined;
+            statePath?: string | undefined;
+        } | undefined;
+    }>;
+    /** Git integration configuration */
+    git: z.ZodDefault<z.ZodObject<{
+        /** Main branch name (default: main) */
+        mainBranch: z.ZodDefault<z.ZodString>;
+        /** Auto-sync with remote (default: false) */
+        autoSync: z.ZodDefault<z.ZodBoolean>;
+        /** Warn if branch is behind remote (default: true) */
+        warnIfBehind: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        mainBranch: string;
+        autoSync: boolean;
+        warnIfBehind: boolean;
+    }, {
+        mainBranch?: string | undefined;
+        autoSync?: boolean | undefined;
+        warnIfBehind?: boolean | undefined;
+    }>>;
+    /** Output formatting configuration */
+    output: z.ZodDefault<z.ZodObject<{
+        /** Output format (default: auto) */
+        format: z.ZodDefault<z.ZodEnum<["human", "yaml", "json", "auto"]>>;
+        /** Show progress indicators (default: true) */
+        showProgress: z.ZodDefault<z.ZodBoolean>;
+        /** Verbose logging (default: false) */
+        verbose: z.ZodDefault<z.ZodBoolean>;
+        /** Suppress ANSI colors (default: false) */
+        noColor: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        format: "human" | "yaml" | "json" | "auto";
+        showProgress: boolean;
+        verbose: boolean;
+        noColor: boolean;
+    }, {
+        format?: "human" | "yaml" | "json" | "auto" | undefined;
+        showProgress?: boolean | undefined;
+        verbose?: boolean | undefined;
+        noColor?: boolean | undefined;
+    }>>;
+    /** Optional: Preset name (typescript-library, typescript-nodejs, etc.) */
+    preset: z.ZodOptional<z.ZodString>;
+    /** Optional: Extend another config file */
+    extends: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    validation: {
+        phases: {
+            name: string;
+            timeout: number;
+            parallel: boolean;
+            steps: {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }[];
+            failFast: boolean;
+            dependsOn?: string[] | undefined;
+        }[];
+        caching: {
+            strategy: "git-tree-hash" | "timestamp" | "disabled";
+            enabled: boolean;
+            statePath: string;
+        };
+    };
+    git: {
+        mainBranch: string;
+        autoSync: boolean;
+        warnIfBehind: boolean;
+    };
+    output: {
+        format: "human" | "yaml" | "json" | "auto";
+        showProgress: boolean;
+        verbose: boolean;
+        noColor: boolean;
+    };
+    preset?: string | undefined;
+    extends?: string | undefined;
+}, {
+    validation: {
+        phases: {
+            name: string;
+            steps: {
+                name: string;
+                command: string;
+                timeout?: number | undefined;
+                continueOnError?: boolean | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+            }[];
+            timeout?: number | undefined;
+            parallel?: boolean | undefined;
+            dependsOn?: string[] | undefined;
+            failFast?: boolean | undefined;
+        }[];
+        caching?: {
+            strategy?: "git-tree-hash" | "timestamp" | "disabled" | undefined;
+            enabled?: boolean | undefined;
+            statePath?: string | undefined;
+        } | undefined;
+    };
+    git?: {
+        mainBranch?: string | undefined;
+        autoSync?: boolean | undefined;
+        warnIfBehind?: boolean | undefined;
+    } | undefined;
+    output?: {
+        format?: "human" | "yaml" | "json" | "auto" | undefined;
+        showProgress?: boolean | undefined;
+        verbose?: boolean | undefined;
+        noColor?: boolean | undefined;
+    } | undefined;
+    preset?: string | undefined;
+    extends?: string | undefined;
+}>;
+export type VibeValidateConfig = z.infer<typeof VibeValidateConfigSchema>;
+/**
+ * Validate configuration object
+ *
+ * @param config - Configuration object to validate
+ * @returns Validated configuration with defaults applied
+ * @throws ZodError if validation fails
+ */
+export declare function validateConfig(config: unknown): VibeValidateConfig;
+/**
+ * Safely validate configuration with detailed error messages
+ *
+ * @param config - Configuration object to validate
+ * @returns Result object with success flag and data or errors
+ */
+export declare function safeValidateConfig(config: unknown): {
+    success: boolean;
+    data?: VibeValidateConfig;
+    errors?: string[];
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}