@eddacraft/anvil-core 0.1.0

package/dist/config/loader.js

@@ -0,0 +1,76 @@
+/**
+ * Configuration Loader
+ *
+ * Loads configuration from files and environment variables.
+ * This is a placeholder - actual implementation will be enhanced.
+ */
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('config');
+/**
+ * Configuration loader class
+ */
+export class ConfigLoader {
+    _options;
+    config = new Map();
+    constructor(options = {}) {
+        this._options = {
+            baseDir: options.baseDir ?? process.cwd(),
+            envPrefix: options.envPrefix ?? 'ANVIL_',
+            fileNames: options.fileNames ?? [
+                '.anvilrc',
+                '.anvilrc.yaml',
+                '.anvilrc.json',
+                'anvil.config.js',
+            ],
+        };
+        debug('ConfigLoader created', {
+            baseDir: this._options.baseDir,
+            envPrefix: this._options.envPrefix,
+        });
+    }
+    get options() {
+        return this._options;
+    }
+    /**
+     * Get a configuration value
+     */
+    get(key) {
+        const entry = this.config.get(key);
+        return entry?.value;
+    }
+    /**
+     * Get a configuration value with a default
+     */
+    getOrDefault(key, defaultValue) {
+        return this.get(key) ?? defaultValue;
+    }
+    /**
+     * Check if a configuration key exists
+     */
+    has(key) {
+        return this.config.has(key);
+    }
+    /**
+     * Set a configuration value
+     */
+    set(key, value, source = 'default') {
+        debug('config set', { key, source });
+        this.config.set(key, { value, source });
+    }
+    /**
+     * Get all configuration values
+     */
+    getAll() {
+        const result = {};
+        for (const [key, entry] of this.config) {
+            result[key] = entry.value;
+        }
+        return result;
+    }
+}
+/**
+ * Create a configuration loader
+ */
+export function createConfigLoader(options) {
+    return new ConfigLoader(options);
+}

package/dist/config/nudge-config.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Nudge configuration
+ *
+ * Controls coaching nudge behaviour across CLI, MCP, and IDE surfaces.
+ */
+/**
+ * Severity threshold for nudge display.
+ * Only warnings at or above this severity will show nudges.
+ * Ordered: error > warning > info
+ */
+export type NudgeSeverityThreshold = 'error' | 'warning' | 'info';
+/**
+ * Nudge configuration options
+ */
+export interface NudgeConfig {
+    /** Whether nudges are enabled (default: true) */
+    enabled: boolean;
+    /** Whether interactive mode is on by default in CLI (default: false) */
+    interactive: boolean;
+    /** Minimum severity to show nudges for (default: 'warning') */
+    severityThreshold: NudgeSeverityThreshold;
+}
+/**
+ * Default nudge configuration
+ */
+export declare const DEFAULT_NUDGE_CONFIG: Readonly<NudgeConfig>;
+/**
+ * Check whether a warning severity meets the nudge threshold.
+ *
+ * @param warningSeverity - The severity of the warning
+ * @param threshold - The minimum severity threshold
+ * @returns true if the warning severity is at or above the threshold
+ */
+export declare function meetsNudgeThreshold(warningSeverity: string, threshold: NudgeSeverityThreshold): boolean;
+//# sourceMappingURL=nudge-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nudge-config.d.ts","sourceRoot":"","sources":["../../src/config/nudge-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,WAAW,EAAE,OAAO,CAAC;IACrB,+DAA+D;IAC/D,iBAAiB,EAAE,sBAAsB,CAAC;CAC3C;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAItD,CAAC;AAYF;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,sBAAsB,GAChC,OAAO,CAIT"}

package/dist/config/nudge-config.js

@@ -0,0 +1,34 @@
+/**
+ * Nudge configuration
+ *
+ * Controls coaching nudge behaviour across CLI, MCP, and IDE surfaces.
+ */
+/**
+ * Default nudge configuration
+ */
+export const DEFAULT_NUDGE_CONFIG = {
+    enabled: true,
+    interactive: false,
+    severityThreshold: 'warning',
+};
+/**
+ * Severity ordering for threshold comparison.
+ * Higher number = higher severity.
+ */
+const SEVERITY_ORDER = {
+    info: 0,
+    warning: 1,
+    error: 2,
+};
+/**
+ * Check whether a warning severity meets the nudge threshold.
+ *
+ * @param warningSeverity - The severity of the warning
+ * @param threshold - The minimum severity threshold
+ * @returns true if the warning severity is at or above the threshold
+ */
+export function meetsNudgeThreshold(warningSeverity, threshold) {
+    const warningLevel = SEVERITY_ORDER[warningSeverity] ?? -1;
+    const thresholdLevel = SEVERITY_ORDER[threshold];
+    return warningLevel >= thresholdLevel;
+}

package/dist/config/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Configuration types
+ */
+/**
+ * Configuration source type
+ */
+export type ConfigSource = 'file' | 'env' | 'default';
+/**
+ * Configuration entry with metadata
+ */
+export interface ConfigEntry<T = unknown> {
+    /** The configuration value */
+    value: T;
+    /** Where the value came from */
+    source: ConfigSource;
+    /** Path to the configuration file (if file source) */
+    filePath?: string;
+}
+/**
+ * Configuration loader options
+ */
+export interface ConfigLoaderOptions {
+    /** Base directory for configuration files */
+    baseDir?: string;
+    /** Environment variable prefix */
+    envPrefix?: string;
+    /** Configuration file names to search for */
+    fileNames?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,OAAO;IACtC,8BAA8B;IAC9B,KAAK,EAAE,CAAC,CAAC;IACT,gCAAgC;IAChC,MAAM,EAAE,YAAY,CAAC;IACrB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kCAAkC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB"}

package/dist/config/types.js

@@ -0,0 +1,4 @@
+/**
+ * Configuration types
+ */
+export {};

package/dist/contracts/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Contracts — schemas, types, and events.
+ * Formerly @eddacraft/anvil-contracts, now co-located inside @eddacraft/anvil-core.
+ *
+ * Warning-related types (Warning, WarningResult, Location, etc.) are NOT
+ * re-exported here because they are already provided by the antipattern module
+ * with additional scanner-specific extensions.
+ */
+export { APSPlanSchema, APS_SCHEMA_VERSION, ChangeTypeSchema, ChangeSchema, ProvenanceSchema, ValidationSchema, EvidenceEntrySchema, EvidenceSchema, ApprovalSchema, ExecutionResultSchema, validatePlan, createPlan, } from './schemas/aps.schema.js';
+export type { APSPlan, Change, ChangeType, Provenance, Validation, EvidenceEntry, Evidence, Approval, ExecutionResult, SchemaValidationResult, } from './schemas/aps.schema.js';
+export { generateJSONSchema } from './schemas/json-schema.js';
+export type { GateConfig, GateCheck, GateResult, GateResultDetails, GateRunResult, CheckContext, PlanData, WatchConfig, PolicyConfig, PolicyBundleConfig, PolicyVerificationConfig, SignatureAlgorithm, StackConfig, StackLayerConfig, StackValidationConfig, ArchitectureContextBase, NormaliseFilesOptions, } from './types/gate.types.js';
+export { getWarningsFromResult, hasBlockingWarnings } from './types/gate.types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,YAAY,EACZ,UAAU,GACX,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,OAAO,EACP,MAAM,EACN,UAAU,EACV,UAAU,EACV,UAAU,EACV,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG9D,YAAY,EACV,UAAU,EACV,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/contracts/index.js

@@ -0,0 +1,13 @@
+/**
+ * Contracts — schemas, types, and events.
+ * Formerly @eddacraft/anvil-contracts, now co-located inside @eddacraft/anvil-core.
+ *
+ * Warning-related types (Warning, WarningResult, Location, etc.) are NOT
+ * re-exported here because they are already provided by the antipattern module
+ * with additional scanner-specific extensions.
+ */
+// APS schemas & helpers
+export { APSPlanSchema, APS_SCHEMA_VERSION, ChangeTypeSchema, ChangeSchema, ProvenanceSchema, ValidationSchema, EvidenceEntrySchema, EvidenceSchema, ApprovalSchema, ExecutionResultSchema, validatePlan, createPlan, } from './schemas/aps.schema.js';
+// JSON Schema generation
+export { generateJSONSchema } from './schemas/json-schema.js';
+export { getWarningsFromResult, hasBlockingWarnings } from './types/gate.types.js';

package/dist/contracts/schemas/aps.schema.d.ts

@@ -0,0 +1,269 @@
+import { z } from 'zod';
+/**
+ * Change type enumeration for proposed changes
+ */
+export declare const ChangeTypeSchema: z.ZodEnum<{
+    file_create: "file_create";
+    file_update: "file_update";
+    file_delete: "file_delete";
+    config_update: "config_update";
+    dependency_add: "dependency_add";
+    dependency_remove: "dependency_remove";
+    dependency_update: "dependency_update";
+    script_execute: "script_execute";
+}>;
+/**
+ * Individual change object schema
+ */
+export declare const ChangeSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        file_create: "file_create";
+        file_update: "file_update";
+        file_delete: "file_delete";
+        config_update: "config_update";
+        dependency_add: "dependency_add";
+        dependency_remove: "dependency_remove";
+        dependency_update: "dependency_update";
+        script_execute: "script_execute";
+    }>;
+    path: z.ZodString;
+    description: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    diff: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Provenance information for audit trail
+ */
+export declare const ProvenanceSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+        cli: "cli";
+        api: "api";
+        automation: "automation";
+        manual: "manual";
+    }>;
+    version: z.ZodString;
+    repository: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    commit: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Validation requirements and checks
+ */
+export declare const ValidationSchema: z.ZodObject<{
+    required_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    policy_version: z.ZodOptional<z.ZodString>;
+    skip_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    custom_rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Evidence entry for gate results
+ */
+export declare const EvidenceEntrySchema: z.ZodObject<{
+    check: z.ZodString;
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        skipped: "skipped";
+        warning: "warning";
+    }>;
+    timestamp: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Evidence bundle containing all gate results
+ */
+export declare const EvidenceSchema: z.ZodObject<{
+    gate_version: z.ZodString;
+    timestamp: z.ZodString;
+    overall_status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        partial: "partial";
+    }>;
+    checks: z.ZodArray<z.ZodObject<{
+        check: z.ZodString;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+            warning: "warning";
+        }>;
+        timestamp: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    summary: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Approval information
+ */
+export declare const ApprovalSchema: z.ZodObject<{
+    approved: z.ZodBoolean;
+    approved_by: z.ZodOptional<z.ZodString>;
+    approved_at: z.ZodOptional<z.ZodString>;
+    approval_notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Execution result for apply/rollback operations
+ */
+export declare const ExecutionResultSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        apply: "apply";
+        rollback: "rollback";
+        "dry-run": "dry-run";
+    }>;
+    status: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        partial: "partial";
+    }>;
+    timestamp: z.ZodString;
+    executed_by: z.ZodOptional<z.ZodString>;
+    changes_applied: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    changes_failed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rollback_point: z.ZodOptional<z.ZodString>;
+    logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Main APS Plan Schema with branding for type safety
+ */
+export declare const APSPlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    hash: z.ZodString;
+    intent: z.ZodString;
+    schema_version: z.ZodLiteral<"0.1.0">;
+    proposed_changes: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            file_create: "file_create";
+            file_update: "file_update";
+            file_delete: "file_delete";
+            config_update: "config_update";
+            dependency_add: "dependency_add";
+            dependency_remove: "dependency_remove";
+            dependency_update: "dependency_update";
+            script_execute: "script_execute";
+        }>;
+        path: z.ZodString;
+        description: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        diff: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    provenance: z.ZodObject<{
+        timestamp: z.ZodString;
+        author: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            cli: "cli";
+            api: "api";
+            automation: "automation";
+            manual: "manual";
+        }>;
+        version: z.ZodString;
+        repository: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    validations: z.ZodObject<{
+        required_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        policy_version: z.ZodOptional<z.ZodString>;
+        skip_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        custom_rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        gate_version: z.ZodString;
+        timestamp: z.ZodString;
+        overall_status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            partial: "partial";
+        }>;
+        checks: z.ZodArray<z.ZodObject<{
+            check: z.ZodString;
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+                warning: "warning";
+            }>;
+            timestamp: z.ZodString;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        summary: z.ZodOptional<z.ZodString>;
+        artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        approved: z.ZodBoolean;
+        approved_by: z.ZodOptional<z.ZodString>;
+        approved_at: z.ZodOptional<z.ZodString>;
+        approval_notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    executions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        operation: z.ZodEnum<{
+            apply: "apply";
+            rollback: "rollback";
+            "dry-run": "dry-run";
+        }>;
+        status: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+            partial: "partial";
+        }>;
+        timestamp: z.ZodString;
+        executed_by: z.ZodOptional<z.ZodString>;
+        changes_applied: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        changes_failed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        rollback_point: z.ZodOptional<z.ZodString>;
+        logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+/**
+ * Type exports - automatically inferred from Zod schemas
+ */
+export type ChangeType = z.infer<typeof ChangeTypeSchema>;
+export type Change = z.infer<typeof ChangeSchema>;
+export type Provenance = z.infer<typeof ProvenanceSchema>;
+export type Validation = z.infer<typeof ValidationSchema>;
+export type EvidenceEntry = z.infer<typeof EvidenceEntrySchema>;
+export type Evidence = z.infer<typeof EvidenceSchema>;
+export type Approval = z.infer<typeof ApprovalSchema>;
+export type ExecutionResult = z.infer<typeof ExecutionResultSchema>;
+export type APSPlan = z.infer<typeof APSPlanSchema>;
+/**
+ * Validation result type for consistent error handling
+ */
+export interface SchemaValidationResult {
+    success: boolean;
+    data?: APSPlan;
+    errors?: Array<{
+        path: string;
+        message: string;
+        code?: string;
+    }>;
+}
+/**
+ * Parse and validate a plan with user-friendly error formatting
+ */
+export declare function validatePlan(data: unknown): SchemaValidationResult;
+/**
+ * Create a new plan with defaults
+ */
+export declare function createPlan(params: {
+    id: string;
+    intent: string;
+    provenance: Provenance;
+    changes?: Change[];
+    validations?: Validation;
+}): Omit<APSPlan, 'hash'>;
+/**
+ * Schema version for external reference
+ */
+export declare const APS_SCHEMA_VERSION: "0.1.0";
+//# sourceMappingURL=aps.schema.d.ts.map

package/dist/contracts/schemas/aps.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aps.schema.d.ts","sourceRoot":"","sources":["../../../src/contracts/schemas/aps.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;EAS3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;iBAUvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;iBAQ3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;iBAK3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;iBAM9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;iBAUzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAShC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4Cf,CAAC;AAGZ;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,sBAAsB,CAqBlE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,CAAC,EAAE,UAAU,CAAC;CAC1B,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAYxB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,SAAiB,CAAC"}

package/dist/contracts/schemas/aps.schema.js

@@ -0,0 +1,183 @@
+import { z } from 'zod';
+/**
+ * Schema version - using literal type for strict versioning
+ */
+const SCHEMA_VERSION = '0.1.0';
+/**
+ * Change type enumeration for proposed changes
+ */
+export const ChangeTypeSchema = z.enum([
+    'file_create',
+    'file_update',
+    'file_delete',
+    'config_update',
+    'dependency_add',
+    'dependency_remove',
+    'dependency_update',
+    'script_execute',
+]);
+/**
+ * Individual change object schema
+ */
+export const ChangeSchema = z.object({
+    type: ChangeTypeSchema,
+    path: z.string().describe('File or resource path affected by the change'),
+    description: z.string().describe('Human-readable description of the change'),
+    content: z.string().optional().describe('New content for file changes'),
+    diff: z.string().optional().describe('Unified diff for updates'),
+    metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Additional change-specific metadata'),
+});
+/**
+ * Provenance information for audit trail
+ */
+export const ProvenanceSchema = z.object({
+    timestamp: z.string().datetime().describe('ISO 8601 timestamp of plan creation'),
+    author: z.string().optional().describe('User or system that created the plan'),
+    source: z.enum(['cli', 'api', 'automation', 'manual']).describe('Origin of the plan'),
+    version: z.string().describe('Version of the tool that created the plan'),
+    repository: z.string().optional().describe('Repository URL or identifier'),
+    branch: z.string().optional().describe('Git branch name'),
+    commit: z.string().optional().describe('Git commit hash'),
+});
+/**
+ * Validation requirements and checks
+ */
+export const ValidationSchema = z.object({
+    required_checks: z.array(z.string()).default([]).describe('List of required validation checks'),
+    policy_version: z.string().optional().describe('Version of the policy bundle to use'),
+    skip_checks: z.array(z.string()).default([]).describe('Checks to skip for this plan'),
+    custom_rules: z.record(z.string(), z.unknown()).optional().describe('Custom validation rules'),
+});
+/**
+ * Evidence entry for gate results
+ */
+export const EvidenceEntrySchema = z.object({
+    check: z.string().describe('Name of the check performed'),
+    status: z.enum(['passed', 'failed', 'skipped', 'warning']).describe('Result status'),
+    timestamp: z.string().datetime().describe('When the check was performed'),
+    details: z.record(z.string(), z.unknown()).optional().describe('Detailed check results'),
+    message: z.string().optional().describe('Human-readable result message'),
+});
+/**
+ * Evidence bundle containing all gate results
+ */
+export const EvidenceSchema = z.object({
+    gate_version: z.string().describe('Version of the gate that ran'),
+    timestamp: z.string().datetime().describe('When the gate was executed'),
+    overall_status: z.enum(['passed', 'failed', 'partial']).describe('Overall gate result'),
+    checks: z.array(EvidenceEntrySchema).describe('Individual check results'),
+    summary: z.string().optional().describe('Summary of gate execution'),
+    artifacts: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Links or references to artifacts'),
+});
+/**
+ * Approval information
+ */
+export const ApprovalSchema = z.object({
+    approved: z.boolean().describe('Whether the plan is approved'),
+    approved_by: z.string().optional().describe('User who approved the plan'),
+    approved_at: z.string().datetime().optional().describe('When the plan was approved'),
+    approval_notes: z.string().optional().describe('Notes or comments on approval'),
+});
+/**
+ * Execution result for apply/rollback operations
+ */
+export const ExecutionResultSchema = z.object({
+    operation: z.enum(['apply', 'rollback', 'dry-run']).describe('Type of operation'),
+    status: z.enum(['success', 'failed', 'partial']).describe('Execution status'),
+    timestamp: z.string().datetime().describe('When the operation was performed'),
+    executed_by: z.string().optional().describe('User who executed the operation'),
+    changes_applied: z.array(z.string()).optional().describe('List of successfully applied changes'),
+    changes_failed: z.array(z.string()).optional().describe('List of failed changes'),
+    rollback_point: z.string().optional().describe('Snapshot ID for rollback'),
+    logs: z.array(z.string()).optional().describe('Execution logs'),
+});
+/**
+ * Main APS Plan Schema with branding for type safety
+ */
+export const APSPlanSchema = z
+    .object({
+    // Identification
+    id: z
+        .string()
+        .regex(/^aps-[a-f0-9]{8}(?:[a-f0-9]{8})?$/)
+        .describe('Unique plan identifier'),
+    hash: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/)
+        .describe('SHA-256 hash of the plan content'),
+    // Core content
+    intent: z
+        .string()
+        .min(10, 'Intent must be at least 10 characters')
+        .max(500, 'Intent must not exceed 500 characters')
+        .describe('Human-readable description of what this plan intends to achieve'),
+    // Schema version using literal type
+    schema_version: z.literal(SCHEMA_VERSION).describe('Version of the APS schema'),
+    // Plan details
+    proposed_changes: z.array(ChangeSchema).describe('List of changes this plan will make'),
+    // Metadata
+    provenance: ProvenanceSchema.describe('Information about plan creation'),
+    validations: ValidationSchema.describe('Validation requirements for this plan'),
+    // Optional fields that get added during lifecycle
+    evidence: z
+        .array(EvidenceSchema)
+        .optional()
+        .describe('Evidence from gate executions (immutable, append-only)'),
+    approval: ApprovalSchema.optional().describe('Approval information'),
+    executions: z.array(ExecutionResultSchema).optional().describe('History of plan executions'),
+    // Additional metadata
+    tags: z.array(z.string()).optional().describe('Tags for categorization and filtering'),
+    metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Additional plan-specific metadata'),
+})
+    .strict(); // Reject unknown properties
+/**
+ * Parse and validate a plan with user-friendly error formatting
+ */
+export function validatePlan(data) {
+    const result = APSPlanSchema.safeParse(data);
+    if (result.success) {
+        return {
+            success: true,
+            data: result.data,
+        };
+    }
+    // Format Zod errors for better user experience
+    const errors = result.error.issues.map((issue) => ({
+        path: issue.path.join('.'),
+        message: issue.message,
+        code: issue.code,
+    }));
+    return {
+        success: false,
+        errors,
+    };
+}
+/**
+ * Create a new plan with defaults
+ */
+export function createPlan(params) {
+    return {
+        id: params.id,
+        intent: params.intent,
+        schema_version: SCHEMA_VERSION,
+        proposed_changes: params.changes || [],
+        provenance: params.provenance,
+        validations: params.validations || {
+            required_checks: ['lint', 'test', 'coverage', 'secrets'],
+            skip_checks: [],
+        },
+    };
+}
+/**
+ * Schema version for external reference
+ */
+export const APS_SCHEMA_VERSION = SCHEMA_VERSION;