@ipation/specbridge 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,1802 @@
+import { z } from 'zod';
+import { SourceFile, Project } from 'ts-morph';
+import { Document } from 'yaml';
+export { minimatch } from 'minimatch';
+
+/**
+ * Core type definitions for SpecBridge
+ */
+type DecisionStatus = 'draft' | 'active' | 'deprecated' | 'superseded';
+type ConstraintType = 'invariant' | 'convention' | 'guideline';
+type Severity = 'critical' | 'high' | 'medium' | 'low';
+type VerificationFrequency = 'commit' | 'pr' | 'daily' | 'weekly';
+type VerificationLevel = 'commit' | 'pr' | 'full';
+/**
+ * Decision metadata
+ */
+interface DecisionMetadata {
+    id: string;
+    title: string;
+    status: DecisionStatus;
+    owners: string[];
+    createdAt?: string;
+    updatedAt?: string;
+    supersededBy?: string;
+    tags?: string[];
+}
+/**
+ * Core decision content
+ */
+interface DecisionContent {
+    summary: string;
+    rationale: string;
+    context?: string;
+    consequences?: string[];
+}
+/**
+ * A single constraint within a decision
+ */
+interface Constraint {
+    id: string;
+    type: ConstraintType;
+    rule: string;
+    severity: Severity;
+    scope: string;
+    verifier?: string;
+    autofix?: boolean;
+    exceptions?: ConstraintException[];
+}
+/**
+ * Exception to a constraint
+ */
+interface ConstraintException {
+    pattern: string;
+    reason: string;
+    approvedBy?: string;
+    expiresAt?: string;
+}
+/**
+ * Automated verification configuration
+ */
+interface VerificationConfig {
+    check: string;
+    target: string;
+    frequency: VerificationFrequency;
+    timeout?: number;
+}
+/**
+ * Complete decision document
+ */
+interface Decision {
+    kind: 'Decision';
+    metadata: DecisionMetadata;
+    decision: DecisionContent;
+    constraints: Constraint[];
+    verification?: {
+        automated?: VerificationConfig[];
+    };
+    links?: {
+        related?: string[];
+        supersedes?: string[];
+        references?: string[];
+    };
+}
+/**
+ * A violation of a constraint
+ */
+interface Violation {
+    decisionId: string;
+    constraintId: string;
+    type: ConstraintType;
+    severity: Severity;
+    message: string;
+    file: string;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+    suggestion?: string;
+    autofix?: ViolationFix;
+}
+/**
+ * Auto-fix for a violation
+ */
+interface ViolationFix {
+    description: string;
+    patch: string;
+}
+/**
+ * A pattern detected during inference
+ */
+interface Pattern {
+    id: string;
+    name: string;
+    description: string;
+    confidence: number;
+    occurrences: number;
+    examples: PatternExample[];
+    suggestedConstraint?: Partial<Constraint>;
+    analyzer: string;
+}
+/**
+ * Example of a detected pattern
+ */
+interface PatternExample {
+    file: string;
+    line: number;
+    snippet: string;
+}
+/**
+ * SpecBridge project configuration
+ */
+interface SpecBridgeConfig {
+    version: string;
+    project: {
+        name: string;
+        sourceRoots: string[];
+        exclude?: string[];
+    };
+    inference?: {
+        minConfidence?: number;
+        analyzers?: string[];
+    };
+    verification?: {
+        levels?: {
+            commit?: LevelConfig;
+            pr?: LevelConfig;
+            full?: LevelConfig;
+        };
+    };
+    agent?: {
+        format?: 'markdown' | 'json' | 'mcp';
+        includeRationale?: boolean;
+    };
+}
+/**
+ * Configuration for a verification level
+ */
+interface LevelConfig {
+    timeout?: number;
+    severity?: Severity[];
+}
+/**
+ * Result of a verification run
+ */
+interface VerificationResult {
+    success: boolean;
+    violations: Violation[];
+    checked: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+}
+/**
+ * Result of an inference run
+ */
+interface InferenceResult {
+    patterns: Pattern[];
+    analyzersRun: string[];
+    filesScanned: number;
+    duration: number;
+}
+/**
+ * Compliance report
+ */
+interface ComplianceReport {
+    timestamp: string;
+    project: string;
+    summary: {
+        totalDecisions: number;
+        activeDecisions: number;
+        totalConstraints: number;
+        violations: {
+            critical: number;
+            high: number;
+            medium: number;
+            low: number;
+        };
+        compliance: number;
+    };
+    byDecision: DecisionCompliance[];
+    recentTrend?: TrendData[];
+}
+/**
+ * Compliance data for a single decision
+ */
+interface DecisionCompliance {
+    decisionId: string;
+    title: string;
+    status: DecisionStatus;
+    constraints: number;
+    violations: number;
+    compliance: number;
+}
+/**
+ * Trend data point
+ */
+interface TrendData {
+    date: string;
+    compliance: number;
+    violations: number;
+}
+/**
+ * Agent context for code generation
+ */
+interface AgentContext {
+    file: string;
+    applicableDecisions: ApplicableDecision[];
+    generatedAt: string;
+}
+/**
+ * Decision applicable to a specific context
+ */
+interface ApplicableDecision {
+    id: string;
+    title: string;
+    summary: string;
+    constraints: ApplicableConstraint[];
+}
+/**
+ * Constraint applicable to a specific context
+ */
+interface ApplicableConstraint {
+    id: string;
+    type: ConstraintType;
+    rule: string;
+    severity: Severity;
+}
+/**
+ * Impact analysis result
+ */
+interface ImpactAnalysis {
+    decision: string;
+    change: 'created' | 'modified' | 'deprecated';
+    affectedFiles: AffectedFile[];
+    estimatedEffort: 'low' | 'medium' | 'high';
+    migrationSteps?: MigrationStep[];
+}
+/**
+ * File affected by a decision change
+ */
+interface AffectedFile {
+    path: string;
+    violations: number;
+    autoFixable: number;
+}
+/**
+ * Step in a migration plan
+ */
+interface MigrationStep {
+    order: number;
+    description: string;
+    files: string[];
+    automated: boolean;
+}
+
+/**
+ * Zod schemas for decision YAML validation
+ */
+
+declare const DecisionStatusSchema: z.ZodEnum<["draft", "active", "deprecated", "superseded"]>;
+declare const ConstraintTypeSchema: z.ZodEnum<["invariant", "convention", "guideline"]>;
+declare const SeveritySchema: z.ZodEnum<["critical", "high", "medium", "low"]>;
+declare const VerificationFrequencySchema: z.ZodEnum<["commit", "pr", "daily", "weekly"]>;
+declare const DecisionMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<["draft", "active", "deprecated", "superseded"]>;
+    owners: z.ZodArray<z.ZodString, "many">;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    supersededBy: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    status: "draft" | "active" | "deprecated" | "superseded";
+    owners: string[];
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    supersededBy?: string | undefined;
+    tags?: string[] | undefined;
+}, {
+    id: string;
+    title: string;
+    status: "draft" | "active" | "deprecated" | "superseded";
+    owners: string[];
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    supersededBy?: string | undefined;
+    tags?: string[] | undefined;
+}>;
+declare const DecisionContentSchema: z.ZodObject<{
+    summary: z.ZodString;
+    rationale: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    consequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    rationale: string;
+    context?: string | undefined;
+    consequences?: string[] | undefined;
+}, {
+    summary: string;
+    rationale: string;
+    context?: string | undefined;
+    consequences?: string[] | undefined;
+}>;
+declare const ConstraintExceptionSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    reason: z.ZodString;
+    approvedBy: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    reason: string;
+    approvedBy?: string | undefined;
+    expiresAt?: string | undefined;
+}, {
+    pattern: string;
+    reason: string;
+    approvedBy?: string | undefined;
+    expiresAt?: string | undefined;
+}>;
+declare const ConstraintSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["invariant", "convention", "guideline"]>;
+    rule: z.ZodString;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    scope: z.ZodString;
+    verifier: z.ZodOptional<z.ZodString>;
+    autofix: z.ZodOptional<z.ZodBoolean>;
+    exceptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        reason: z.ZodString;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        reason: string;
+        approvedBy?: string | undefined;
+        expiresAt?: string | undefined;
+    }, {
+        pattern: string;
+        reason: string;
+        approvedBy?: string | undefined;
+        expiresAt?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "invariant" | "convention" | "guideline";
+    rule: string;
+    severity: "critical" | "high" | "medium" | "low";
+    scope: string;
+    verifier?: string | undefined;
+    autofix?: boolean | undefined;
+    exceptions?: {
+        pattern: string;
+        reason: string;
+        approvedBy?: string | undefined;
+        expiresAt?: string | undefined;
+    }[] | undefined;
+}, {
+    id: string;
+    type: "invariant" | "convention" | "guideline";
+    rule: string;
+    severity: "critical" | "high" | "medium" | "low";
+    scope: string;
+    verifier?: string | undefined;
+    autofix?: boolean | undefined;
+    exceptions?: {
+        pattern: string;
+        reason: string;
+        approvedBy?: string | undefined;
+        expiresAt?: string | undefined;
+    }[] | undefined;
+}>;
+declare const VerificationConfigSchema: z.ZodObject<{
+    check: z.ZodString;
+    target: z.ZodString;
+    frequency: z.ZodEnum<["commit", "pr", "daily", "weekly"]>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    check: string;
+    target: string;
+    frequency: "commit" | "pr" | "daily" | "weekly";
+    timeout?: number | undefined;
+}, {
+    check: string;
+    target: string;
+    frequency: "commit" | "pr" | "daily" | "weekly";
+    timeout?: number | undefined;
+}>;
+declare const LinksSchema: z.ZodObject<{
+    related: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    supersedes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    related?: string[] | undefined;
+    supersedes?: string[] | undefined;
+    references?: string[] | undefined;
+}, {
+    related?: string[] | undefined;
+    supersedes?: string[] | undefined;
+    references?: string[] | undefined;
+}>;
+declare const DecisionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"Decision">;
+    metadata: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodEnum<["draft", "active", "deprecated", "superseded"]>;
+        owners: z.ZodArray<z.ZodString, "many">;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+        supersededBy: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+        status: "draft" | "active" | "deprecated" | "superseded";
+        owners: string[];
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        supersededBy?: string | undefined;
+        tags?: string[] | undefined;
+    }, {
+        id: string;
+        title: string;
+        status: "draft" | "active" | "deprecated" | "superseded";
+        owners: string[];
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        supersededBy?: string | undefined;
+        tags?: string[] | undefined;
+    }>;
+    decision: z.ZodObject<{
+        summary: z.ZodString;
+        rationale: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+        consequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        summary: string;
+        rationale: string;
+        context?: string | undefined;
+        consequences?: string[] | undefined;
+    }, {
+        summary: string;
+        rationale: string;
+        context?: string | undefined;
+        consequences?: string[] | undefined;
+    }>;
+    constraints: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["invariant", "convention", "guideline"]>;
+        rule: z.ZodString;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        scope: z.ZodString;
+        verifier: z.ZodOptional<z.ZodString>;
+        autofix: z.ZodOptional<z.ZodBoolean>;
+        exceptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            reason: z.ZodString;
+            approvedBy: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+            reason: string;
+            approvedBy?: string | undefined;
+            expiresAt?: string | undefined;
+        }, {
+            pattern: string;
+            reason: string;
+            approvedBy?: string | undefined;
+            expiresAt?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "invariant" | "convention" | "guideline";
+        rule: string;
+        severity: "critical" | "high" | "medium" | "low";
+        scope: string;
+        verifier?: string | undefined;
+        autofix?: boolean | undefined;
+        exceptions?: {
+            pattern: string;
+            reason: string;
+            approvedBy?: string | undefined;
+            expiresAt?: string | undefined;
+        }[] | undefined;
+    }, {
+        id: string;
+        type: "invariant" | "convention" | "guideline";
+        rule: string;
+        severity: "critical" | "high" | "medium" | "low";
+        scope: string;
+        verifier?: string | undefined;
+        autofix?: boolean | undefined;
+        exceptions?: {
+            pattern: string;
+            reason: string;
+            approvedBy?: string | undefined;
+            expiresAt?: string | undefined;
+        }[] | undefined;
+    }>, "many">;
+    verification: z.ZodOptional<z.ZodObject<{
+        automated: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            check: z.ZodString;
+            target: z.ZodString;
+            frequency: z.ZodEnum<["commit", "pr", "daily", "weekly"]>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            check: string;
+            target: string;
+            frequency: "commit" | "pr" | "daily" | "weekly";
+            timeout?: number | undefined;
+        }, {
+            check: string;
+            target: string;
+            frequency: "commit" | "pr" | "daily" | "weekly";
+            timeout?: number | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        automated?: {
+            check: string;
+            target: string;
+            frequency: "commit" | "pr" | "daily" | "weekly";
+            timeout?: number | undefined;
+        }[] | undefined;
+    }, {
+        automated?: {
+            check: string;
+            target: string;
+            frequency: "commit" | "pr" | "daily" | "weekly";
+            timeout?: number | undefined;
+        }[] | undefined;
+    }>>;
+    links: z.ZodOptional<z.ZodObject<{
+        related: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        supersedes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        related?: string[] | undefined;
+        supersedes?: string[] | undefined;
+        references?: string[] | undefined;
+    }, {
+        related?: string[] | undefined;
+        supersedes?: string[] | undefined;
+        references?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "Decision";
+    metadata: {
+        id: string;
+        title: string;
+        status: "draft" | "active" | "deprecated" | "superseded";
+        owners: string[];
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        supersededBy?: string | undefined;
+        tags?: string[] | undefined;
+    };
+    decision: {
+        summary: string;
+        rationale: string;
+        context?: string | undefined;
+        consequences?: string[] | undefined;
+    };
+    constraints: {
+        id: string;
+        type: "invariant" | "convention" | "guideline";
+        rule: string;
+        severity: "critical" | "high" | "medium" | "low";
+        scope: string;
+        verifier?: string | undefined;
+        autofix?: boolean | undefined;
+        exceptions?: {
+            pattern: string;
+            reason: string;
+            approvedBy?: string | undefined;
+            expiresAt?: string | undefined;
+        }[] | undefined;
+    }[];
+    verification?: {
+        automated?: {
+            check: string;
+            target: string;
+            frequency: "commit" | "pr" | "daily" | "weekly";
+            timeout?: number | undefined;
+        }[] | undefined;
+    } | undefined;
+    links?: {
+        related?: string[] | undefined;
+        supersedes?: string[] | undefined;
+        references?: string[] | undefined;
+    } | undefined;
+}, {
+    kind: "Decision";
+    metadata: {
+        id: string;
+        title: string;
+        status: "draft" | "active" | "deprecated" | "superseded";
+        owners: string[];
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        supersededBy?: string | undefined;
+        tags?: string[] | undefined;
+    };
+    decision: {
+        summary: string;
+        rationale: string;
+        context?: string | undefined;
+        consequences?: string[] | undefined;
+    };
+    constraints: {
+        id: string;
+        type: "invariant" | "convention" | "guideline";
+        rule: string;
+        severity: "critical" | "high" | "medium" | "low";
+        scope: string;
+        verifier?: string | undefined;
+        autofix?: boolean | undefined;
+        exceptions?: {
+            pattern: string;
+            reason: string;
+            approvedBy?: string | undefined;
+            expiresAt?: string | undefined;
+        }[] | undefined;
+    }[];
+    verification?: {
+        automated?: {
+            check: string;
+            target: string;
+            frequency: "commit" | "pr" | "daily" | "weekly";
+            timeout?: number | undefined;
+        }[] | undefined;
+    } | undefined;
+    links?: {
+        related?: string[] | undefined;
+        supersedes?: string[] | undefined;
+        references?: string[] | undefined;
+    } | undefined;
+}>;
+type DecisionStatusSchema_ = z.infer<typeof DecisionStatusSchema>;
+type ConstraintTypeSchema_ = z.infer<typeof ConstraintTypeSchema>;
+type SeveritySchema_ = z.infer<typeof SeveritySchema>;
+type VerificationFrequencySchema_ = z.infer<typeof VerificationFrequencySchema>;
+type DecisionMetadataSchema_ = z.infer<typeof DecisionMetadataSchema>;
+type DecisionContentSchema_ = z.infer<typeof DecisionContentSchema>;
+type ConstraintExceptionSchema_ = z.infer<typeof ConstraintExceptionSchema>;
+type ConstraintSchema_ = z.infer<typeof ConstraintSchema>;
+type VerificationConfigSchema_ = z.infer<typeof VerificationConfigSchema>;
+type DecisionTypeSchema = z.infer<typeof DecisionSchema>;
+/**
+ * Validate a decision document
+ */
+declare function validateDecision(data: unknown): {
+    success: true;
+    data: DecisionTypeSchema;
+} | {
+    success: false;
+    errors: z.ZodError;
+};
+/**
+ * Format Zod errors into human-readable messages
+ */
+declare function formatValidationErrors(errors: z.ZodError): string[];
+
+/**
+ * Zod schemas for SpecBridge configuration
+ */
+
+declare const SpecBridgeConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        sourceRoots: z.ZodArray<z.ZodString, "many">;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        sourceRoots: string[];
+        exclude?: string[] | undefined;
+    }, {
+        name: string;
+        sourceRoots: string[];
+        exclude?: string[] | undefined;
+    }>;
+    inference: z.ZodOptional<z.ZodObject<{
+        minConfidence: z.ZodOptional<z.ZodNumber>;
+        analyzers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        minConfidence?: number | undefined;
+        analyzers?: string[] | undefined;
+    }, {
+        minConfidence?: number | undefined;
+        analyzers?: string[] | undefined;
+    }>>;
+    verification: z.ZodOptional<z.ZodObject<{
+        levels: z.ZodOptional<z.ZodObject<{
+            commit: z.ZodOptional<z.ZodObject<{
+                timeout: z.ZodOptional<z.ZodNumber>;
+                severity: z.ZodOptional<z.ZodArray<z.ZodEnum<["critical", "high", "medium", "low"]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            }, {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            }>>;
+            pr: z.ZodOptional<z.ZodObject<{
+                timeout: z.ZodOptional<z.ZodNumber>;
+                severity: z.ZodOptional<z.ZodArray<z.ZodEnum<["critical", "high", "medium", "low"]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            }, {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            }>>;
+            full: z.ZodOptional<z.ZodObject<{
+                timeout: z.ZodOptional<z.ZodNumber>;
+                severity: z.ZodOptional<z.ZodArray<z.ZodEnum<["critical", "high", "medium", "low"]>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            }, {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            commit?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            pr?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            full?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+        }, {
+            commit?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            pr?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            full?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        levels?: {
+            commit?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            pr?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            full?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        levels?: {
+            commit?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            pr?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            full?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+        } | undefined;
+    }>>;
+    agent: z.ZodOptional<z.ZodObject<{
+        format: z.ZodOptional<z.ZodEnum<["markdown", "json", "mcp"]>>;
+        includeRationale: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        format?: "markdown" | "json" | "mcp" | undefined;
+        includeRationale?: boolean | undefined;
+    }, {
+        format?: "markdown" | "json" | "mcp" | undefined;
+        includeRationale?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    project: {
+        name: string;
+        sourceRoots: string[];
+        exclude?: string[] | undefined;
+    };
+    verification?: {
+        levels?: {
+            commit?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            pr?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            full?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    inference?: {
+        minConfidence?: number | undefined;
+        analyzers?: string[] | undefined;
+    } | undefined;
+    agent?: {
+        format?: "markdown" | "json" | "mcp" | undefined;
+        includeRationale?: boolean | undefined;
+    } | undefined;
+}, {
+    version: string;
+    project: {
+        name: string;
+        sourceRoots: string[];
+        exclude?: string[] | undefined;
+    };
+    verification?: {
+        levels?: {
+            commit?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            pr?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+            full?: {
+                severity?: ("critical" | "high" | "medium" | "low")[] | undefined;
+                timeout?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    inference?: {
+        minConfidence?: number | undefined;
+        analyzers?: string[] | undefined;
+    } | undefined;
+    agent?: {
+        format?: "markdown" | "json" | "mcp" | undefined;
+        includeRationale?: boolean | undefined;
+    } | undefined;
+}>;
+type SpecBridgeConfigType = z.infer<typeof SpecBridgeConfigSchema>;
+/**
+ * Validate configuration
+ */
+declare function validateConfig(data: unknown): {
+    success: true;
+    data: SpecBridgeConfigType;
+} | {
+    success: false;
+    errors: z.ZodError;
+};
+/**
+ * Default configuration
+ */
+declare const defaultConfig: SpecBridgeConfigType;
+
+/**
+ * Custom error types for SpecBridge
+ */
+/**
+ * Base error for SpecBridge
+ */
+declare class SpecBridgeError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
+}
+/**
+ * Configuration errors
+ */
+declare class ConfigError extends SpecBridgeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Decision validation errors
+ */
+declare class DecisionValidationError extends SpecBridgeError {
+    readonly decisionId: string;
+    readonly validationErrors: string[];
+    constructor(message: string, decisionId: string, validationErrors: string[]);
+}
+/**
+ * Decision not found
+ */
+declare class DecisionNotFoundError extends SpecBridgeError {
+    constructor(decisionId: string);
+}
+/**
+ * Registry errors
+ */
+declare class RegistryError extends SpecBridgeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Verification errors
+ */
+declare class VerificationError extends SpecBridgeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Inference errors
+ */
+declare class InferenceError extends SpecBridgeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * File system errors
+ */
+declare class FileSystemError extends SpecBridgeError {
+    readonly path: string;
+    constructor(message: string, path: string);
+}
+/**
+ * Already initialized error
+ */
+declare class AlreadyInitializedError extends SpecBridgeError {
+    constructor(path: string);
+}
+/**
+ * Not initialized error
+ */
+declare class NotInitializedError extends SpecBridgeError {
+    constructor();
+}
+/**
+ * Verifier not found
+ */
+declare class VerifierNotFoundError extends SpecBridgeError {
+    constructor(verifierId: string);
+}
+/**
+ * Analyzer not found
+ */
+declare class AnalyzerNotFoundError extends SpecBridgeError {
+    constructor(analyzerId: string);
+}
+/**
+ * Hook installation error
+ */
+declare class HookError extends SpecBridgeError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Format error message for CLI output
+ */
+declare function formatError(error: Error): string;
+
+/**
+ * Configuration loader
+ */
+
+/**
+ * Load configuration from .specbridge/config.yaml
+ */
+declare function loadConfig(basePath?: string): Promise<SpecBridgeConfig>;
+/**
+ * Merge partial config with defaults
+ */
+declare function mergeWithDefaults(partial: Partial<SpecBridgeConfig>): SpecBridgeConfig;
+
+interface LoadedDecision {
+    decision: Decision;
+    filePath: string;
+}
+interface LoadResult {
+    decisions: LoadedDecision[];
+    errors: LoadError[];
+}
+interface LoadError {
+    filePath: string;
+    error: string;
+}
+/**
+ * Load a single decision file
+ */
+declare function loadDecisionFile(filePath: string): Promise<Decision>;
+/**
+ * Load all decisions from a directory
+ */
+declare function loadDecisionsFromDir(dirPath: string): Promise<LoadResult>;
+/**
+ * Validate a decision file without loading it into registry
+ */
+declare function validateDecisionFile(filePath: string): Promise<{
+    valid: boolean;
+    errors: string[];
+}>;
+
+/**
+ * Decision Registry - Central store for architectural decisions
+ */
+
+interface RegistryOptions {
+    basePath?: string;
+}
+interface DecisionFilter {
+    status?: DecisionStatus[];
+    tags?: string[];
+    constraintType?: ConstraintType[];
+    severity?: Severity[];
+}
+interface RegistryConstraintMatch {
+    decisionId: string;
+    decisionTitle: string;
+    constraintId: string;
+    type: ConstraintType;
+    rule: string;
+    severity: Severity;
+    scope: string;
+}
+/**
+ * Decision Registry class
+ */
+declare class Registry {
+    private decisions;
+    private basePath;
+    private loaded;
+    constructor(options?: RegistryOptions);
+    /**
+     * Load all decisions from the decisions directory
+     */
+    load(): Promise<LoadResult>;
+    /**
+     * Ensure registry is loaded
+     */
+    private ensureLoaded;
+    /**
+     * Get all decisions
+     */
+    getAll(filter?: DecisionFilter): Decision[];
+    /**
+     * Get active decisions only
+     */
+    getActive(): Decision[];
+    /**
+     * Get a decision by ID
+     */
+    get(id: string): Decision;
+    /**
+     * Get a decision with its file path
+     */
+    getWithPath(id: string): LoadedDecision;
+    /**
+     * Check if a decision exists
+     */
+    has(id: string): boolean;
+    /**
+     * Get all decision IDs
+     */
+    getIds(): string[];
+    /**
+     * Get constraints applicable to a specific file
+     */
+    getConstraintsForFile(filePath: string, filter?: DecisionFilter): RegistryConstraintMatch[];
+    /**
+     * Get decisions by tag
+     */
+    getByTag(tag: string): Decision[];
+    /**
+     * Get decisions by owner
+     */
+    getByOwner(owner: string): Decision[];
+    /**
+     * Apply filter to decisions
+     */
+    private applyFilter;
+    /**
+     * Get count of decisions by status
+     */
+    getStatusCounts(): Record<DecisionStatus, number>;
+    /**
+     * Get total constraint count
+     */
+    getConstraintCount(): number;
+}
+/**
+ * Create a new registry instance
+ */
+declare function createRegistry(options?: RegistryOptions): Registry;
+
+/**
+ * Codebase scanner using ts-morph
+ */
+
+interface ScanResult {
+    files: ScannedFile[];
+    totalFiles: number;
+    totalLines: number;
+}
+interface ScannedFile {
+    path: string;
+    sourceFile: SourceFile;
+    lines: number;
+}
+interface ScanOptions {
+    sourceRoots: string[];
+    exclude?: string[];
+    cwd?: string;
+}
+/**
+ * Scanner class for analyzing TypeScript/JavaScript codebases
+ */
+declare class CodeScanner {
+    private project;
+    private scannedFiles;
+    constructor();
+    /**
+     * Scan files matching the given patterns
+     */
+    scan(options: ScanOptions): Promise<ScanResult>;
+    /**
+     * Get all scanned files
+     */
+    getFiles(): ScannedFile[];
+    /**
+     * Get a specific file
+     */
+    getFile(path: string): ScannedFile | undefined;
+    /**
+     * Get project instance for advanced analysis
+     */
+    getProject(): Project;
+    /**
+     * Find all classes in scanned files
+     */
+    findClasses(): {
+        file: string;
+        name: string;
+        line: number;
+    }[];
+    /**
+     * Find all functions in scanned files
+     */
+    findFunctions(): {
+        file: string;
+        name: string;
+        line: number;
+        isExported: boolean;
+    }[];
+    /**
+     * Find all imports in scanned files
+     */
+    findImports(): {
+        file: string;
+        module: string;
+        named: string[];
+        line: number;
+    }[];
+    /**
+     * Find all interfaces in scanned files
+     */
+    findInterfaces(): {
+        file: string;
+        name: string;
+        line: number;
+    }[];
+    /**
+     * Find all type aliases in scanned files
+     */
+    findTypeAliases(): {
+        file: string;
+        name: string;
+        line: number;
+    }[];
+    /**
+     * Find try-catch blocks in scanned files
+     */
+    findTryCatchBlocks(): {
+        file: string;
+        line: number;
+        hasThrow: boolean;
+    }[];
+}
+/**
+ * Create a scanner from config
+ */
+declare function createScannerFromConfig(_config: SpecBridgeConfig): CodeScanner;
+
+/**
+ * Inference Engine - Orchestrates pattern detection
+ */
+
+interface InferenceOptions {
+    analyzers?: string[];
+    minConfidence?: number;
+    sourceRoots?: string[];
+    exclude?: string[];
+    cwd?: string;
+}
+/**
+ * Inference Engine class
+ */
+declare class InferenceEngine {
+    private scanner;
+    private analyzers;
+    constructor();
+    /**
+     * Configure analyzers to use
+     */
+    configureAnalyzers(analyzerIds: string[]): void;
+    /**
+     * Run inference on the codebase
+     */
+    infer(options: InferenceOptions): Promise<InferenceResult>;
+    /**
+     * Get scanner for direct access
+     */
+    getScanner(): CodeScanner;
+}
+/**
+ * Create an inference engine from config
+ */
+declare function createInferenceEngine(): InferenceEngine;
+/**
+ * Run inference with config
+ */
+declare function runInference(config: SpecBridgeConfig, options?: Partial<InferenceOptions>): Promise<InferenceResult>;
+
+/**
+ * Base analyzer interface
+ */
+
+/**
+ * Analyzer interface - all analyzers must implement this
+ */
+interface Analyzer {
+    /**
+     * Unique identifier for this analyzer
+     */
+    readonly id: string;
+    /**
+     * Human-readable name
+     */
+    readonly name: string;
+    /**
+     * Description of what this analyzer detects
+     */
+    readonly description: string;
+    /**
+     * Analyze the codebase and return detected patterns
+     */
+    analyze(scanner: CodeScanner): Promise<Pattern[]>;
+}
+/**
+ * Helper to create a pattern with consistent structure
+ */
+declare function createPattern(analyzer: string, params: {
+    id: string;
+    name: string;
+    description: string;
+    confidence: number;
+    occurrences: number;
+    examples: PatternExample[];
+    suggestedConstraint?: Pattern['suggestedConstraint'];
+}): Pattern;
+/**
+ * Calculate confidence based on occurrence ratio
+ */
+declare function calculateConfidence(occurrences: number, total: number, minOccurrences?: number): number;
+/**
+ * Extract a code snippet around a line
+ */
+declare function extractSnippet(content: string, line: number, contextLines?: number): string;
+
+/**
+ * Naming convention analyzer
+ */
+
+declare class NamingAnalyzer implements Analyzer {
+    readonly id = "naming";
+    readonly name = "Naming Convention Analyzer";
+    readonly description = "Detects naming conventions for classes, functions, interfaces, and types";
+    analyze(scanner: CodeScanner): Promise<Pattern[]>;
+    private analyzeClassNaming;
+    private analyzeFunctionNaming;
+    private analyzeInterfaceNaming;
+    private analyzeTypeNaming;
+    private findBestMatch;
+}
+
+/**
+ * Import pattern analyzer
+ */
+
+declare class ImportsAnalyzer implements Analyzer {
+    readonly id = "imports";
+    readonly name = "Import Pattern Analyzer";
+    readonly description = "Detects import organization patterns and module usage conventions";
+    analyze(scanner: CodeScanner): Promise<Pattern[]>;
+    private analyzeBarrelImports;
+    private analyzeRelativeImports;
+    private analyzeCommonModules;
+}
+
+declare class StructureAnalyzer implements Analyzer {
+    readonly id = "structure";
+    readonly name = "Code Structure Analyzer";
+    readonly description = "Detects file organization and directory structure patterns";
+    analyze(scanner: CodeScanner): Promise<Pattern[]>;
+    private analyzeDirectoryConventions;
+    private analyzeFileNaming;
+    private analyzeColocation;
+}
+
+declare class ErrorsAnalyzer implements Analyzer {
+    readonly id = "errors";
+    readonly name = "Error Handling Analyzer";
+    readonly description = "Detects error handling patterns and custom error class usage";
+    analyze(scanner: CodeScanner): Promise<Pattern[]>;
+    private analyzeCustomErrorClasses;
+    private analyzeTryCatchPatterns;
+    private analyzeThrowPatterns;
+}
+
+/**
+ * Analyzer exports
+ */
+
+/**
+ * Built-in analyzers registry
+ */
+declare const builtinAnalyzers: Record<string, () => Analyzer>;
+/**
+ * Get analyzer by ID
+ */
+declare function getAnalyzer(id: string): Analyzer | null;
+/**
+ * Get all analyzer IDs
+ */
+declare function getAnalyzerIds(): string[];
+
+interface VerificationOptions {
+    level?: VerificationLevel;
+    files?: string[];
+    decisions?: string[];
+    severity?: Severity[];
+    timeout?: number;
+    cwd?: string;
+}
+/**
+ * Verification Engine class
+ */
+declare class VerificationEngine {
+    private registry;
+    private project;
+    constructor(registry?: Registry);
+    /**
+     * Run verification
+     */
+    verify(config: SpecBridgeConfig, options?: VerificationOptions): Promise<VerificationResult>;
+    /**
+     * Verify a single file
+     */
+    verifyFile(filePath: string, decisions: Decision[], severityFilter?: Severity[]): Promise<Violation[]>;
+    /**
+     * Verify multiple files
+     */
+    private verifyFiles;
+    /**
+     * Check if file is excepted from constraint
+     */
+    private isExcepted;
+    /**
+     * Get registry
+     */
+    getRegistry(): Registry;
+}
+/**
+ * Create verification engine
+ */
+declare function createVerificationEngine(registry?: Registry): VerificationEngine;
+
+/**
+ * Base verifier interface
+ */
+
+/**
+ * Context passed to verifiers
+ */
+interface VerificationContext {
+    filePath: string;
+    sourceFile: SourceFile;
+    constraint: Constraint;
+    decisionId: string;
+}
+/**
+ * Verifier interface - all verifiers must implement this
+ */
+interface Verifier {
+    /**
+     * Unique identifier for this verifier
+     */
+    readonly id: string;
+    /**
+     * Human-readable name
+     */
+    readonly name: string;
+    /**
+     * Description of what this verifier checks
+     */
+    readonly description: string;
+    /**
+     * Verify a file against a constraint
+     */
+    verify(ctx: VerificationContext): Promise<Violation[]>;
+}
+/**
+ * Helper to create a violation
+ */
+declare function createViolation(params: {
+    decisionId: string;
+    constraintId: string;
+    type: Constraint['type'];
+    severity: Severity;
+    message: string;
+    file: string;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+    suggestion?: string;
+    autofix?: Violation['autofix'];
+}): Violation;
+
+/**
+ * Naming convention verifier
+ */
+
+declare class NamingVerifier implements Verifier {
+    readonly id = "naming";
+    readonly name = "Naming Convention Verifier";
+    readonly description = "Verifies naming conventions for classes, functions, and variables";
+    verify(ctx: VerificationContext): Promise<Violation[]>;
+}
+
+/**
+ * Import pattern verifier
+ */
+
+declare class ImportsVerifier implements Verifier {
+    readonly id = "imports";
+    readonly name = "Import Pattern Verifier";
+    readonly description = "Verifies import patterns like barrel imports, path aliases, etc.";
+    verify(ctx: VerificationContext): Promise<Violation[]>;
+}
+
+declare class ErrorsVerifier implements Verifier {
+    readonly id = "errors";
+    readonly name = "Error Handling Verifier";
+    readonly description = "Verifies error handling patterns";
+    verify(ctx: VerificationContext): Promise<Violation[]>;
+}
+
+/**
+ * Regex-based verifier for simple pattern matching
+ */
+
+/**
+ * A generic verifier that uses regex patterns from constraint rules
+ * This handles constraints that specify patterns to match or avoid
+ */
+declare class RegexVerifier implements Verifier {
+    readonly id = "regex";
+    readonly name = "Regex Pattern Verifier";
+    readonly description = "Verifies code against regex patterns specified in constraints";
+    verify(ctx: VerificationContext): Promise<Violation[]>;
+}
+
+/**
+ * Verifier exports
+ */
+
+/**
+ * Built-in verifiers registry
+ */
+declare const builtinVerifiers: Record<string, () => Verifier>;
+/**
+ * Get verifier by ID
+ */
+declare function getVerifier(id: string): Verifier | null;
+/**
+ * Get all verifier IDs
+ */
+declare function getVerifierIds(): string[];
+/**
+ * Select appropriate verifier based on constraint rule
+ */
+declare function selectVerifierForConstraint(rule: string, specifiedVerifier?: string): Verifier | null;
+
+/**
+ * Dependency graph for impact analysis
+ */
+
+interface GraphNode {
+    type: 'decision' | 'constraint' | 'file';
+    id: string;
+    edges: string[];
+}
+interface DependencyGraph {
+    nodes: Map<string, GraphNode>;
+    decisionToFiles: Map<string, Set<string>>;
+    fileToDecisions: Map<string, Set<string>>;
+}
+/**
+ * Build dependency graph from decisions and file list
+ */
+declare function buildDependencyGraph(decisions: Decision[], files: string[]): Promise<DependencyGraph>;
+/**
+ * Get files affected by a decision
+ */
+declare function getAffectedFiles(graph: DependencyGraph, decisionId: string): string[];
+/**
+ * Get decisions affecting a file
+ */
+declare function getAffectingDecisions(graph: DependencyGraph, filePath: string): string[];
+/**
+ * Calculate transitive closure for a node
+ */
+declare function getTransitiveDependencies(graph: DependencyGraph, nodeId: string, visited?: Set<string>): string[];
+
+/**
+ * Propagation Engine - Analyze impact of decision changes
+ */
+
+interface PropagationOptions {
+    cwd?: string;
+}
+/**
+ * Propagation Engine class
+ */
+declare class PropagationEngine {
+    private registry;
+    private graph;
+    constructor(registry?: Registry);
+    /**
+     * Initialize the engine with current state
+     */
+    initialize(config: SpecBridgeConfig, options?: PropagationOptions): Promise<void>;
+    /**
+     * Analyze impact of changing a decision
+     */
+    analyzeImpact(decisionId: string, change: 'created' | 'modified' | 'deprecated', config: SpecBridgeConfig, options?: PropagationOptions): Promise<ImpactAnalysis>;
+    /**
+     * Generate migration steps
+     */
+    private generateMigrationSteps;
+    /**
+     * Get dependency graph
+     */
+    getGraph(): DependencyGraph | null;
+}
+/**
+ * Create propagation engine
+ */
+declare function createPropagationEngine(registry?: Registry): PropagationEngine;
+
+/**
+ * Compliance reporter
+ */
+
+interface ReportOptions {
+    includeAll?: boolean;
+    cwd?: string;
+}
+/**
+ * Generate a compliance report
+ */
+declare function generateReport(config: SpecBridgeConfig, options?: ReportOptions): Promise<ComplianceReport>;
+/**
+ * Check if compliance has degraded from previous report
+ */
+declare function checkDegradation(current: ComplianceReport, previous: ComplianceReport | null): {
+    degraded: boolean;
+    details: string[];
+};
+/**
+ * Reporter class for formatting verification results
+ */
+declare class Reporter {
+    /**
+     * Generate formatted report from verification result
+     */
+    generate(result: any, options?: {
+        format?: 'table' | 'json' | 'markdown';
+        includePassedChecks?: boolean;
+        groupBy?: 'severity' | 'file';
+        colorize?: boolean;
+    }): string;
+    /**
+     * Generate compliance overview from multiple results
+     */
+    generateComplianceReport(results: any[]): string;
+    private formatAsTable;
+    private formatAsTableGrouped;
+    private formatAsMarkdown;
+}
+
+/**
+ * Format report for console output
+ */
+declare function formatConsoleReport(report: ComplianceReport): string;
+
+/**
+ * Markdown format for reports
+ */
+
+/**
+ * Format report as Markdown
+ */
+declare function formatMarkdownReport(report: ComplianceReport): string;
+
+/**
+ * Agent context generator
+ */
+
+interface ContextOptions {
+    includeRationale?: boolean;
+    format?: 'markdown' | 'json' | 'mcp';
+    cwd?: string;
+}
+/**
+ * Generate agent context for a file
+ */
+declare function generateContext(filePath: string, config: SpecBridgeConfig, options?: ContextOptions): Promise<AgentContext>;
+/**
+ * Format context as Markdown for agent prompts
+ */
+declare function formatContextAsMarkdown(context: AgentContext): string;
+/**
+ * Format context as JSON
+ */
+declare function formatContextAsJson(context: AgentContext): string;
+/**
+ * Format context for MCP (Model Context Protocol)
+ */
+declare function formatContextAsMcp(context: AgentContext): object;
+/**
+ * Generate context in specified format
+ */
+declare function generateFormattedContext(filePath: string, config: SpecBridgeConfig, options?: ContextOptions): Promise<string>;
+/**
+ * AgentContextGenerator class for test compatibility
+ */
+declare class AgentContextGenerator {
+    /**
+     * Generate context from decisions
+     */
+    generateContext(options: {
+        decisions: any[];
+        filePattern?: string;
+        format?: 'markdown' | 'plain' | 'json';
+        concise?: boolean;
+        minSeverity?: string;
+        includeExamples?: boolean;
+    }): string;
+    /**
+     * Generate prompt suffix for AI agents
+     */
+    generatePromptSuffix(options: {
+        decisions: any[];
+    }): string;
+    /**
+     * Extract relevant decisions for a specific file
+     */
+    extractRelevantDecisions(options: {
+        decisions: any[];
+        filePath: string;
+    }): any[];
+}
+
+/**
+ * Check if a path exists
+ */
+declare function pathExists(path: string): Promise<boolean>;
+/**
+ * Check if a path is a directory
+ */
+declare function isDirectory(path: string): Promise<boolean>;
+/**
+ * Ensure a directory exists
+ */
+declare function ensureDir(path: string): Promise<void>;
+/**
+ * Read a text file
+ */
+declare function readTextFile(path: string): Promise<string>;
+/**
+ * Write a text file, creating directories as needed
+ */
+declare function writeTextFile(path: string, content: string): Promise<void>;
+/**
+ * Read all files in a directory matching a pattern
+ */
+declare function readFilesInDir(dirPath: string, filter?: (filename: string) => boolean): Promise<string[]>;
+/**
+ * Get the .specbridge directory path
+ */
+declare function getSpecBridgeDir(basePath?: string): string;
+/**
+ * Get the decisions directory path
+ */
+declare function getDecisionsDir(basePath?: string): string;
+/**
+ * Get the verifiers directory path
+ */
+declare function getVerifiersDir(basePath?: string): string;
+/**
+ * Get the inferred patterns directory path
+ */
+declare function getInferredDir(basePath?: string): string;
+/**
+ * Get the reports directory path
+ */
+declare function getReportsDir(basePath?: string): string;
+/**
+ * Get the config file path
+ */
+declare function getConfigPath(basePath?: string): string;
+
+/**
+ * YAML utilities with comment preservation
+ */
+
+/**
+ * Parse YAML string to object
+ */
+declare function parseYaml<T = unknown>(content: string): T;
+/**
+ * Stringify object to YAML with nice formatting
+ */
+declare function stringifyYaml(data: unknown, options?: {
+    indent?: number;
+}): string;
+/**
+ * Parse YAML preserving document structure (for editing)
+ */
+declare function parseYamlDocument(content: string): Document;
+/**
+ * Update YAML document preserving comments
+ */
+declare function updateYamlDocument(doc: Document, path: string[], value: unknown): void;
+
+interface GlobOptions {
+    cwd?: string;
+    ignore?: string[];
+    absolute?: boolean;
+    onlyFiles?: boolean;
+}
+/**
+ * Find files matching glob patterns
+ */
+declare function glob(patterns: string | string[], options?: GlobOptions): Promise<string[]>;
+/**
+ * Check if a file path matches a glob pattern
+ */
+declare function matchesPattern(filePath: string, pattern: string): boolean;
+/**
+ * Check if a file path matches any of the given patterns
+ */
+declare function matchesAnyPattern(filePath: string, patterns: string[]): boolean;
+
+export { type AffectedFile, type AgentContext, AgentContextGenerator, AlreadyInitializedError, type Analyzer, AnalyzerNotFoundError, type ApplicableConstraint, type ApplicableDecision, CodeScanner, type ComplianceReport, ConfigError, type Constraint, type ConstraintException, ConstraintExceptionSchema, type ConstraintExceptionSchema_, ConstraintSchema, type ConstraintSchema_, type ConstraintType, ConstraintTypeSchema, type ConstraintTypeSchema_, type ContextOptions, type Decision, type DecisionCompliance, type DecisionContent, DecisionContentSchema, type DecisionContentSchema_, type DecisionFilter, type DecisionMetadata, DecisionMetadataSchema, type DecisionMetadataSchema_, DecisionNotFoundError, DecisionSchema, type DecisionStatus, DecisionStatusSchema, type DecisionStatusSchema_, type DecisionTypeSchema, DecisionValidationError, type DependencyGraph, ErrorsAnalyzer, ErrorsVerifier, FileSystemError, type GlobOptions, type GraphNode, HookError, type ImpactAnalysis, ImportsAnalyzer, ImportsVerifier, InferenceEngine, InferenceError, type InferenceOptions, type InferenceResult, type LevelConfig, LinksSchema, type LoadError, type LoadResult, type LoadedDecision, type MigrationStep, NamingAnalyzer, NamingVerifier, NotInitializedError, type Pattern, type PatternExample, PropagationEngine, type PropagationOptions, RegexVerifier, Registry, type RegistryConstraintMatch, RegistryError, type RegistryOptions, type ReportOptions, Reporter, type ScanOptions, type ScanResult, type ScannedFile, type Severity, SeveritySchema, type SeveritySchema_, type SpecBridgeConfig, SpecBridgeConfigSchema, type SpecBridgeConfigType, SpecBridgeError, StructureAnalyzer, type TrendData, type VerificationConfig, VerificationConfigSchema, type VerificationConfigSchema_, type VerificationContext, VerificationEngine, VerificationError, type VerificationFrequency, VerificationFrequencySchema, type VerificationFrequencySchema_, type VerificationLevel, type VerificationOptions, type VerificationResult, type Verifier, VerifierNotFoundError, type Violation, type ViolationFix, buildDependencyGraph, builtinAnalyzers, builtinVerifiers, calculateConfidence, checkDegradation, createInferenceEngine, createPattern, createPropagationEngine, createRegistry, createScannerFromConfig, createVerificationEngine, createViolation, defaultConfig, ensureDir, extractSnippet, formatConsoleReport, formatContextAsJson, formatContextAsMarkdown, formatContextAsMcp, formatError, formatMarkdownReport, formatValidationErrors, generateContext, generateFormattedContext, generateReport, getAffectedFiles, getAffectingDecisions, getAnalyzer, getAnalyzerIds, getConfigPath, getDecisionsDir, getInferredDir, getReportsDir, getSpecBridgeDir, getTransitiveDependencies, getVerifier, getVerifierIds, getVerifiersDir, glob, isDirectory, loadConfig, loadDecisionFile, loadDecisionsFromDir, matchesAnyPattern, matchesPattern, mergeWithDefaults, parseYaml, parseYamlDocument, pathExists, readFilesInDir, readTextFile, runInference, selectVerifierForConstraint, stringifyYaml, updateYamlDocument, validateConfig, validateDecision, validateDecisionFile, writeTextFile };