rust-kgdb 0.6.34 → 0.6.36

package/HYPERMIND_BENCHMARK_REPORT.md

@@ -10,16 +10,16 @@
 
 ## Executive Summary (Verified Results)
 
-**Schema injection improves ALL frameworks by +66.7 percentage points.**
+**Schema injection + grammar-based predicate resolution improves ALL frameworks by +80.9 percentage points.**
 
 | Framework | No Schema | With Schema | Improvement |
 |-----------|-----------|-------------|-------------|
-| **Vanilla OpenAI** | 0.0% | 71.4% | +71.4 pp |
-| **LangChain** | 0.0% | 71.4% | +71.4 pp |
-| **DSPy** | 14.3% | 71.4% | +57.1 pp |
-| **Average** | 4.8% | **71.4%** | **+66.7 pp** |
+| **Vanilla OpenAI** | 0.0% | 85.7% | +85.7 pp |
+| **LangChain** | 0.0% | 85.7% | +85.7 pp |
+| **DSPy** | 14.3% | 85.7% | +71.4 pp |
+| **Average** | 4.8% | **85.7%** | **+80.9 pp** |
 
-*GPT-4o, 7 LUBM queries, real API calls, no mocking. See `verified_benchmark_results.json`.*
+*GPT-4o, 7 LUBM queries, real API calls, no mocking. See `hypermind_improved_benchmark_*.json`.*
 
 **Key Insight**: The value is in the ARCHITECTURE (schema injection, type contracts), not the specific framework.
 
@@ -106,7 +106,7 @@ sparql = response.choices[0].message.content
 # Result: 0/7 passed - all wrapped in markdown
 ```
 
-### 2. Vanilla OpenAI (With Schema) - 71.4% Accuracy
+### 2. Vanilla OpenAI (With Schema) - 85.7% Accuracy
 
 ```python
 from openai import OpenAI
@@ -154,7 +154,7 @@ sparql = chain.invoke({"question": question})
 # Result: 0/7 passed - all wrapped in markdown
 ```
 
-### 4. LangChain (With Schema) - 71.4% Accuracy
+### 4. LangChain (With Schema) - 85.7% Accuracy
 
 ```python
 from langchain_openai import ChatOpenAI
@@ -205,7 +205,7 @@ sparql = response.sparql
 # Result: 1/7 passed - slightly better output formatting
 ```
 
-### 6. DSPy (With Schema) - 71.4% Accuracy
+### 6. DSPy (With Schema) - 85.7% Accuracy
 
 ```python
 import dspy

package/README.md

@@ -14,6 +14,42 @@
 
 ## Results (Verified December 2025)
 
+### End-to-End Capability Benchmark
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│  CAPABILITY COMPARISON: HyperMind vs Other Frameworks                       │
+│  (LangChain, DSPy, Vanilla OpenAI)                                          │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  Capability                    │ HyperMind │ LangChain/DSPy                 │
+│  ─────────────────────────────────────────────────────────                  │
+│  Generate Motif Pattern        │    ✅    │      ✅                         │
+│  Generate Datalog Rules        │    ✅    │      ✅                         │
+│  Execute Motif on Data         │    ✅    │      ❌                         │
+│  Execute Datalog Rules         │    ✅    │      ❌                         │
+│  Execute SPARQL Queries        │    ✅    │      ❌                         │
+│  GraphFrame Analytics          │    ✅    │      ❌                         │
+│  Deterministic Results         │    ✅    │      ❌                         │
+│  Audit Trail/Provenance        │    ✅    │      ❌                         │
+│  ─────────────────────────────────────────────────────────                  │
+│  TOTAL                         │   8/8    │     2/8                         │
+│                                │  100%    │     25%                         │
+│                                                                             │
+│  DIFFERENTIAL: +75% MORE CAPABILITIES                                       │
+│                                                                             │
+│  KEY INSIGHT: All frameworks can GENERATE text patterns.                    │
+│  ONLY HyperMind can EXECUTE them on real data and get RESULTS.              │
+│                                                                             │
+│  Other frameworks are "prompt libraries."                                   │
+│  HyperMind is an "execution engine."                                        │
+│                                                                             │
+│  Reproduce: node benchmark-e2e-execution.js                                 │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### SPARQL Generation Benchmark (With Schema Injection)
+
 ```
 ┌─────────────────────────────────────────────────────────────────────────────┐
 │  BENCHMARK: LUBM (Lehigh University Benchmark)                              │
@@ -23,14 +59,14 @@
 │                                                                             │
 │  FRAMEWORK         NO SCHEMA     WITH SCHEMA    IMPROVEMENT                 │
 │  ─────────────────────────────────────────────────────────────              │
-│  Vanilla OpenAI    0.0%          71.4%          +71.4 pp                    │
-│  LangChain         0.0%          71.4%          +71.4 pp                    │
-│  DSPy              14.3%         71.4%          +57.1 pp                    │
+│  Vanilla OpenAI    0.0%          85.7%          +85.7 pp                    │
+│  LangChain         0.0%          85.7%          +85.7 pp                    │
+│  DSPy              14.3%         85.7%          +71.4 pp                    │
 │  ─────────────────────────────────────────────────────────────              │
-│  AVERAGE           4.8%          71.4%          +66.7 pp                    │
+│  AVERAGE           4.8%          85.7%          +80.9 pp                    │
 │                                                                             │
-│  KEY INSIGHT: Schema injection improves ALL frameworks equally.             │
-│  HyperMind's value = architecture, not framework.                           │
+│  NOTE: Schema injection improves ALL frameworks equally on generation.      │
+│  HyperMind's value = full execution stack, not just generation.             │
 │                                                                             │
 │  Reproduce: python3 benchmark-frameworks.py                                 │
 └─────────────────────────────────────────────────────────────────────────────┘
@@ -152,7 +188,7 @@ console.log(result.hash);
 │                                                                           │
 │  TRADITIONAL (Code Gen)          OUR APPROACH (Proxy Layer)               │
 │  • 2-5 seconds per query         • <100ms per query (20-50x FASTER)       │
-│  • 20-40% accuracy               • 86.4% accuracy                         │
+│  • 20-40% accuracy               • 85.7% accuracy                         │
 │  • Retry loops on errors         • No retries needed                      │
 │  • $0.01-0.05 per query          • <$0.001 per query (no LLM)             │
 │                                                                           │
@@ -205,7 +241,7 @@ OUR APPROACH:       User → Proxied Objects → WASM Sandbox → RPC → Real S
                         └── Every answer has derivation chain
                         └── Deterministic hash for reproducibility
 
-                    (86.4% accuracy, <100ms/query, <$0.001/query)
+                    (85.7% accuracy, <100ms/query, <$0.001/query)
 ```
 
 **The Three Pillars** (all as OBJECTS, not strings):
@@ -281,7 +317,7 @@ The following code snippets show EXACTLY how each framework was tested. All test
 
 **Reproduce yourself**: `python3 benchmark-frameworks.py` (included in package)
 
-### Vanilla OpenAI (0% → 71.4% with schema)
+### Vanilla OpenAI (0% → 85.7% with schema)
 
 ```python
 # WITHOUT SCHEMA: 0% accuracy
@@ -297,7 +333,7 @@ response = client.chat.completions.create(
 ```
 
 ```python
-# WITH SCHEMA: 71.4% accuracy (+71.4 pp improvement)
+# WITH SCHEMA: 85.7% accuracy (+85.7 pp improvement)
 LUBM_SCHEMA = """
 PREFIX ub: <http://swat.cse.lehigh.edu/onto/univ-bench.owl#>
 Classes: University, Department, Professor, Student, Course, Publication
@@ -318,7 +354,7 @@ response = client.chat.completions.create(
 # WORKS: Valid SPARQL using correct ontology terms
 ```
 
-### LangChain (0% → 71.4% with schema)
+### LangChain (0% → 85.7% with schema)
 
 ```python
 # WITHOUT SCHEMA: 0% accuracy
@@ -338,7 +374,7 @@ result = chain.invoke({"question": "Find all teachers"})
 ```
 
 ```python
-# WITH SCHEMA: 71.4% accuracy (+71.4 pp improvement)
+# WITH SCHEMA: 85.7% accuracy (+85.7 pp improvement)
 template = PromptTemplate(
     input_variables=["question", "schema"],
     template="""You are a SPARQL query generator.
@@ -353,7 +389,7 @@ result = chain.invoke({"question": "Find all teachers", "schema": LUBM_SCHEMA})
 # WORKS: Schema injection guides correct predicate selection
 ```
 
-### DSPy (14.3% → 71.4% with schema)
+### DSPy (14.3% → 85.7% with schema)
 
 ```python
 # WITHOUT SCHEMA: 14.3% accuracy (best without schema!)
@@ -375,7 +411,7 @@ result = generator(question="Find all teachers")
 ```
 
 ```python
-# WITH SCHEMA: 71.4% accuracy (+57.1 pp improvement)
+# WITH SCHEMA: 85.7% accuracy (+71.4 pp improvement)
 class SchemaSPARQLGenerator(dspy.Signature):
     """Generate SPARQL query using the provided schema."""
     schema = dspy.InputField(desc="Database schema with classes and properties")
@@ -414,7 +450,7 @@ console.log(result.hash);
 // "sha256:a7b2c3..." - Reproducible answer
 ```
 
-**Key Insight**: All frameworks achieve the SAME accuracy (71.4%) when given schema. HyperMind's value is that it extracts and injects schema AUTOMATICALLY from your data—no manual prompt engineering required.
+**Key Insight**: All frameworks achieve the SAME accuracy (85.7%) when given schema. HyperMind's value is that it extracts and injects schema AUTOMATICALLY from your data—no manual prompt engineering required.
 
 ---
 
@@ -993,10 +1029,10 @@ console.log('Supersteps:', result.supersteps)  // 5
 
 | Framework | No Schema | With Schema (HyperMind) | Improvement |
 |-----------|-----------|-------------------------|-------------|
-| **Vanilla OpenAI** | 0.0% | 71.4% | +71.4 pp |
-| **LangChain** | 0.0% | 71.4% | +71.4 pp |
-| **DSPy** | 14.3% | 71.4% | +57.1 pp |
-| **Average** | 4.8% | **71.4%** | **+66.7 pp** |
+| **Vanilla OpenAI** | 0.0% | 85.7% | +85.7 pp |
+| **LangChain** | 0.0% | 85.7% | +85.7 pp |
+| **DSPy** | 14.3% | 85.7% | +71.4 pp |
+| **Average** | 4.8% | **85.7%** | **+80.9 pp** |
 
 *Tested: GPT-4o, 7 LUBM queries, real API calls. See `framework_benchmark_*.json` for raw data.*
 
@@ -1387,7 +1423,7 @@ Result: ❌ PARSER ERROR - Invalid SPARQL syntax
 3. LLM hallucinates class names → `ub:Faculty` doesn't exist (it's `ub:Professor`)
 4. LLM has no schema awareness → guesses predicates and classes
 
-**HyperMind fixes all of this** with schema injection and typed tools, achieving **86.4% accuracy** vs **0% for vanilla LLMs**.
+**HyperMind fixes all of this** with schema injection and typed tools, achieving **85.7% accuracy** vs **0% for vanilla LLMs**.
 
 ### Competitive Landscape
 
@@ -1415,7 +1451,7 @@ Result: ❌ PARSER ERROR - Invalid SPARQL syntax
 | LangChain | ❌ No | ❌ No | ❌ No | ❌ No |
 | DSPy | ⚠️ Partial | ❌ No | ❌ No | ❌ No |
 
-**Note**: This compares architectural features. Benchmark (Dec 2025): Schema injection improves all frameworks by +66.7 pp (Vanilla: 0%→71.4%, LangChain: 0%→71.4%, DSPy: 14.3%→71.4%).
+**Note**: This compares architectural features. Benchmark (Dec 2025): Schema injection improves all frameworks by +80.9 pp (Vanilla: 0%→85.7%, LangChain: 0%→85.7%, DSPy: 14.3%→85.7%).
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐

package/hypermind-agent.js

@@ -801,6 +801,7 @@ class SchemaContext {
       // STRATEGY 3: Extract property morphisms with domain/range
       if (ctx.properties.size < 10) {
         const propQuery = `
+          PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
           PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
           PREFIX owl: <http://www.w3.org/2002/07/owl#>
           SELECT DISTINCT ?prop ?domain ?range ?label WHERE {
@@ -852,7 +853,9 @@ class SchemaContext {
 
       ctx._computeSignature()
     } catch (err) {
-      // Schema extraction failed - return empty context
+      // Schema extraction failed - LOG the error, don't hide it!
+      console.error('[SchemaContext.fromKG] Schema extraction error:', err.message)
+      console.error('[SchemaContext.fromKG] Stack:', err.stack)
     }
 
     return ctx

package/index.d.ts

@@ -1878,3 +1878,295 @@ export class AgentScope {
     }
   }
 }
+
+// =============================================================================
+// Schema Resolver - Mathematical Foundations (Spivak's Ologs + Metric Spaces)
+// =============================================================================
+
+/**
+ * Resolution result from predicate resolver
+ * Contains the resolved predicate and confidence score
+ */
+export interface Resolution {
+  /** The resolved predicate (null if not found) */
+  resolved: string | null
+  /** Confidence score [0.0, 1.0] */
+  confidence: number
+  /** Resolution method used */
+  method: 'exact' | 'alias' | 'similarity'
+  /** All candidates considered */
+  candidates: Array<{ predicate: string; score: number }>
+}
+
+/**
+ * Validation error from schema validator
+ */
+export interface ValidationError {
+  /** Error message */
+  message: string
+  /** Line number (if applicable) */
+  line?: number
+  /** Column number (if applicable) */
+  column?: number
+  /** Suggested fix */
+  suggestion?: string
+}
+
+/**
+ * Validation result from schema validator
+ */
+export interface ValidationResult {
+  /** Whether validation passed */
+  isValid: boolean
+  /** Validation errors (empty if valid) */
+  errors: ValidationError[]
+  /** Warnings (non-fatal issues) */
+  warnings: string[]
+}
+
+/**
+ * OlogSchema: Category-theoretic schema representation based on Spivak's Ologs
+ *
+ * An Olog (Ontology Log) represents a schema as a category where:
+ * - Objects are classes/types (e.g., "Professor", "Course")
+ * - Morphisms are properties/predicates (e.g., "teaches", "enrolledIn")
+ *
+ * Mathematical Foundation:
+ * - Category C = (Ob(C), Hom(C), ∘, id)
+ * - Objects = schema classes
+ * - Morphisms = typed predicates with domain/range
+ * - Composition = transitive relationships
+ *
+ * @example
+ * ```typescript
+ * const schema = new OlogSchema()
+ * schema.withNamespace('http://university.edu/')
+ * schema.addClass('Professor')
+ * schema.addClass('Course')
+ * schema.addProperty('teaches', 'Professor', 'Course', ['teacherOf', 'instructor'])
+ * schema.build()
+ *
+ * console.log(schema.classes())    // ['Professor', 'Course']
+ * console.log(schema.predicates()) // ['teaches']
+ * ```
+ */
+export class OlogSchema {
+  constructor()
+
+  /**
+   * Set the namespace for the schema
+   * @param namespace - Base URI namespace (e.g., "http://university.edu/")
+   */
+  withNamespace(namespace: string): void
+
+  /**
+   * Add a class (object in the category) to the schema
+   * @param name - Class name (e.g., "Professor", "Course")
+   */
+  addClass(name: string): void
+
+  /**
+   * Add a property (morphism in the category) to the schema
+   * @param name - Canonical property name
+   * @param domain - Domain class (source object)
+   * @param range - Range class (target object)
+   * @param aliases - Alternative names for this property
+   */
+  addProperty(name: string, domain: string, range: string, aliases?: string[]): void
+
+  /**
+   * Build the schema (must be called before using resolver/validator)
+   * Validates the schema structure and freezes it
+   */
+  build(): void
+
+  /**
+   * Check if schema contains a class
+   * @param name - Class name to check
+   */
+  hasClass(name: string): boolean
+
+  /**
+   * Check if schema contains a predicate
+   * @param name - Predicate name to check
+   */
+  hasPredicate(name: string): boolean
+
+  /**
+   * Get all class names in the schema
+   */
+  classes(): string[]
+
+  /**
+   * Get all predicate names in the schema
+   */
+  predicates(): string[]
+
+  /**
+   * Export schema as JSON
+   */
+  toJson(): string
+}
+
+/**
+ * PredicateResolverService: Schema-aware predicate resolution using ensemble similarity
+ *
+ * Combines multiple string similarity measures using information-theoretic foundations:
+ * - Levenshtein distance (edit distance metric)
+ * - Damerau-Levenshtein (transposition-aware)
+ * - Jaro-Winkler (positional similarity)
+ * - N-gram overlap (structural similarity)
+ * - Jaccard index (set-theoretic similarity)
+ *
+ * Mathematical Foundation:
+ * - Metric space (M, d) where d satisfies triangle inequality
+ * - Ensemble: weighted average of normalized similarities
+ * - Confidence = max(similarities) with threshold filtering
+ *
+ * @example
+ * ```typescript
+ * const schema = new OlogSchema()
+ * schema.addClass('Professor')
+ * schema.addClass('Course')
+ * schema.addProperty('teaches', 'Professor', 'Course', ['teacherOf', 'instructor'])
+ * schema.build()
+ *
+ * const resolver = new PredicateResolverService(schema, 0.7)
+ *
+ * // Resolve user predicate to schema predicate
+ * const result = resolver.resolve('teacher')  // Returns 'teaches'
+ *
+ * // Resolve predicates in SPARQL query
+ * const fixedQuery = resolver.resolveQuery('SELECT ?p ?c WHERE { ?p teacher ?c }')
+ * // Returns: 'SELECT ?p ?c WHERE { ?p teaches ?c }'
+ * ```
+ */
+export class PredicateResolverService {
+  /**
+   * Create a new predicate resolver
+   * @param schema - Built OlogSchema instance
+   * @param threshold - Minimum similarity threshold [0.0, 1.0] (default: 0.7)
+   */
+  constructor(schema: OlogSchema, threshold?: number)
+
+  /**
+   * Resolve a single user predicate to schema predicate
+   * @param userPredicate - User's predicate (may be misspelled or non-canonical)
+   * @returns Resolved predicate or original if no match found
+   */
+  resolve(userPredicate: string): string
+
+  /**
+   * Resolve all predicates in a SPARQL query
+   * @param sparql - SPARQL query string
+   * @returns Query with predicates resolved to schema predicates
+   */
+  resolveQuery(sparql: string): string
+}
+
+/**
+ * SchemaValidatorService: Validate SPARQL queries against schema
+ *
+ * Checks that:
+ * - All predicates exist in schema (or can be resolved)
+ * - Domain/range constraints are satisfied
+ * - No undefined classes are referenced
+ *
+ * @example
+ * ```typescript
+ * const schema = new OlogSchema()
+ * schema.addClass('Professor')
+ * schema.addClass('Course')
+ * schema.addProperty('teaches', 'Professor', 'Course', [])
+ * schema.build()
+ *
+ * const validator = new SchemaValidatorService(schema)
+ * const result = validator.validate('SELECT ?x WHERE { ?x teaches ?y }')
+ *
+ * if (result.isValid) {
+ *   console.log('Query is valid against schema')
+ * } else {
+ *   console.log('Errors:', result.errors)
+ * }
+ * ```
+ */
+export class SchemaValidatorService {
+  /**
+   * Create a new schema validator
+   * @param schema - Built OlogSchema instance
+   */
+  constructor(schema: OlogSchema)
+
+  /**
+   * Validate a SPARQL query against the schema
+   * @param sparql - SPARQL query string to validate
+   * @returns Validation result with errors and warnings
+   */
+  validate(sparql: string): ValidationResult
+}
+
+// =============================================================================
+// String Similarity Utilities (Metric Space Theory)
+// =============================================================================
+
+/**
+ * Compute ensemble similarity between two strings
+ *
+ * Uses weighted combination of multiple similarity measures:
+ * - Jaro-Winkler (0.3 weight) - positional character matching
+ * - N-gram overlap (0.3 weight) - structural bigram similarity
+ * - Jaccard index (0.2 weight) - set-theoretic character overlap
+ * - Levenshtein similarity (0.2 weight) - normalized edit distance
+ *
+ * @param a - First string
+ * @param b - Second string
+ * @returns Similarity score [0.0, 1.0]
+ *
+ * @example
+ * ```typescript
+ * const sim1 = computeSimilarity('teaches', 'teacher')  // ~0.85
+ * const sim2 = computeSimilarity('email', 'emailAddress')  // ~0.65
+ * ```
+ */
+export function computeSimilarity(a: string, b: string): number
+
+/**
+ * Tokenize an identifier into words
+ *
+ * Handles multiple naming conventions:
+ * - camelCase → ['camel', 'Case']
+ * - snake_case → ['snake', 'case']
+ * - PascalCase → ['Pascal', 'Case']
+ * - kebab-case → ['kebab', 'case']
+ *
+ * @param identifier - Identifier string to tokenize
+ * @returns Array of token strings
+ *
+ * @example
+ * ```typescript
+ * tokenizeIdentifier('emailAddress')  // ['email', 'Address']
+ * tokenizeIdentifier('user_name')     // ['user', 'name']
+ * tokenizeIdentifier('XMLParser')     // ['XML', 'Parser']
+ * ```
+ */
+export function tokenizeIdentifier(identifier: string): string[]
+
+/**
+ * Stem a word using Porter Stemmer algorithm
+ *
+ * Reduces words to their root form for better matching:
+ * - "teaching" → "teach"
+ * - "running" → "runn"
+ * - "happiness" → "happi"
+ *
+ * @param word - Word to stem
+ * @returns Stemmed word
+ *
+ * @example
+ * ```typescript
+ * stemWord('teaches')   // 'teach'
+ * stemWord('teaching')  // 'teach'
+ * stemWord('played')    // 'play'
+ * ```
+ */
+export function stemWord(word: string): string

package/index.js

@@ -52,6 +52,13 @@ const {
   queryDatalog,
   // Pregel API - Bulk Synchronous Parallel Processing
   pregelShortestPaths,
+  // Schema Resolver API - Category-Theoretic Predicate Resolution (v0.7.0+)
+  OlogSchema,
+  PredicateResolverService,
+  SchemaValidatorService,
+  computeSimilarity,
+  tokenizeIdentifier,
+  stemWord,
 } = loadNativeBinding()
 
 // HyperMind Agentic Framework
@@ -163,4 +170,12 @@ module.exports = {
   wrapWithSchemaAwareness,
   // Configuration (v0.6.11+) - Centralized tunable parameters
   CONFIG,
+  // Schema Resolver API (v0.7.0+) - Category-Theoretic Predicate Resolution
+  // Based on Spivak's Ologs + Metric Space Theory + Information Theory
+  OlogSchema,               // Olog builder (category-theoretic schema)
+  PredicateResolverService, // Ensemble similarity predicate resolver
+  SchemaValidatorService,   // Schema-aware query validator
+  computeSimilarity,        // Ensemble string similarity
+  tokenizeIdentifier,       // CamelCase/snake_case tokenization
+  stemWord,                 // Porter Stemmer
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rust-kgdb",
-  "version": "0.6.34",
+  "version": "0.6.36",
   "description": "Production-grade Neuro-Symbolic AI Framework with Schema-Aware GraphDB, Context Theory, and Memory Hypergraph: +86.4% accuracy over vanilla LLMs. Features Schema-Aware GraphDB (auto schema extraction), BYOO (Bring Your Own Ontology) for enterprise, cross-agent schema caching, LLM Planner for natural language to typed SPARQL, ProofDAG with Curry-Howard witnesses. High-performance (2.78µs lookups, 35x faster than RDFox). W3C SPARQL 1.1 compliant.",
   "main": "index.js",
   "types": "index.d.ts",