aiyou-dev 3.5.15

package/v3/@aiyou-dev/guidance/dist/wasm-kernel.js

@@ -0,0 +1,158 @@
+/**
+ * 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 @aiyou-dev/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/v3/@aiyou-dev/guidance/package.json

@@ -0,0 +1,198 @@
+{
+  "name": "@aiyou-dev/guidance",
+  "version": "3.0.0-alpha.1",
+  "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"
+    },
+    "./gateway": {
+      "types": "./dist/gateway.d.ts",
+      "import": "./dist/gateway.js"
+    },
+    "./manifest-validator": {
+      "types": "./dist/manifest-validator.d.ts",
+      "import": "./dist/manifest-validator.js"
+    },
+    "./proof": {
+      "types": "./dist/proof.d.ts",
+      "import": "./dist/proof.js"
+    },
+    "./memory-gate": {
+      "types": "./dist/memory-gate.d.ts",
+      "import": "./dist/memory-gate.js"
+    },
+    "./coherence": {
+      "types": "./dist/coherence.d.ts",
+      "import": "./dist/coherence.js"
+    },
+    "./artifacts": {
+      "types": "./dist/artifacts.d.ts",
+      "import": "./dist/artifacts.js"
+    },
+    "./capabilities": {
+      "types": "./dist/capabilities.d.ts",
+      "import": "./dist/capabilities.js"
+    },
+    "./evolution": {
+      "types": "./dist/evolution.d.ts",
+      "import": "./dist/evolution.js"
+    },
+    "./conformance-kit": {
+      "types": "./dist/conformance-kit.d.ts",
+      "import": "./dist/conformance-kit.js"
+    },
+    "./ruvbot-integration": {
+      "types": "./dist/ruvbot-integration.d.ts",
+      "import": "./dist/ruvbot-integration.js"
+    },
+    "./trust": {
+      "types": "./dist/trust.d.ts",
+      "import": "./dist/trust.js"
+    },
+    "./truth-anchors": {
+      "types": "./dist/truth-anchors.d.ts",
+      "import": "./dist/truth-anchors.js"
+    },
+    "./uncertainty": {
+      "types": "./dist/uncertainty.d.ts",
+      "import": "./dist/uncertainty.js"
+    },
+    "./temporal": {
+      "types": "./dist/temporal.d.ts",
+      "import": "./dist/temporal.js"
+    },
+    "./authority": {
+      "types": "./dist/authority.d.ts",
+      "import": "./dist/authority.js"
+    },
+    "./adversarial": {
+      "types": "./dist/adversarial.d.ts",
+      "import": "./dist/adversarial.js"
+    },
+    "./meta-governance": {
+      "types": "./dist/meta-governance.d.ts",
+      "import": "./dist/meta-governance.js"
+    },
+    "./continue-gate": {
+      "types": "./dist/continue-gate.d.ts",
+      "import": "./dist/continue-gate.js"
+    },
+    "./wasm-kernel": {
+      "types": "./dist/wasm-kernel.d.ts",
+      "import": "./dist/wasm-kernel.js"
+    },
+    "./generators": {
+      "types": "./dist/generators.d.ts",
+      "import": "./dist/generators.js"
+    },
+    "./analyzer": {
+      "types": "./dist/analyzer.d.ts",
+      "import": "./dist/analyzer.js"
+    }
+  },
+  "files": [
+    "dist",
+    "wasm-pkg"
+  ],
+  "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": {
+    "@aiyou-dev/hooks": "^3.0.0-alpha.7",
+    "@aiyou-dev/memory": "^3.0.0-alpha.2",
+    "@aiyou-dev/shared": "^3.0.0-alpha.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.16"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "aiyou-dev",
+    "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",
+    "ruvbot",
+    "ruv",
+    "ai-safety",
+    "agent-orchestration",
+    "multi-agent",
+    "code-generation",
+    "llm-governance",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "author": "Claude Flow Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruvnet/aiyou-dev.git",
+    "directory": "v3/@aiyou-dev/guidance"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "v3alpha"
+  }
+}

package/v3/@aiyou-dev/shared/dist/core/config/defaults.d.ts

@@ -0,0 +1,41 @@
+/**
+ * V3 Default Configuration Values
+ */
+import type { AgentConfig, TaskConfig, SwarmConfig, MemoryConfig, MCPServerConfig, OrchestratorConfig, SystemConfig } from './schema.js';
+/**
+ * Default agent configuration
+ */
+export declare const defaultAgentConfig: Partial<AgentConfig>;
+/**
+ * Default task configuration
+ */
+export declare const defaultTaskConfig: Partial<TaskConfig>;
+/**
+ * Default swarm configuration (core version)
+ */
+export declare const defaultSwarmConfigCore: SwarmConfig;
+/**
+ * Default memory configuration (hybrid backend - ADR-009)
+ */
+export declare const defaultMemoryConfig: MemoryConfig;
+/**
+ * Default MCP server configuration
+ */
+export declare const defaultMCPServerConfig: MCPServerConfig;
+/**
+ * Default orchestrator configuration
+ */
+export declare const defaultOrchestratorConfig: OrchestratorConfig;
+/**
+ * Default full system configuration
+ */
+export declare const defaultSystemConfig: SystemConfig;
+/**
+ * Agent type presets
+ */
+export declare const agentTypePresets: Record<string, Partial<AgentConfig>>;
+/**
+ * Get merged configuration with defaults
+ */
+export declare function mergeWithDefaults<T extends Record<string, unknown>>(config: Partial<T>, defaults: T): T;
+//# sourceMappingURL=defaults.d.ts.map

package/v3/@aiyou-dev/shared/dist/core/config/defaults.js

@@ -0,0 +1,186 @@
+/**
+ * V3 Default Configuration Values
+ */
+/**
+ * Default agent configuration
+ */
+export const defaultAgentConfig = {
+    capabilities: [],
+    maxConcurrentTasks: 5,
+    priority: 50,
+    retryPolicy: {
+        maxRetries: 3,
+        backoffMs: 1000,
+        backoffMultiplier: 2,
+    },
+};
+/**
+ * Default task configuration
+ */
+export const defaultTaskConfig = {
+    priority: 50,
+    metadata: {
+        maxRetries: 3,
+    },
+};
+/**
+ * Default swarm configuration (core version)
+ */
+export const defaultSwarmConfigCore = {
+    topology: 'hierarchical-mesh',
+    maxAgents: 20,
+    autoScale: {
+        enabled: false,
+        minAgents: 1,
+        maxAgents: 20,
+        scaleUpThreshold: 0.8,
+        scaleDownThreshold: 0.3,
+    },
+    coordination: {
+        consensusRequired: false,
+        timeoutMs: 10000,
+        retryPolicy: {
+            maxRetries: 3,
+            backoffMs: 500,
+        },
+    },
+    communication: {
+        protocol: 'events',
+        batchSize: 10,
+        flushIntervalMs: 100,
+    },
+};
+/**
+ * Default memory configuration (hybrid backend - ADR-009)
+ */
+export const defaultMemoryConfig = {
+    type: 'hybrid',
+    path: './data/memory',
+    sqlite: {
+        inMemory: false,
+        wal: true,
+    },
+    agentdb: {
+        dimensions: 1536,
+        indexType: 'hnsw',
+        efConstruction: 200,
+        m: 16,
+        quantization: 'none',
+    },
+    hybrid: {
+        vectorThreshold: 100,
+    },
+};
+/**
+ * Default MCP server configuration
+ */
+export const defaultMCPServerConfig = {
+    name: 'aiyou-dev',
+    version: '3.0.0',
+    transport: {
+        type: 'stdio',
+    },
+    capabilities: {
+        tools: true,
+        resources: true,
+        prompts: true,
+        logging: true,
+    },
+};
+/**
+ * Default orchestrator configuration
+ */
+export const defaultOrchestratorConfig = {
+    session: {
+        persistSessions: true,
+        dataDir: './data',
+        sessionRetentionMs: 3600000, // 1 hour
+    },
+    health: {
+        checkInterval: 30000, // 30 seconds
+        historyLimit: 100,
+        degradedThreshold: 1,
+        unhealthyThreshold: 2,
+    },
+    lifecycle: {
+        maxConcurrentAgents: 20,
+        spawnTimeout: 30000, // 30 seconds
+        terminateTimeout: 10000, // 10 seconds
+        maxSpawnRetries: 3,
+    },
+};
+/**
+ * Default full system configuration
+ */
+export const defaultSystemConfig = {
+    orchestrator: defaultOrchestratorConfig,
+    memory: defaultMemoryConfig,
+    mcp: defaultMCPServerConfig,
+    swarm: defaultSwarmConfigCore,
+};
+/**
+ * Agent type presets
+ */
+export const agentTypePresets = {
+    coder: {
+        type: 'coder',
+        capabilities: ['code', 'debug', 'refactor', 'test'],
+        maxConcurrentTasks: 3,
+        priority: 70,
+    },
+    reviewer: {
+        type: 'reviewer',
+        capabilities: ['review', 'analyze', 'suggest'],
+        maxConcurrentTasks: 5,
+        priority: 60,
+    },
+    tester: {
+        type: 'tester',
+        capabilities: ['test', 'validate', 'benchmark'],
+        maxConcurrentTasks: 4,
+        priority: 65,
+    },
+    researcher: {
+        type: 'researcher',
+        capabilities: ['research', 'analyze', 'summarize'],
+        maxConcurrentTasks: 3,
+        priority: 50,
+    },
+    planner: {
+        type: 'planner',
+        capabilities: ['plan', 'organize', 'decompose'],
+        maxConcurrentTasks: 2,
+        priority: 80,
+    },
+    architect: {
+        type: 'architect',
+        capabilities: ['design', 'architecture', 'patterns'],
+        maxConcurrentTasks: 2,
+        priority: 85,
+    },
+    coordinator: {
+        type: 'coordinator',
+        capabilities: ['coordinate', 'delegate', 'monitor'],
+        maxConcurrentTasks: 10,
+        priority: 90,
+    },
+    security: {
+        type: 'security',
+        capabilities: ['audit', 'scan', 'validate', 'secure'],
+        maxConcurrentTasks: 3,
+        priority: 95,
+    },
+    performance: {
+        type: 'performance',
+        capabilities: ['benchmark', 'optimize', 'profile'],
+        maxConcurrentTasks: 2,
+        priority: 70,
+    },
+};
+/**
+ * Get merged configuration with defaults
+ */
+export function mergeWithDefaults(config, defaults) {
+    return { ...defaults, ...config };
+}
+//# sourceMappingURL=defaults.js.map

package/v3/@aiyou-dev/shared/dist/core/config/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * V3 Configuration - Public API
+ */
+export * from './schema.js';
+export * from './validator.js';
+export * from './defaults.js';
+export * from './loader.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@aiyou-dev/shared/dist/core/config/index.js

@@ -0,0 +1,12 @@
+/**
+ * V3 Configuration - Public API
+ */
+// Schemas
+export * from './schema.js';
+// Validation
+export * from './validator.js';
+// Defaults
+export * from './defaults.js';
+// Loader
+export * from './loader.js';
+//# sourceMappingURL=index.js.map

package/v3/@aiyou-dev/shared/dist/core/config/loader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * V3 Configuration Loader
+ * Load configuration from various sources
+ */
+import type { SystemConfig } from './schema.js';
+/**
+ * Configuration source type
+ */
+export type ConfigSource = 'file' | 'env' | 'default' | 'merged';
+/**
+ * Loaded configuration with metadata
+ */
+export interface LoadedConfig {
+    config: SystemConfig;
+    source: ConfigSource;
+    path?: string;
+    warnings?: string[];
+}
+/**
+ * Configuration loader class
+ */
+export declare class ConfigLoader {
+    private searchPaths;
+    constructor(additionalPaths?: string[]);
+    /**
+     * Load configuration from all sources
+     */
+    load(): Promise<LoadedConfig>;
+    /**
+     * Load configuration from specific file
+     */
+    loadFromFile(filePath: string): Promise<LoadedConfig>;
+    /**
+     * Deep merge objects
+     */
+    private deepMerge;
+}
+/**
+ * Load configuration (convenience function)
+ */
+export declare function loadConfig(options?: {
+    paths?: string[];
+    file?: string;
+}): Promise<LoadedConfig>;
+//# sourceMappingURL=loader.d.ts.map