rust-kgdb 0.8.5 → 0.8.7

package/CHANGELOG.md

@@ -2,6 +2,131 @@
 
 All notable changes to the rust-kgdb TypeScript SDK will be documented in this file.
 
+## [0.8.6] - 2025-12-21
+
+### ThinkingReasoner: Verified Rust Core Demo
+
+This release certifies that ThinkingReasoner works end-to-end with **real verified output**.
+
+#### Verified Rust SDK Output
+
+```
+======================================================================
+ ThinkingReasoner Demo - Generic Ontology-Driven Deduction
+======================================================================
+
+[1] Creating ThinkingContext...
+    Context ID: fraud-detection-session
+    Actor ID: fraud-agent-001
+
+[2] Loading insurance ontology...
+    Auto-generated 6 rules from ontology
+    - Transitivity rules for ins:transfers
+    - Symmetry rules for ins:relatedTo
+    - SubClass inference rules
+
+[3] Recording observations...
+    Observation 1: Alice -> Bob
+    Observation 2: Bob -> Carol
+    Observation 3: Carol -> Alice
+
+[4] Recording hypothesis...
+    Hypothesis: Circular payment fraud detected
+    Confidence: 0.85
+
+[5] Running deduction...
+    - Rules fired: 3
+    - Iterations: 1
+    - Derived facts: 3
+    - Proofs generated: 3
+
+    Proofs:
+      1. Proof ID: proof:f4d9d811... Hash: "2e7208a8" Confidence: 0.72
+      2. Proof ID: proof:2db45b7b... Hash: "7defe6c8" Confidence: 0.72
+      3. Proof ID: proof:3e220fb5... Hash: "8ff4ea7a" Confidence: 0.72
+
+[6] Getting thinking graph...
+    Nodes: 7
+    Edges: 3
+    Derivation steps: 7
+
+    Derivation Chain:
+      Step 1: [OBSERVATION] Alice transfers $10,000 to Bob
+      Step 2: [OBSERVATION] Bob transfers $9,500 to Carol
+      Step 3: [OBSERVATION] Carol transfers $9,000 to Alice
+      Step 4: [HYPOTHESIS] Circular payment fraud: Alice -> Bob -> Carol -> Alice
+      Step 5: [DATALOG-INFER] causalChain(obs1, hypothesis)
+      Step 6: [DATALOG-INFER] causalChain(obs2, hypothesis)
+      Step 7: [DATALOG-INFER] causalChain(obs3, hypothesis)
+
+[7] Context statistics:
+    Events: 7
+    Facts: 26
+    Rules: 6
+    Proofs: 3
+```
+
+#### What This Proves
+
+1. **Rust Core Works**: All heavy lifting (ontology parsing, rule generation, deduction, proof generation) happens in Rust
+2. **FFI Exposure Works**: NAPI-RS exposes ThinkingReasoner to TypeScript with zero-copy performance
+3. **Generic Framework**: Same ontology → same rules. Change ontology → reasoning changes automatically
+4. **Proof-Carrying Outputs**: Every derived fact has SHA-256 cryptographic proof (Curry-Howard correspondence)
+
+#### Verified TypeScript Demo
+
+```
+[4] Running deductive reasoning (Rust core)...
+    Rules fired: 3
+    Iterations: 1
+    Derived facts: 3
+    Proofs generated: 3
+
+[8] Validating proofs...
+    Proof proof:17b64cb7-a424-...: VALID
+      Hash: 3332343530363366...
+      Confidence: 0.72
+```
+
+#### Key Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    RUST CORE (Heavy Lifting)                    │
+│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
+│  │ OntologyRuleGen │  │ DeductiveEngine │  │ ProofWriter     │  │
+│  │ owl:Transitive  │  │ Semi-naive      │  │ SHA-256 hash    │  │
+│  │ owl:Symmetric   │  │ Datalog         │  │ Curry-Howard    │  │
+│  └─────────────────┘  └─────────────────┘  └─────────────────┘  │
+└─────────────────────────────────────────────────────────────────┘
+                              │ NAPI-RS
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                    TYPESCRIPT SDK (Thin Wrapper)                │
+│  new ThinkingReasoner()                                         │
+│  reasoner.loadOntology(ttl)                                     │
+│  reasoner.hypothesize(s, p, o, confidence, parents)             │
+│  reasoner.deduce() → { derived_facts, proofs }                  │
+│  reasoner.getThinkingGraph() → { nodes, edges, derivation }     │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+#### Files Changed
+- `examples/hypermind-e2e-demo.js` - Complete E2E demo with verified output
+- `CHANGELOG.md` - This entry with real captured output
+
+#### Run Commands
+
+```bash
+# Rust SDK demo (source of truth)
+cargo run --example thinking_reasoner_demo -p rust-kgdb-sdk
+
+# TypeScript SDK demo
+node examples/hypermind-e2e-demo.js
+```
+
+---
+
 ## [0.8.4] - 2025-12-21
 
 ### HyperMindAgent Now Has Deductive Reasoning by Default

package/README.md

@@ -4,15 +4,58 @@
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![W3C](https://img.shields.io/badge/W3C-SPARQL%201.1%20%7C%20RDF%201.2-blue)](https://www.w3.org/TR/sparql11-query/)
 
-> **Your knowledge is scattered. Your claims live in Snowflake. Your customer graph sits in Neo4j. Your risk models run on BigQuery. Your compliance docs are in SharePoint. And your AI? It hallucinates because it can't see the full picture.**
->
-> rust-kgdb unifies scattered enterprise knowledge into a single queryable graph—with native embeddings, cross-database federation, and AI that generates queries instead of fabricating answers. No hallucinations. Full audit trails. One query across everything.
->
-> **What makes it different?** Totally in-memory KGDB with memory acceleration (449ns lookups). Multi-way federated joins across KGDB + Snowflake + BigQuery in a single SQL statement. W3C DCAT/DPROD data cataloging for self-describing data products. And now: **ThinkingReasoner**—deductive AI with proof-carrying outputs where every conclusion has a cryptographic derivation chain.
+> **"Any AI that cannot PROVE its conclusions is just sophisticated guessing."**
 
 ---
 
-## What's New in v0.8.0
+## BRAIN: Business Reasoning & AI Intelligence Network
+
+**What if your AI could show its work?** Not just give you an answer, but prove *exactly* how it derived that answer—with cryptographic verification that auditors and regulators can independently validate?
+
+```
+Traditional LLM:                         BRAIN HyperMind Agent:
+┌─────────────────────────────┐          ┌─────────────────────────────────────────┐
+│ Input: "Is this fraudulent?"│          │ Input: "Is this fraudulent?"            │
+│ Output: "Probability: 0.87" │          │ Output:                                 │
+│         (No explanation)    │          │   FINDING: Circular payment fraud       │
+│         (No proof)          │          │   PROOF: SHA-256 92be3c44...            │
+│         (Hallucination risk)│          │   DATA: KGDB + Snowflake TPCH + BigQuery│
+└─────────────────────────────┘          │   DERIVATION:                           │
+                                         │     Step 1: cust001 -> cust002 ($711)   │
+                                         │     Step 2: cust002 -> cust003 ($121)   │
+                                         │     Step 3: cust003 -> cust001 ($7,498) │
+                                         │     Step 4: [OWL:TRANSITIVE] Cycle!     │
+                                         │   MEMORY: Matches Case #2847            │
+                                         └─────────────────────────────────────────┘
+```
+
+**Try it now:**
+```bash
+npm install rust-kgdb
+node node_modules/rust-kgdb/examples/fraud-underwriting-reallife-demo.js
+```
+
+---
+
+## The Problem We Solve
+
+Your knowledge is scattered:
+- **Claims** live in Snowflake TPCH_SF1
+- **Customer graph** sits in Neo4j or KGDB
+- **Risk models** run on BigQuery
+- **Compliance docs** are in SharePoint
+
+And your AI? It hallucinates because it can't see the full picture.
+
+**rust-kgdb unifies everything:**
+- In-memory KGDB with **449ns lookups** (5-11x faster than RDFox)
+- **HyperFederate**: KGDB + Snowflake + BigQuery in single SPARQL query
+- **ThinkingReasoner**: Deductive AI with proof-carrying outputs
+- **RPC Proxy**: Works in-memory (npm) or K8s cluster—both certified
+
+---
+
+## What's New in v0.8.7
 
 **What if every AI conclusion came with a mathematical proof?**