vaspera 2.9.0 → 2.10.0

package/dist/autofix/constitution.schema.d.ts

@@ -0,0 +1,441 @@
+/**
+ * Constitution Schema
+ *
+ * Zod schema for autofix constitution files that govern
+ * which patterns can be auto-applied and under what conditions.
+ *
+ * @module autofix/constitution.schema
+ */
+import { z } from "zod";
+/**
+ * Risk tolerance levels for autofix operations
+ */
+export declare const RiskToleranceSchema: z.ZodEnum<["conservative", "moderate", "aggressive"]>;
+/**
+ * Severity levels
+ */
+export declare const SeveritySchema: z.ZodEnum<["info", "low", "medium", "high", "critical"]>;
+/**
+ * Conditions for pattern approval
+ */
+export declare const PatternConditionsSchema: z.ZodOptional<z.ZodObject<{
+    /** Only allow in specific directories */
+    allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Exclude from specific directories */
+    excludedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Maximum lines changed per fix */
+    maxLinesChanged: z.ZodOptional<z.ZodNumber>;
+    /** Only if severity at or above this level */
+    minSeverity: z.ZodOptional<z.ZodEnum<["info", "low", "medium", "high", "critical"]>>;
+}, "strip", z.ZodTypeAny, {
+    minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+    allowedPaths?: string[] | undefined;
+    excludedPaths?: string[] | undefined;
+    maxLinesChanged?: number | undefined;
+}, {
+    minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+    allowedPaths?: string[] | undefined;
+    excludedPaths?: string[] | undefined;
+    maxLinesChanged?: number | undefined;
+}>>;
+/**
+ * Pattern approval configuration
+ */
+export declare const PatternApprovalSchema: z.ZodObject<{
+    /** Pattern ID from FIX_PATTERNS */
+    patternId: z.ZodString;
+    /** Whether this pattern can be auto-applied */
+    autoApprove: z.ZodBoolean;
+    /** Required reviewer if not auto-approved */
+    requiredReviewer: z.ZodOptional<z.ZodString>;
+    /** Additional conditions for auto-approval */
+    conditions: z.ZodOptional<z.ZodObject<{
+        /** Only allow in specific directories */
+        allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Exclude from specific directories */
+        excludedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Maximum lines changed per fix */
+        maxLinesChanged: z.ZodOptional<z.ZodNumber>;
+        /** Only if severity at or above this level */
+        minSeverity: z.ZodOptional<z.ZodEnum<["info", "low", "medium", "high", "critical"]>>;
+    }, "strip", z.ZodTypeAny, {
+        minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+        allowedPaths?: string[] | undefined;
+        excludedPaths?: string[] | undefined;
+        maxLinesChanged?: number | undefined;
+    }, {
+        minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+        allowedPaths?: string[] | undefined;
+        excludedPaths?: string[] | undefined;
+        maxLinesChanged?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    patternId: string;
+    autoApprove: boolean;
+    requiredReviewer?: string | undefined;
+    conditions?: {
+        minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+        allowedPaths?: string[] | undefined;
+        excludedPaths?: string[] | undefined;
+        maxLinesChanged?: number | undefined;
+    } | undefined;
+}, {
+    patternId: string;
+    autoApprove: boolean;
+    requiredReviewer?: string | undefined;
+    conditions?: {
+        minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+        allowedPaths?: string[] | undefined;
+        excludedPaths?: string[] | undefined;
+        maxLinesChanged?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * PR creation rules
+ */
+export declare const PRRulesSchema: z.ZodObject<{
+    /** Require human approval before merge */
+    requireApproval: z.ZodDefault<z.ZodBoolean>;
+    /** Minimum number of approvers */
+    minApprovers: z.ZodDefault<z.ZodNumber>;
+    /** Required labels on all autofix PRs */
+    requiredLabels: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Assignees for autofix PRs */
+    defaultAssignees: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Reviewers for autofix PRs */
+    defaultReviewers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Title prefix for autofix commits */
+    commitPrefix: z.ZodDefault<z.ZodString>;
+    /** Include Co-Authored-By in commits */
+    includeCoAuthor: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum PRs to create in a single run */
+    maxPRsPerRun: z.ZodDefault<z.ZodNumber>;
+    /** Group fixes by this strategy */
+    groupBy: z.ZodDefault<z.ZodEnum<["severity", "file", "pattern", "single"]>>;
+}, "strip", z.ZodTypeAny, {
+    groupBy: "file" | "severity" | "pattern" | "single";
+    requireApproval: boolean;
+    minApprovers: number;
+    requiredLabels: string[];
+    defaultAssignees: string[];
+    defaultReviewers: string[];
+    commitPrefix: string;
+    includeCoAuthor: boolean;
+    maxPRsPerRun: number;
+}, {
+    groupBy?: "file" | "severity" | "pattern" | "single" | undefined;
+    requireApproval?: boolean | undefined;
+    minApprovers?: number | undefined;
+    requiredLabels?: string[] | undefined;
+    defaultAssignees?: string[] | undefined;
+    defaultReviewers?: string[] | undefined;
+    commitPrefix?: string | undefined;
+    includeCoAuthor?: boolean | undefined;
+    maxPRsPerRun?: number | undefined;
+}>;
+/**
+ * Directory-level restrictions
+ */
+export declare const DirectoryRulesSchema: z.ZodObject<{
+    /** Never auto-fix in these directories */
+    neverAutofix: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Always require review in these directories */
+    requireReview: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Skip scanning these directories entirely */
+    ignore: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ignore: string[];
+    neverAutofix: string[];
+    requireReview: string[];
+}, {
+    ignore?: string[] | undefined;
+    neverAutofix?: string[] | undefined;
+    requireReview?: string[] | undefined;
+}>;
+/**
+ * Safety constraints
+ */
+export declare const SafetyConstraintsSchema: z.ZodObject<{
+    /** Require clean git working tree before applying fixes */
+    requireCleanWorkingTree: z.ZodDefault<z.ZodBoolean>;
+    /** Create backup branch before applying fixes */
+    createBackupBranch: z.ZodDefault<z.ZodBoolean>;
+    /** Run tests after applying fixes */
+    runTestsAfterFix: z.ZodDefault<z.ZodBoolean>;
+    /** Test command to run */
+    testCommand: z.ZodDefault<z.ZodString>;
+    /** Revert fix if tests fail */
+    revertOnTestFailure: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum total files to modify in one run */
+    maxFilesPerRun: z.ZodDefault<z.ZodNumber>;
+    /** Dry run by default (require explicit --apply) */
+    dryRunDefault: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    requireCleanWorkingTree: boolean;
+    createBackupBranch: boolean;
+    runTestsAfterFix: boolean;
+    testCommand: string;
+    revertOnTestFailure: boolean;
+    maxFilesPerRun: number;
+    dryRunDefault: boolean;
+}, {
+    requireCleanWorkingTree?: boolean | undefined;
+    createBackupBranch?: boolean | undefined;
+    runTestsAfterFix?: boolean | undefined;
+    testCommand?: string | undefined;
+    revertOnTestFailure?: boolean | undefined;
+    maxFilesPerRun?: number | undefined;
+    dryRunDefault?: boolean | undefined;
+}>;
+/**
+ * Full constitution configuration
+ */
+export declare const ConstitutionSchema: z.ZodObject<{
+    /** Version of the constitution schema */
+    version: z.ZodLiteral<"1.0">;
+    /** Organization name */
+    organization: z.ZodOptional<z.ZodString>;
+    /** Overall risk tolerance */
+    riskTolerance: z.ZodDefault<z.ZodEnum<["conservative", "moderate", "aggressive"]>>;
+    /** Pattern-specific approvals */
+    patterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Pattern ID from FIX_PATTERNS */
+        patternId: z.ZodString;
+        /** Whether this pattern can be auto-applied */
+        autoApprove: z.ZodBoolean;
+        /** Required reviewer if not auto-approved */
+        requiredReviewer: z.ZodOptional<z.ZodString>;
+        /** Additional conditions for auto-approval */
+        conditions: z.ZodOptional<z.ZodObject<{
+            /** Only allow in specific directories */
+            allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Exclude from specific directories */
+            excludedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** Maximum lines changed per fix */
+            maxLinesChanged: z.ZodOptional<z.ZodNumber>;
+            /** Only if severity at or above this level */
+            minSeverity: z.ZodOptional<z.ZodEnum<["info", "low", "medium", "high", "critical"]>>;
+        }, "strip", z.ZodTypeAny, {
+            minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+            allowedPaths?: string[] | undefined;
+            excludedPaths?: string[] | undefined;
+            maxLinesChanged?: number | undefined;
+        }, {
+            minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+            allowedPaths?: string[] | undefined;
+            excludedPaths?: string[] | undefined;
+            maxLinesChanged?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        patternId: string;
+        autoApprove: boolean;
+        requiredReviewer?: string | undefined;
+        conditions?: {
+            minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+            allowedPaths?: string[] | undefined;
+            excludedPaths?: string[] | undefined;
+            maxLinesChanged?: number | undefined;
+        } | undefined;
+    }, {
+        patternId: string;
+        autoApprove: boolean;
+        requiredReviewer?: string | undefined;
+        conditions?: {
+            minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+            allowedPaths?: string[] | undefined;
+            excludedPaths?: string[] | undefined;
+            maxLinesChanged?: number | undefined;
+        } | undefined;
+    }>, "many">>;
+    /** PR creation rules */
+    prRules: z.ZodDefault<z.ZodObject<{
+        /** Require human approval before merge */
+        requireApproval: z.ZodDefault<z.ZodBoolean>;
+        /** Minimum number of approvers */
+        minApprovers: z.ZodDefault<z.ZodNumber>;
+        /** Required labels on all autofix PRs */
+        requiredLabels: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Assignees for autofix PRs */
+        defaultAssignees: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Reviewers for autofix PRs */
+        defaultReviewers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Title prefix for autofix commits */
+        commitPrefix: z.ZodDefault<z.ZodString>;
+        /** Include Co-Authored-By in commits */
+        includeCoAuthor: z.ZodDefault<z.ZodBoolean>;
+        /** Maximum PRs to create in a single run */
+        maxPRsPerRun: z.ZodDefault<z.ZodNumber>;
+        /** Group fixes by this strategy */
+        groupBy: z.ZodDefault<z.ZodEnum<["severity", "file", "pattern", "single"]>>;
+    }, "strip", z.ZodTypeAny, {
+        groupBy: "file" | "severity" | "pattern" | "single";
+        requireApproval: boolean;
+        minApprovers: number;
+        requiredLabels: string[];
+        defaultAssignees: string[];
+        defaultReviewers: string[];
+        commitPrefix: string;
+        includeCoAuthor: boolean;
+        maxPRsPerRun: number;
+    }, {
+        groupBy?: "file" | "severity" | "pattern" | "single" | undefined;
+        requireApproval?: boolean | undefined;
+        minApprovers?: number | undefined;
+        requiredLabels?: string[] | undefined;
+        defaultAssignees?: string[] | undefined;
+        defaultReviewers?: string[] | undefined;
+        commitPrefix?: string | undefined;
+        includeCoAuthor?: boolean | undefined;
+        maxPRsPerRun?: number | undefined;
+    }>>;
+    /** Directory restrictions */
+    directories: z.ZodDefault<z.ZodObject<{
+        /** Never auto-fix in these directories */
+        neverAutofix: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Always require review in these directories */
+        requireReview: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Skip scanning these directories entirely */
+        ignore: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        ignore: string[];
+        neverAutofix: string[];
+        requireReview: string[];
+    }, {
+        ignore?: string[] | undefined;
+        neverAutofix?: string[] | undefined;
+        requireReview?: string[] | undefined;
+    }>>;
+    /** Safety constraints */
+    safety: z.ZodDefault<z.ZodObject<{
+        /** Require clean git working tree before applying fixes */
+        requireCleanWorkingTree: z.ZodDefault<z.ZodBoolean>;
+        /** Create backup branch before applying fixes */
+        createBackupBranch: z.ZodDefault<z.ZodBoolean>;
+        /** Run tests after applying fixes */
+        runTestsAfterFix: z.ZodDefault<z.ZodBoolean>;
+        /** Test command to run */
+        testCommand: z.ZodDefault<z.ZodString>;
+        /** Revert fix if tests fail */
+        revertOnTestFailure: z.ZodDefault<z.ZodBoolean>;
+        /** Maximum total files to modify in one run */
+        maxFilesPerRun: z.ZodDefault<z.ZodNumber>;
+        /** Dry run by default (require explicit --apply) */
+        dryRunDefault: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        requireCleanWorkingTree: boolean;
+        createBackupBranch: boolean;
+        runTestsAfterFix: boolean;
+        testCommand: string;
+        revertOnTestFailure: boolean;
+        maxFilesPerRun: number;
+        dryRunDefault: boolean;
+    }, {
+        requireCleanWorkingTree?: boolean | undefined;
+        createBackupBranch?: boolean | undefined;
+        runTestsAfterFix?: boolean | undefined;
+        testCommand?: string | undefined;
+        revertOnTestFailure?: boolean | undefined;
+        maxFilesPerRun?: number | undefined;
+        dryRunDefault?: boolean | undefined;
+    }>>;
+    /** Custom metadata to include in PRs */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: "1.0";
+    patterns: {
+        patternId: string;
+        autoApprove: boolean;
+        requiredReviewer?: string | undefined;
+        conditions?: {
+            minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+            allowedPaths?: string[] | undefined;
+            excludedPaths?: string[] | undefined;
+            maxLinesChanged?: number | undefined;
+        } | undefined;
+    }[];
+    riskTolerance: "moderate" | "aggressive" | "conservative";
+    prRules: {
+        groupBy: "file" | "severity" | "pattern" | "single";
+        requireApproval: boolean;
+        minApprovers: number;
+        requiredLabels: string[];
+        defaultAssignees: string[];
+        defaultReviewers: string[];
+        commitPrefix: string;
+        includeCoAuthor: boolean;
+        maxPRsPerRun: number;
+    };
+    directories: {
+        ignore: string[];
+        neverAutofix: string[];
+        requireReview: string[];
+    };
+    safety: {
+        requireCleanWorkingTree: boolean;
+        createBackupBranch: boolean;
+        runTestsAfterFix: boolean;
+        testCommand: string;
+        revertOnTestFailure: boolean;
+        maxFilesPerRun: number;
+        dryRunDefault: boolean;
+    };
+    metadata?: Record<string, string> | undefined;
+    organization?: string | undefined;
+}, {
+    version: "1.0";
+    metadata?: Record<string, string> | undefined;
+    patterns?: {
+        patternId: string;
+        autoApprove: boolean;
+        requiredReviewer?: string | undefined;
+        conditions?: {
+            minSeverity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+            allowedPaths?: string[] | undefined;
+            excludedPaths?: string[] | undefined;
+            maxLinesChanged?: number | undefined;
+        } | undefined;
+    }[] | undefined;
+    organization?: string | undefined;
+    riskTolerance?: "moderate" | "aggressive" | "conservative" | undefined;
+    prRules?: {
+        groupBy?: "file" | "severity" | "pattern" | "single" | undefined;
+        requireApproval?: boolean | undefined;
+        minApprovers?: number | undefined;
+        requiredLabels?: string[] | undefined;
+        defaultAssignees?: string[] | undefined;
+        defaultReviewers?: string[] | undefined;
+        commitPrefix?: string | undefined;
+        includeCoAuthor?: boolean | undefined;
+        maxPRsPerRun?: number | undefined;
+    } | undefined;
+    directories?: {
+        ignore?: string[] | undefined;
+        neverAutofix?: string[] | undefined;
+        requireReview?: string[] | undefined;
+    } | undefined;
+    safety?: {
+        requireCleanWorkingTree?: boolean | undefined;
+        createBackupBranch?: boolean | undefined;
+        runTestsAfterFix?: boolean | undefined;
+        testCommand?: string | undefined;
+        revertOnTestFailure?: boolean | undefined;
+        maxFilesPerRun?: number | undefined;
+        dryRunDefault?: boolean | undefined;
+    } | undefined;
+}>;
+/**
+ * Inferred types from schemas
+ */
+export type RiskTolerance = z.infer<typeof RiskToleranceSchema>;
+export type Severity = z.infer<typeof SeveritySchema>;
+export type PatternConditions = z.infer<typeof PatternConditionsSchema>;
+export type PatternApproval = z.infer<typeof PatternApprovalSchema>;
+export type PRRules = z.infer<typeof PRRulesSchema>;
+export type DirectoryRules = z.infer<typeof DirectoryRulesSchema>;
+export type SafetyConstraints = z.infer<typeof SafetyConstraintsSchema>;
+export type Constitution = z.infer<typeof ConstitutionSchema>;
+/**
+ * Default constitution with conservative settings
+ */
+export declare const DEFAULT_CONSTITUTION: Constitution;
+//# sourceMappingURL=constitution.schema.d.ts.map

package/dist/autofix/constitution.schema.d.ts.map

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

package/dist/autofix/constitution.schema.js

@@ -0,0 +1,144 @@
+/**
+ * Constitution Schema
+ *
+ * Zod schema for autofix constitution files that govern
+ * which patterns can be auto-applied and under what conditions.
+ *
+ * @module autofix/constitution.schema
+ */
+import { z } from "zod";
+/**
+ * Risk tolerance levels for autofix operations
+ */
+export const RiskToleranceSchema = z.enum([
+    "conservative", // Only auto-apply patterns marked safeToAutoApply with low risk
+    "moderate", // Auto-apply safe patterns and low/medium risk
+    "aggressive", // Auto-apply all patterns
+]);
+/**
+ * Severity levels
+ */
+export const SeveritySchema = z.enum([
+    "info",
+    "low",
+    "medium",
+    "high",
+    "critical",
+]);
+/**
+ * Conditions for pattern approval
+ */
+export const PatternConditionsSchema = z.object({
+    /** Only allow in specific directories */
+    allowedPaths: z.array(z.string()).optional(),
+    /** Exclude from specific directories */
+    excludedPaths: z.array(z.string()).optional(),
+    /** Maximum lines changed per fix */
+    maxLinesChanged: z.number().positive().optional(),
+    /** Only if severity at or above this level */
+    minSeverity: SeveritySchema.optional(),
+}).optional();
+/**
+ * Pattern approval configuration
+ */
+export const PatternApprovalSchema = z.object({
+    /** Pattern ID from FIX_PATTERNS */
+    patternId: z.string().min(1),
+    /** Whether this pattern can be auto-applied */
+    autoApprove: z.boolean(),
+    /** Required reviewer if not auto-approved */
+    requiredReviewer: z.string().optional(),
+    /** Additional conditions for auto-approval */
+    conditions: PatternConditionsSchema,
+});
+/**
+ * PR creation rules
+ */
+export const PRRulesSchema = z.object({
+    /** Require human approval before merge */
+    requireApproval: z.boolean().default(true),
+    /** Minimum number of approvers */
+    minApprovers: z.number().min(0).default(1),
+    /** Required labels on all autofix PRs */
+    requiredLabels: z.array(z.string()).default(["autofix", "security"]),
+    /** Assignees for autofix PRs */
+    defaultAssignees: z.array(z.string()).default([]),
+    /** Reviewers for autofix PRs */
+    defaultReviewers: z.array(z.string()).default([]),
+    /** Title prefix for autofix commits */
+    commitPrefix: z.string().default("fix(security):"),
+    /** Include Co-Authored-By in commits */
+    includeCoAuthor: z.boolean().default(true),
+    /** Maximum PRs to create in a single run */
+    maxPRsPerRun: z.number().min(1).default(10),
+    /** Group fixes by this strategy */
+    groupBy: z.enum(["severity", "file", "pattern", "single"]).default("severity"),
+});
+/**
+ * Directory-level restrictions
+ */
+export const DirectoryRulesSchema = z.object({
+    /** Never auto-fix in these directories */
+    neverAutofix: z.array(z.string()).default([
+        "node_modules",
+        "vendor",
+        ".git",
+        "dist",
+        "build",
+    ]),
+    /** Always require review in these directories */
+    requireReview: z.array(z.string()).default([
+        "src/auth",
+        "src/security",
+        "src/crypto",
+    ]),
+    /** Skip scanning these directories entirely */
+    ignore: z.array(z.string()).default([]),
+});
+/**
+ * Safety constraints
+ */
+export const SafetyConstraintsSchema = z.object({
+    /** Require clean git working tree before applying fixes */
+    requireCleanWorkingTree: z.boolean().default(true),
+    /** Create backup branch before applying fixes */
+    createBackupBranch: z.boolean().default(true),
+    /** Run tests after applying fixes */
+    runTestsAfterFix: z.boolean().default(true),
+    /** Test command to run */
+    testCommand: z.string().default("npm test"),
+    /** Revert fix if tests fail */
+    revertOnTestFailure: z.boolean().default(true),
+    /** Maximum total files to modify in one run */
+    maxFilesPerRun: z.number().min(1).default(20),
+    /** Dry run by default (require explicit --apply) */
+    dryRunDefault: z.boolean().default(true),
+});
+/**
+ * Full constitution configuration
+ */
+export const ConstitutionSchema = z.object({
+    /** Version of the constitution schema */
+    version: z.literal("1.0"),
+    /** Organization name */
+    organization: z.string().optional(),
+    /** Overall risk tolerance */
+    riskTolerance: RiskToleranceSchema.default("conservative"),
+    /** Pattern-specific approvals */
+    patterns: z.array(PatternApprovalSchema).default([]),
+    /** PR creation rules */
+    prRules: PRRulesSchema.default({}),
+    /** Directory restrictions */
+    directories: DirectoryRulesSchema.default({}),
+    /** Safety constraints */
+    safety: SafetyConstraintsSchema.default({}),
+    /** Custom metadata to include in PRs */
+    metadata: z.record(z.string(), z.string()).optional(),
+});
+/**
+ * Default constitution with conservative settings
+ */
+export const DEFAULT_CONSTITUTION = ConstitutionSchema.parse({
+    version: "1.0",
+});
+//# sourceMappingURL=constitution.schema.js.map

package/dist/autofix/constitution.schema.js.map

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

package/dist/autofix/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Autofix PR Integration
+ *
+ * Automated PR creation with AI-powered security fixes.
+ *
+ * @module autofix
+ */
+export type { AutofixGroupBy, AutofixPRConfig, AutofixPRResult, AutofixGroup, BatchPRResult, GitResult, BranchInfo, AutofixCommit, PRMetadata, } from "./types.js";
+export { DEFAULT_AUTOFIX_PR_CONFIG } from "./types.js";
+export { git, isGitAvailable, isGitRepo, getCurrentBranch, getDefaultBranch, branchExists, remoteBranchExists, createBranch, checkoutBranch, deleteBranch, stageFiles, getModifiedFiles, getStagedFiles, isWorkingTreeClean, pushBranch, stash, stashPop, getBranchInfo, resetToCommit, getRemoteUrl, parseGitHubRemote, generateBranchName, ensureCleanWorkingTree, restoreOriginalState, } from "./branch-manager.js";
+export { generateCommitMessage, generateCommitBody, createCommit, generatePRTitle, generatePRBody, groupFixesBySeverity, groupFixesByFile, groupFixesByPattern, } from "./commit-generator.js";
+export { isGhCliAvailable, isGhAuthenticated, groupFindings, createAutofixPR, createAutofixPRs, previewAutofixPRs, } from "./pr-generator.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/autofix/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,YAAY,EACV,cAAc,EACd,eAAe,EACf,eAAe,EACf,YAAY,EACZ,aAAa,EACb,SAAS,EACT,UAAU,EACV,aAAa,EACb,UAAU,GACX,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAGvD,OAAO,EACL,GAAG,EACH,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,KAAK,EACL,QAAQ,EACR,aAAa,EACb,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC"}

package/dist/autofix/index.js

@@ -0,0 +1,15 @@
+/**
+ * Autofix PR Integration
+ *
+ * Automated PR creation with AI-powered security fixes.
+ *
+ * @module autofix
+ */
+export { DEFAULT_AUTOFIX_PR_CONFIG } from "./types.js";
+// Branch Manager
+export { git, isGitAvailable, isGitRepo, getCurrentBranch, getDefaultBranch, branchExists, remoteBranchExists, createBranch, checkoutBranch, deleteBranch, stageFiles, getModifiedFiles, getStagedFiles, isWorkingTreeClean, pushBranch, stash, stashPop, getBranchInfo, resetToCommit, getRemoteUrl, parseGitHubRemote, generateBranchName, ensureCleanWorkingTree, restoreOriginalState, } from "./branch-manager.js";
+// Commit Generator
+export { generateCommitMessage, generateCommitBody, createCommit, generatePRTitle, generatePRBody, groupFixesBySeverity, groupFixesByFile, groupFixesByPattern, } from "./commit-generator.js";
+// PR Generator
+export { isGhCliAvailable, isGhAuthenticated, groupFindings, createAutofixPR, createAutofixPRs, previewAutofixPRs, } from "./pr-generator.js";
+//# sourceMappingURL=index.js.map

package/dist/autofix/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/autofix/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAeH,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEvD,iBAAiB;AACjB,OAAO,EACL,GAAG,EACH,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,KAAK,EACL,QAAQ,EACR,aAAa,EACb,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAE7B,mBAAmB;AACnB,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAE/B,eAAe;AACf,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC"}