rust-kgdb 0.5.6 → 0.5.9

package/index.d.ts

@@ -741,3 +741,251 @@ export function createPlanningContext(
   endpoint: string,
   hints?: string[]
 ): PlanningContext
+
+// ==============================================
+// HyperMind Architecture Components (v0.5.8+)
+// ==============================================
+
+/**
+ * TypeId - Hindley-Milner type system with refinement types
+ *
+ * Base types: String, Int64, Float64, Bool, Unit
+ * RDF types: Node, Triple, Quad, BindingSet
+ * Compound: List<T>, Option<T>, Result<T,E>, Map<K,V>
+ * Refinement: RiskScore, PolicyNumber, ClaimAmount, CreditScore
+ */
+export const TypeId: {
+  // Base types
+  String: 'String'
+  Int64: 'Int64'
+  Float64: 'Float64'
+  Bool: 'Bool'
+  Unit: 'Unit'
+
+  // RDF-native types
+  Node: 'Node'
+  Triple: 'Triple'
+  Quad: 'Quad'
+  BindingSet: 'BindingSet'
+
+  // Compound types
+  List: (t: string) => string
+  Option: (t: string) => string
+  Result: (t: string, e: string) => string
+  Map: (k: string, v: string) => string
+
+  // Refinement types (business domain)
+  RiskScore: 'RiskScore'
+  PolicyNumber: 'PolicyNumber'
+  ClaimAmount: 'ClaimAmount'
+  ClaimId: 'ClaimId'
+  CreditScore: 'CreditScore'
+  ConfidenceScore: 'ConfidenceScore'
+
+  // Schema types
+  SchemaType: (name: string) => string
+
+  // Type checking
+  isCompatible: (output: string, input: string) => boolean
+}
+
+/**
+ * Tool morphism definition in the TOOL_REGISTRY
+ */
+export interface ToolMorphism {
+  name: string
+  input: string
+  output: string
+  description: string
+  domain: string
+  constraints?: Record<string, unknown>
+  patterns?: Record<string, string>
+  prebuiltRules?: Record<string, string>
+}
+
+/**
+ * TOOL_REGISTRY - All available tools as typed morphisms (Category Theory)
+ * Each tool is an arrow: Input Type → Output Type
+ */
+export const TOOL_REGISTRY: Record<string, ToolMorphism>
+
+/**
+ * LLMPlanner - Natural language to typed tool pipelines
+ *
+ * Converts natural language prompts into validated execution plans
+ * using type checking (Curry-Howard correspondence).
+ *
+ * @example
+ * ```typescript
+ * const planner = new LLMPlanner('claude-sonnet-4', TOOL_REGISTRY)
+ * const plan = await planner.plan('Find suspicious claims')
+ * // plan.steps, plan.type_chain, plan.confidence
+ * ```
+ */
+export class LLMPlanner {
+  constructor(model: string, tools?: Record<string, ToolMorphism>)
+
+  /**
+   * Generate execution plan from natural language
+   */
+  plan(prompt: string, context?: Record<string, unknown>): Promise<{
+    id: string
+    prompt: string
+    intent: Record<string, unknown>
+    steps: Array<{
+      id: number
+      tool: string
+      input_type: string
+      output_type: string
+      args: Record<string, unknown>
+    }>
+    type_chain: string
+    confidence: number
+    explanation: string
+  }>
+}
+
+/**
+ * WasmSandbox configuration
+ */
+export interface WasmSandboxConfig {
+  /** Maximum memory in bytes (default: 64MB) */
+  maxMemory?: number
+  /** Maximum execution time in ms (default: 10000) */
+  maxExecTime?: number
+  /** Capabilities: 'ReadKG', 'WriteKG', 'ExecuteTool' */
+  capabilities?: string[]
+  /** Fuel limit for operations (default: 1000000) */
+  fuelLimit?: number
+}
+
+/**
+ * WasmSandbox - Secure WASM execution environment
+ *
+ * All interaction with the Rust core flows through WASM for complete security:
+ * - Isolated linear memory (no direct host access)
+ * - CPU fuel metering (configurable operation limits)
+ * - Capability-based permissions (ReadKG, WriteKG, ExecuteTool)
+ * - Memory limits (configurable maximum allocation)
+ * - Full audit logging (all tool invocations recorded)
+ *
+ * @example
+ * ```typescript
+ * const sandbox = new WasmSandbox({
+ *   capabilities: ['ReadKG', 'ExecuteTool'],
+ *   fuelLimit: 1000000,
+ *   maxMemory: 64 * 1024 * 1024
+ * })
+ * ```
+ */
+export class WasmSandbox {
+  constructor(config?: WasmSandboxConfig)
+
+  /**
+   * Create Object Proxy for gRPC-style tool invocation
+   */
+  createObjectProxy(tools: Record<string, ToolMorphism>): Record<string, (args: unknown) => Promise<unknown>>
+
+  /**
+   * Check if sandbox has a specific capability
+   */
+  hasCapability(cap: string): boolean
+
+  /**
+   * Get audit log of all tool invocations
+   */
+  getAuditLog(): Array<{
+    timestamp: string
+    tool: string
+    args: unknown
+    result: unknown
+    status: 'OK' | 'DENIED'
+    error?: string
+    fuel_remaining: number
+  }>
+
+  /**
+   * Get sandbox metrics
+   */
+  getMetrics(): {
+    fuel_initial: number
+    fuel_remaining: number
+    fuel_consumed: number
+    memory_used: number
+    memory_limit: number
+    capabilities: string[]
+    tool_calls: number
+  }
+}
+
+/**
+ * ComposedAgent - Agent with sandbox execution and witness generation
+ */
+export class ComposedAgent {
+  name: string
+
+  /**
+   * Execute with natural language prompt
+   */
+  call(prompt: string): Promise<{
+    response: string
+    plan: unknown
+    results: Array<{ step: unknown; result?: unknown; error?: string; status: string }>
+    witness: {
+      witness_version: string
+      timestamp: string
+      agent: string
+      model: string
+      plan: { id: string; steps: number; confidence: number }
+      execution: { tool_calls: Array<{ tool: string; status: string }> }
+      sandbox_metrics: unknown
+      audit_log: unknown[]
+      proof_hash: string
+    }
+    metrics: unknown
+  }>
+}
+
+/**
+ * AgentBuilder - Fluent builder for agent composition
+ *
+ * @example
+ * ```typescript
+ * const agent = new AgentBuilder('compliance-checker')
+ *   .withTool('kg.sparql.query')
+ *   .withTool('kg.datalog.infer')
+ *   .withPlanner('claude-sonnet-4')
+ *   .withSandbox({ capabilities: ['ReadKG'], fuelLimit: 1000000 })
+ *   .withHook('afterExecute', (data) => console.log(data))
+ *   .build()
+ * ```
+ */
+export class AgentBuilder {
+  constructor(name: string)
+
+  /**
+   * Add tool to agent (from TOOL_REGISTRY)
+   */
+  withTool(toolName: string, toolImpl?: (args: unknown) => Promise<unknown>): this
+
+  /**
+   * Set LLM planner model
+   */
+  withPlanner(model: string): this
+
+  /**
+   * Configure WASM sandbox
+   */
+  withSandbox(config: WasmSandboxConfig): this
+
+  /**
+   * Add execution hook
+   * Events: 'beforePlan', 'afterPlan', 'beforeExecute', 'afterExecute', 'onError'
+   */
+  withHook(event: string, handler: (data: unknown) => void): this
+
+  /**
+   * Build the composed agent
+   */
+  build(): ComposedAgent
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rust-kgdb",
-  "version": "0.5.6",
+  "version": "0.5.9",
   "description": "Production-grade Neuro-Symbolic AI Framework: +86.4% accuracy improvement over vanilla LLMs. High-performance knowledge graph (2.78µs lookups, 35x faster than RDFox). Features fraud detection, underwriting agents, WASM sandbox, type/category/proof theory, and W3C SPARQL 1.1 compliance.",
   "main": "index.js",
   "types": "index.d.ts",