vigiles 2.0.0

package/dist/proofs.js

@@ -0,0 +1,622 @@
+"use strict";
+/**
+ * vigiles — Deterministic proof system for self-evolving specifications.
+ *
+ * Six algorithms that verify spec mutations without any LLM dependency:
+ *
+ *   1. MonotonicityLattice — rules can only strengthen over time
+ *   2. ncd()              — information-theoretic duplicate detection
+ *   3. BloomFilter        — fast approximate set membership
+ *   4. fixedPoint()       — compilation convergence detection
+ *   5. MerkleHistory      — tamper-evident spec evolution audit trail
+ *   6. propertyTest()     — random mutation + invariant checking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleHistory = exports.BloomFilter = void 0;
+exports.checkMonotonicity = checkMonotonicity;
+exports.latticeJoin = latticeJoin;
+exports.latticeMeet = latticeMeet;
+exports.ruleStrength = ruleStrength;
+exports.ncd = ncd;
+exports.findSimilarRules = findSimilarRules;
+exports.ruleToBloomFilter = ruleToBloomFilter;
+exports.fixedPoint = fixedPoint;
+exports.propertyTest = propertyTest;
+exports.fitness = fitness;
+const node_crypto_1 = require("node:crypto");
+const node_zlib_1 = require("node:zlib");
+// ---------------------------------------------------------------------------
+// 1. Monotonicity Lattice — partial order on rule strength
+// ---------------------------------------------------------------------------
+/**
+ * Ordinal strength of each rule kind.
+ *
+ *   guidance (0) < enforce (1)
+ *
+ * The lattice ensures specs only get stricter over time.
+ */
+const STRENGTH = {
+    guidance: 0,
+    enforce: 1,
+};
+/**
+ * Check that a spec mutation is monotonic: existing rules only strengthen.
+ *
+ * - Adding rules: always allowed
+ * - Removing rules: flagged (informational, not a violation by default)
+ * - Strengthening (guidance → check → enforce): allowed
+ * - Weakening (enforce → guidance): violation unless allowWeaken includes the rule ID
+ */
+function checkMonotonicity(before, after, options = {}) {
+    const violations = [];
+    const added = [];
+    const removed = [];
+    const strengthened = [];
+    const unchanged = [];
+    const allowWeaken = options.allowWeaken ?? new Set();
+    // Check rules present in both versions
+    for (const [id, beforeRule] of Object.entries(before)) {
+        const afterRule = after[id];
+        if (!afterRule) {
+            removed.push(id);
+            // Removal is a monotonicity violation unless explicitly allowlisted.
+            // Without this, a bare `remove` mutation could pass the proof suite
+            // on neutral fitness and silently delete constraints, breaking the
+            // "rules only strengthen over time" invariant.
+            if (!allowWeaken.has(id)) {
+                violations.push({
+                    ruleId: id,
+                    from: beforeRule._kind,
+                    to: "guidance", // nominal floor — rule is gone entirely
+                    fromStrength: STRENGTH[beforeRule._kind],
+                    toStrength: -1,
+                });
+            }
+            continue;
+        }
+        const beforeStrength = STRENGTH[beforeRule._kind];
+        const afterStrength = STRENGTH[afterRule._kind];
+        if (afterStrength < beforeStrength && !allowWeaken.has(id)) {
+            violations.push({
+                ruleId: id,
+                from: beforeRule._kind,
+                to: afterRule._kind,
+                fromStrength: beforeStrength,
+                toStrength: afterStrength,
+            });
+        }
+        else if (afterStrength > beforeStrength) {
+            strengthened.push(id);
+        }
+        else {
+            unchanged.push(id);
+        }
+    }
+    // New rules
+    for (const id of Object.keys(after)) {
+        if (!(id in before)) {
+            added.push(id);
+        }
+    }
+    return {
+        valid: violations.length === 0,
+        violations,
+        added,
+        removed,
+        strengthened,
+        unchanged,
+    };
+}
+/**
+ * Compute the join (least upper bound) of two rule kinds in the lattice.
+ * join(guidance, enforce) = enforce
+ */
+function latticeJoin(a, b) {
+    return STRENGTH[a] >= STRENGTH[b] ? a : b;
+}
+/**
+ * Compute the meet (greatest lower bound) of two rule kinds in the lattice.
+ * meet(guidance, enforce) = guidance
+ */
+function latticeMeet(a, b) {
+    return STRENGTH[a] <= STRENGTH[b] ? a : b;
+}
+/** Get the numeric strength of a rule kind. */
+function ruleStrength(kind) {
+    return STRENGTH[kind];
+}
+// ---------------------------------------------------------------------------
+// 2. Normalized Compression Distance (NCD)
+// ---------------------------------------------------------------------------
+/**
+ * Compute the compressed size of a string using gzip.
+ * This approximates Kolmogorov complexity — the length of the shortest
+ * program that produces the string.
+ */
+function compressedSize(s) {
+    return (0, node_zlib_1.gzipSync)(Buffer.from(s, "utf-8"), { level: 9 }).length;
+}
+/**
+ * Normalized Compression Distance — information-theoretic similarity.
+ *
+ *   NCD(x, y) = (C(xy) - min(C(x), C(y))) / max(C(x), C(y))
+ *
+ * Range: [0, 1+ε] where 0 = identical information content.
+ * Deterministic. No model dependency. Approximates the universal distance metric.
+ *
+ * Reference: Li, Chen, Li, Ma, Vitányi (2004) "The Similarity Metric"
+ */
+function ncd(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    const ca = compressedSize(a);
+    const cb = compressedSize(b);
+    const cab = compressedSize(a + b);
+    const minC = Math.min(ca, cb);
+    const maxC = Math.max(ca, cb);
+    if (maxC === 0)
+        return 0;
+    return (cab - minC) / maxC;
+}
+/**
+ * Find all rule pairs with NCD below a similarity threshold.
+ * Returns pairs sorted by distance (most similar first).
+ */
+function findSimilarRules(rules, threshold = 0.5) {
+    const entries = Object.entries(rules);
+    const pairs = [];
+    for (let i = 0; i < entries.length; i++) {
+        for (let j = i + 1; j < entries.length; j++) {
+            const [idA, ruleA] = entries[i];
+            const [idB, ruleB] = entries[j];
+            const textA = ruleToText(ruleA);
+            const textB = ruleToText(ruleB);
+            const d = ncd(textA, textB);
+            if (d < threshold) {
+                pairs.push({ idA, idB, distance: d });
+            }
+        }
+    }
+    return pairs.sort((a, b) => a.distance - b.distance);
+}
+/**
+ * Extract the text content of a rule for NCD comparison.
+ *
+ * Throws a structured error on unknown rule kinds so that the caller (e.g.
+ * runProofSuite) can surface a clear proof failure rather than letting an
+ * `undefined` propagate into compressedSize and crash the audit.
+ */
+function ruleToText(rule) {
+    switch (rule._kind) {
+        case "enforce":
+            return `${rule.linterRule} ${rule.why}`;
+        case "guidance":
+            return rule.text;
+        default: {
+            const unknown = rule._kind;
+            throw new Error(`Unknown rule kind "${String(unknown)}" — expected "enforce" or "guidance". ` +
+                `Runtime data is out of sync with the Rule type (legacy spec, JS caller, or cast bypass).`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// 3. Bloom Filter — probabilistic set membership
+// ---------------------------------------------------------------------------
+/**
+ * FNV-1a hash — fast, good distribution, deterministic.
+ * Returns a 32-bit unsigned integer.
+ */
+function fnv1a(data, seed = 0) {
+    let hash = 2166136261 ^ seed;
+    for (let i = 0; i < data.length; i++) {
+        hash ^= data.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0; // ensure unsigned
+}
+/**
+ * Bloom filter — space-efficient probabilistic set membership.
+ *
+ * Insert elements, then query "is X possibly in the set?"
+ * False positives possible. False negatives impossible.
+ *
+ * Optimal parameters:
+ *   m = -(n × ln(p)) / (ln2)²     (bit array size)
+ *   k = (m / n) × ln2              (hash function count)
+ *
+ * Reference: Bloom (1970) "Space/Time Trade-offs in Hash Coding"
+ */
+class BloomFilter {
+    bits;
+    numHashes;
+    size;
+    _count = 0;
+    /**
+     * Create a Bloom filter.
+     * @param expectedItems Expected number of items to insert
+     * @param falsePositiveRate Desired false positive rate (0-1)
+     */
+    constructor(expectedItems, falsePositiveRate = 0.01) {
+        // m = -(n * ln(p)) / (ln2)^2
+        const m = Math.ceil((-expectedItems * Math.log(falsePositiveRate)) / Math.log(2) ** 2);
+        // k = (m/n) * ln2
+        const k = Math.max(1, Math.round((m / expectedItems) * Math.log(2)));
+        this.size = m;
+        this.numHashes = k;
+        this.bits = new Uint8Array(Math.ceil(m / 8));
+    }
+    /** Number of items inserted. */
+    get count() {
+        return this._count;
+    }
+    /** Theoretical false positive rate given current fill. */
+    get estimatedFPR() {
+        const exponent = (-this.numHashes * this._count) / this.size;
+        return (1 - Math.exp(exponent)) ** this.numHashes;
+    }
+    /** Insert an element. */
+    add(item) {
+        for (let i = 0; i < this.numHashes; i++) {
+            const pos = fnv1a(item, i) % this.size;
+            const byteIndex = pos >>> 3;
+            const bitIndex = pos & 7;
+            this.bits[byteIndex] |= 1 << bitIndex;
+        }
+        this._count++;
+    }
+    /** Query membership. Returns true if the item MIGHT be in the set. */
+    has(item) {
+        for (let i = 0; i < this.numHashes; i++) {
+            const pos = fnv1a(item, i) % this.size;
+            const byteIndex = pos >>> 3;
+            const bitIndex = pos & 7;
+            if ((this.bits[byteIndex] & (1 << bitIndex)) === 0) {
+                return false; // definitely not in set
+            }
+        }
+        return true; // possibly in set
+    }
+    /**
+     * Estimate the Jaccard similarity between two Bloom filters.
+     * Uses bit-level comparison — no need to know the original elements.
+     */
+    static jaccardSimilarity(a, b) {
+        if (a.size !== b.size) {
+            throw new Error("Bloom filters must have the same size for comparison");
+        }
+        let intersection = 0;
+        let union = 0;
+        for (let i = 0; i < a.bits.length; i++) {
+            const and = a.bits[i] & b.bits[i];
+            const or = a.bits[i] | b.bits[i];
+            // Count set bits (Brian Kernighan's algorithm)
+            let x = and;
+            while (x) {
+                intersection++;
+                x &= x - 1;
+            }
+            x = or;
+            while (x) {
+                union++;
+                x &= x - 1;
+            }
+        }
+        return union === 0 ? 1 : intersection / union;
+    }
+}
+exports.BloomFilter = BloomFilter;
+/**
+ * Build a Bloom filter from a rule's tokens.
+ * Tokenizes rule text into words and n-grams for fuzzy matching.
+ */
+function ruleToBloomFilter(rule, expectedTokens = 100) {
+    const text = ruleToText(rule);
+    const filter = new BloomFilter(expectedTokens, 0.01);
+    // Word-level tokens
+    const words = text.toLowerCase().split(/\W+/).filter(Boolean);
+    for (const word of words) {
+        filter.add(word);
+    }
+    // Character 3-grams for fuzzy matching
+    const normalized = text.toLowerCase();
+    for (let i = 0; i <= normalized.length - 3; i++) {
+        filter.add(normalized.slice(i, i + 3));
+    }
+    return filter;
+}
+/**
+ * Detect whether a compile function reaches a fixed point.
+ *
+ * A fixed point means: applying the function again produces the same output.
+ * compile(compile(spec)) === compile(spec)
+ *
+ * If the function doesn't converge, detects cycles using Floyd's
+ * tortoise-and-hare algorithm adapted for hash sequences.
+ *
+ * @param compileFn A function that takes content and returns new content
+ * @param initialContent Starting content
+ * @param maxIterations Maximum iterations before declaring divergence
+ */
+function fixedPoint(compileFn, initialContent, maxIterations = 10) {
+    const hashes = [];
+    let current = initialContent;
+    for (let i = 0; i < maxIterations; i++) {
+        const hash = sha256short(current);
+        hashes.push(hash);
+        const next = compileFn(current);
+        const nextHash = sha256short(next);
+        // Fixed point: output === input
+        if (nextHash === hash) {
+            return { converged: true, iterations: i + 1, hashes, cycleLength: 0 };
+        }
+        // Cycle detection: have we seen this hash before?
+        const cycleStart = hashes.indexOf(nextHash);
+        if (cycleStart !== -1) {
+            return {
+                converged: false,
+                iterations: i + 1,
+                hashes: [...hashes, nextHash],
+                cycleLength: i + 1 - cycleStart,
+            };
+        }
+        current = next;
+    }
+    return {
+        converged: false,
+        iterations: maxIterations,
+        hashes,
+        cycleLength: 0,
+    };
+}
+/** Compute a short SHA-256 hash (16 hex chars). */
+function sha256short(data) {
+    return (0, node_crypto_1.createHash)("sha256").update(data).digest("hex").slice(0, 16);
+}
+/** Compute the hash of a HistoryNode (excluding the hash field itself). */
+function computeNodeHash(node) {
+    const payload = JSON.stringify({
+        parentHash: node.parentHash,
+        specHash: node.specHash,
+        mutation: node.mutation,
+        proofs: node.proofs,
+        timestamp: node.timestamp,
+    });
+    return sha256short(payload);
+}
+class MerkleHistory {
+    nodes = [];
+    /** Number of versions in the history. */
+    get length() {
+        return this.nodes.length;
+    }
+    /**
+     * Get all nodes as a deep defensive copy. Callers cannot mutate node
+     * fields (specHash, mutation, proofs) through this API — that would
+     * bypass append/proof gates and weaken the tamper-evident guarantees.
+     */
+    getNodes() {
+        return this.nodes.map((n) => ({
+            ...n,
+            mutation: { ...n.mutation, ruleIds: [...n.mutation.ruleIds] },
+            proofs: n.proofs.map((r) => ({ ...r })),
+        }));
+    }
+    /**
+     * Get the latest node, or null if empty. Returned as a deep defensive
+     * copy — see getNodes() for rationale.
+     */
+    head() {
+        const last = this.nodes[this.nodes.length - 1];
+        if (!last)
+            return null;
+        return {
+            ...last,
+            mutation: { ...last.mutation, ruleIds: [...last.mutation.ruleIds] },
+            proofs: last.proofs.map((r) => ({ ...r })),
+        };
+    }
+    /**
+     * Append a new version to the history.
+     * Returns the hash of the new node.
+     */
+    append(specHash, mutation, proofs) {
+        const parentHash = this.nodes.length > 0
+            ? this.nodes[this.nodes.length - 1].hash
+            : "genesis";
+        // Clone payloads on write so later caller-side mutation of the supplied
+        // mutation/proofs objects can't retroactively alter stored nodes. This
+        // is the write-side counterpart to getNodes()/head(), keeping the
+        // append-only / tamper-evident contract true under normal usage
+        // patterns like "caller reuses and edits a mutation object".
+        const clonedMutation = {
+            ...mutation,
+            ruleIds: [...mutation.ruleIds],
+        };
+        const clonedProofs = proofs.map((r) => ({ ...r }));
+        const partial = {
+            parentHash,
+            specHash,
+            mutation: clonedMutation,
+            proofs: clonedProofs,
+            timestamp: Date.now(),
+        };
+        const hash = computeNodeHash(partial);
+        this.nodes.push({ hash, ...partial });
+        return hash;
+    }
+    /**
+     * Verify the entire chain — every node's hash must be correct,
+     * and every parent pointer must match the previous node.
+     *
+     * Returns the index of the first invalid node, or -1 if valid.
+     */
+    verify() {
+        for (let i = 0; i < this.nodes.length; i++) {
+            const node = this.nodes[i];
+            // Check hash integrity
+            const { hash: _hash, ...rest } = node;
+            const expectedHash = computeNodeHash(rest);
+            if (node.hash !== expectedHash) {
+                return { valid: false, invalidAt: i };
+            }
+            // Check parent chain
+            if (i === 0) {
+                if (node.parentHash !== "genesis") {
+                    return { valid: false, invalidAt: i };
+                }
+            }
+            else {
+                if (node.parentHash !== this.nodes[i - 1].hash) {
+                    return { valid: false, invalidAt: i };
+                }
+            }
+        }
+        return { valid: true, invalidAt: -1 };
+    }
+    /**
+     * Serialize the history to JSON for persistence.
+     */
+    toJSON() {
+        return JSON.stringify(this.nodes, null, 2);
+    }
+    /**
+     * Deserialize a history from JSON. Rejects non-array payloads and
+     * validates that each entry has the required HistoryNode shape so
+     * malformed persisted data can't produce a "valid" history that
+     * later crashes on append/verify.
+     */
+    static fromJSON(json) {
+        const parsed = JSON.parse(json);
+        if (!Array.isArray(parsed)) {
+            throw new Error(`MerkleHistory.fromJSON: expected an array, got ${typeof parsed}`);
+        }
+        for (let i = 0; i < parsed.length; i++) {
+            const node = parsed[i];
+            if (typeof node !== "object" ||
+                node === null ||
+                typeof node.hash !== "string" ||
+                typeof node.parentHash !== "string" ||
+                typeof node.specHash !== "string" ||
+                typeof node.timestamp !== "number") {
+                throw new Error(`MerkleHistory.fromJSON: invalid node at index ${String(i)}`);
+            }
+            // Validate nested mutation and proofs so later getNodes/head
+            // don't crash on missing .ruleIds or .map().
+            const mut = node.mutation;
+            if (!mut ||
+                typeof mut !== "object" ||
+                typeof mut.type !== "string" ||
+                !Array.isArray(mut.ruleIds)) {
+                throw new Error(`MerkleHistory.fromJSON: invalid mutation at node ${String(i)}`);
+            }
+            if (!Array.isArray(node.proofs)) {
+                throw new Error(`MerkleHistory.fromJSON: invalid proofs at node ${String(i)}`);
+            }
+        }
+        const history = new MerkleHistory();
+        history.nodes = parsed;
+        return history;
+    }
+}
+exports.MerkleHistory = MerkleHistory;
+/**
+ * Simple deterministic PRNG (xorshift32) for reproducible tests.
+ */
+function xorshift32(state) {
+    let x = state;
+    x ^= x << 13;
+    x ^= x >> 17;
+    x ^= x << 5;
+    return x >>> 0;
+}
+/**
+ * Property-based testing: generate random mutations, check invariants hold.
+ *
+ * Inspired by QuickCheck/fast-check. Uses a deterministic PRNG for
+ * reproducible failures.
+ *
+ * @param initial Starting value
+ * @param mutate Function that produces a random mutation
+ * @param invariants Named invariant functions that must all return true
+ * @param options Test parameters
+ */
+function propertyTest(initial, mutate, invariants, options = {}) {
+    const iterations = options.iterations ?? 100;
+    const sequenceLength = options.sequenceLength ?? 5;
+    let rng = options.seed ?? 42;
+    for (let i = 0; i < iterations; i++) {
+        // Generate a sequence of mutations
+        let current = initial;
+        const sequence = [current];
+        for (let j = 0; j < sequenceLength; j++) {
+            rng = xorshift32(rng);
+            current = mutate(current, rng);
+            sequence.push(current);
+            // Check all invariants after each mutation
+            for (const [name, check] of Object.entries(invariants)) {
+                if (!check(current)) {
+                    // Shrink: binary search for minimal failing subsequence
+                    const shrunk = shrinkSequence(initial, sequence, mutate, name, invariants);
+                    return {
+                        passed: false,
+                        iterations: i + 1,
+                        failingSequence: sequence,
+                        shrunk,
+                        failedInvariant: name,
+                    };
+                }
+            }
+        }
+    }
+    return { passed: true, iterations };
+}
+/**
+ * Shrink a failing sequence to find the minimal counterexample.
+ * Uses binary search on the sequence length.
+ */
+function shrinkSequence(_initial, sequence, _mutate, invariantName, invariants) {
+    // Simple shrinking: find the first element in the sequence that fails
+    const check = invariants[invariantName];
+    for (const item of sequence) {
+        if (!check(item)) {
+            return item;
+        }
+    }
+    // Shouldn't reach here — return last element
+    return sequence[sequence.length - 1];
+}
+/**
+ * Compute the fitness of a spec. Higher is better.
+ *
+ *   fitness = coverage × (1 - redundancy) × (1 - budgetPressure)
+ *
+ * - coverage: fraction of rules with enforcement (check or enforce)
+ * - redundancy: fraction of rule pairs that are near-duplicates (NCD < threshold)
+ * - budgetPressure: tokens used / max tokens
+ */
+function fitness(spec, options = {}) {
+    const maxTokens = options.maxTokens ?? 2000;
+    const ncdThreshold = options.ncdThreshold ?? 0.3;
+    const rules = Object.values(spec.rules);
+    const total = rules.length;
+    if (total === 0) {
+        return { score: 0, coverage: 0, redundancy: 0, budgetPressure: 0 };
+    }
+    // Coverage: fraction with teeth (enforce vs guidance)
+    const enforced = rules.filter((r) => r._kind === "enforce").length;
+    const coverage = enforced / total;
+    // Redundancy: fraction of pairs that are near-duplicates
+    const similarPairs = findSimilarRules(spec.rules, ncdThreshold);
+    const totalPairs = (total * (total - 1)) / 2;
+    const redundancy = totalPairs > 0 ? similarPairs.length / totalPairs : 0;
+    // Budget pressure: rough token estimate (~4 chars per token)
+    const ruleTexts = rules.map(ruleToText);
+    const totalChars = ruleTexts.reduce((sum, t) => sum + t.length, 0);
+    const estimatedTokens = Math.ceil(totalChars / 4);
+    const budgetPressure = Math.min(1, estimatedTokens / maxTokens);
+    const score = coverage * (1 - redundancy) * (1 - budgetPressure);
+    return { score, coverage, redundancy, budgetPressure };
+}
+//# sourceMappingURL=proofs.js.map

package/dist/proofs.js.map

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

package/dist/proofs.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests for the proof system and evolution engine.
+ *
+ * Covers: monotonicity lattice, NCD, Bloom filter, fixed-point convergence,
+ * Merkle history, property-based testing, fitness function, and the
+ * evolution engine.
+ */
+export {};
+//# sourceMappingURL=proofs.test.d.ts.map

package/dist/proofs.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proofs.test.d.ts","sourceRoot":"","sources":["../src/proofs.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}