monomind 1.19.0 → 2.0.1

package/packages/@monomind/guidance/dist/wasm-kernel.js

@@ -1,158 +0,0 @@
-/**
- * WASM Kernel Host Bridge
- *
- * Layer B: Node host runtime that calls into the Rust WASM kernel (Layer A).
- * All WASM calls go through this bridge. If the WASM module fails to load,
- * the bridge transparently falls back to the JavaScript implementations.
- *
- * Key rule: The host calls the kernel once per event with a batch payload,
- * not thousands of tiny calls.
- *
- * @module @monomind/guidance/wasm-kernel
- */
-import { createHash, createHmac } from 'node:crypto';
-// ============================================================================
-// WASM Loader
-// ============================================================================
-let wasmModule = null;
-let loadAttempted = false;
-function tryLoadWasm() {
-    if (loadAttempted)
-        return wasmModule;
-    loadAttempted = true;
-    try {
-        // Dynamic require — works in Node.js, gracefully fails elsewhere
-        const path = new URL('../wasm-pkg/guidance_kernel.js', import.meta.url);
-        // Use createRequire for ESM compatibility
-        const { createRequire } = require('node:module');
-        const requireFn = createRequire(import.meta.url);
-        wasmModule = requireFn(path.pathname);
-        // Initialize kernel
-        if (wasmModule && typeof wasmModule.kernel_init === 'function') {
-            wasmModule.kernel_init();
-        }
-    }
-    catch {
-        // WASM not available — fall back to JS
-        wasmModule = null;
-    }
-    return wasmModule;
-}
-// ============================================================================
-// JS Fallback Implementations
-// ============================================================================
-function jsSha256(input) {
-    return createHash('sha256').update(input).digest('hex');
-}
-function jsHmacSha256(key, input) {
-    return createHmac('sha256', key).update(input).digest('hex');
-}
-function jsContentHash(jsonInput) {
-    try {
-        const parsed = JSON.parse(jsonInput);
-        const sorted = sortKeys(parsed);
-        return jsSha256(JSON.stringify(sorted));
-    }
-    catch {
-        return jsSha256(jsonInput);
-    }
-}
-function sortKeys(value) {
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (Array.isArray(value))
-        return value.map(sortKeys);
-    const sorted = {};
-    for (const key of Object.keys(value).sort()) {
-        sorted[key] = sortKeys(value[key]);
-    }
-    return sorted;
-}
-// ============================================================================
-// Kernel singleton
-// ============================================================================
-let kernelInstance = null;
-/**
- * Get the WASM kernel instance. Automatically falls back to JS if WASM is
- * unavailable. Thread-safe (single initialization).
- */
-export function getKernel() {
-    if (kernelInstance)
-        return kernelInstance;
-    const wasm = tryLoadWasm();
-    if (wasm) {
-        kernelInstance = {
-            available: true,
-            version: wasm.kernel_init(),
-            sha256: (input) => wasm.sha256(input),
-            hmacSha256: (key, input) => wasm.hmac_sha256(key, input),
-            contentHash: (jsonInput) => wasm.content_hash(jsonInput),
-            signEnvelope: (key, envelopeJson) => wasm.sign_envelope(key, envelopeJson),
-            verifyChain: (chainJson, key) => wasm.verify_chain(chainJson, key),
-            scanSecrets: (content) => {
-                const json = wasm.scan_secrets(content);
-                try {
-                    return JSON.parse(json);
-                }
-                catch {
-                    return [];
-                }
-            },
-            detectDestructive: (command) => {
-                const result = wasm.detect_destructive(command);
-                return result === '' ? null : result;
-            },
-            batchProcess: (ops) => {
-                const json = wasm.batch_process(JSON.stringify(ops));
-                try {
-                    return JSON.parse(json);
-                }
-                catch {
-                    return [];
-                }
-            },
-        };
-    }
-    else {
-        // JS fallback — identical outputs, just slower
-        kernelInstance = {
-            available: false,
-            version: 'js-fallback',
-            sha256: jsSha256,
-            hmacSha256: jsHmacSha256,
-            contentHash: jsContentHash,
-            signEnvelope: jsHmacSha256,
-            verifyChain: () => {
-                // Chain verification requires full envelope parsing — not implemented
-                // in JS fallback because the ProofChain class already does it.
-                throw new Error('verifyChain not available in JS fallback; use ProofChain.verifyChain()');
-            },
-            scanSecrets: () => {
-                // Gate scanning in JS fallback defers to EnforcementGates class
-                throw new Error('scanSecrets not available in JS fallback; use EnforcementGates');
-            },
-            detectDestructive: () => {
-                throw new Error('detectDestructive not available in JS fallback; use EnforcementGates');
-            },
-            batchProcess: () => {
-                throw new Error('batchProcess requires WASM kernel');
-            },
-        };
-    }
-    return kernelInstance;
-}
-/**
- * Check if the WASM kernel is available without initializing it.
- */
-export function isWasmAvailable() {
-    return getKernel().available;
-}
-/**
- * Reset the kernel instance (for testing).
- */
-export function resetKernel() {
-    kernelInstance = null;
-    wasmModule = null;
-    loadAttempted = false;
-}
-//# sourceMappingURL=wasm-kernel.js.map

package/packages/@monomind/guidance/package.json

@@ -1,119 +0,0 @@
-{
-  "name": "@monomind/guidance",
-  "version": "1.0.0",
-  "description": "Guidance Control Plane - Compiles, retrieves, enforces, and evolves guidance rules for Claude Code sessions",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./compiler": {
-      "types": "./dist/compiler.d.ts",
-      "import": "./dist/compiler.js"
-    },
-    "./retriever": {
-      "types": "./dist/retriever.d.ts",
-      "import": "./dist/retriever.js"
-    },
-    "./gates": {
-      "types": "./dist/gates.d.ts",
-      "import": "./dist/gates.js"
-    },
-    "./hooks": {
-      "types": "./dist/hooks.d.ts",
-      "import": "./dist/hooks.js"
-    },
-    "./ledger": {
-      "types": "./dist/ledger.d.ts",
-      "import": "./dist/ledger.js"
-    },
-    "./optimizer": {
-      "types": "./dist/optimizer.d.ts",
-      "import": "./dist/optimizer.js"
-    },
-    "./headless": {
-      "types": "./dist/headless.d.ts",
-      "import": "./dist/headless.js"
-    },
-    "./persistence": {
-      "types": "./dist/persistence.d.ts",
-      "import": "./dist/persistence.js"
-    },
-    "./proof": {
-      "types": "./dist/proof.d.ts",
-      "import": "./dist/proof.js"
-    },
-    "./analyzer": {
-      "types": "./dist/analyzer.d.ts",
-      "import": "./dist/analyzer.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:watch": "vitest watch",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@monomind/hooks": "workspace:*"
-  },
-  "peerDependencies": {},
-  "peerDependenciesMeta": {},
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.4"
-  },
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "keywords": [
-    "monomind",
-    "claude-code",
-    "claude",
-    "anthropic",
-    "ai-agent",
-    "ai-governance",
-    "agent-governance",
-    "guidance",
-    "control-plane",
-    "policy-enforcement",
-    "enforcement-gates",
-    "proof-chain",
-    "trust-system",
-    "long-horizon",
-    "autonomous-agent",
-    "claude-md",
-    "CLAUDE.md",
-    "memory-governance",
-    "adversarial-defense",
-    "prompt-injection",
-    "wasm",
-    "ai-safety",
-    "agent-orchestration",
-    "multi-agent",
-    "code-generation",
-    "llm-governance",
-    "mcp",
-    "model-context-protocol"
-  ],
-  "author": "Monomind Team",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/monoes/monomind.git",
-    "directory": "packages/@monomind/guidance"
-  },
-  "publishConfig": {
-    "access": "public",
-    "tag": "alpha"
-  }
-}