rust-kgdb 0.6.3 → 0.6.5

package/examples/datalog-example.ts

@@ -2,61 +2,68 @@
  * Datalog Example for rust-kgdb TypeScript SDK
  *
  * Demonstrates Datalog reasoning capabilities including:
- * - Adding facts and rules
+ * - Adding facts and rules using JSON format
  * - Semi-naive evaluation
- * - Recursive rule evaluation
- * - Stratified negation
- * - Query evaluation
- * - Integration with RDF graphs
+ * - Recursive rule evaluation (transitive closure)
+ * - Querying derived facts
+ *
+ * IMPORTANT: The DatalogProgram API uses JSON strings for facts and rules.
+ * This enables a flexible, language-agnostic interface.
  */
 
-import { DatalogEngine, GraphDb } from 'rust-kgdb';
+import { DatalogProgram, evaluateDatalog, queryDatalog, GraphDB } from 'rust-kgdb';
 
 // =============================================================================
 // Example 1: Basic Facts and Rules
 // =============================================================================
 
-async function basicDatalogExample() {
+function basicDatalogExample() {
     console.log('=== Basic Datalog Facts and Rules ===\n');
 
-    const engine = new DatalogEngine();
+    const program = new DatalogProgram();
 
     // Add facts: parent(X, Y) means X is parent of Y
-    engine.addFact('parent', ['alice', 'bob']);
-    engine.addFact('parent', ['alice', 'carol']);
-    engine.addFact('parent', ['bob', 'david']);
-    engine.addFact('parent', ['bob', 'eve']);
-    engine.addFact('parent', ['carol', 'frank']);
+    // Facts use JSON format: {"predicate": "name", "terms": ["arg1", "arg2"]}
+    program.addFact(JSON.stringify({ predicate: 'parent', terms: ['alice', 'bob'] }));
+    program.addFact(JSON.stringify({ predicate: 'parent', terms: ['alice', 'carol'] }));
+    program.addFact(JSON.stringify({ predicate: 'parent', terms: ['bob', 'david'] }));
+    program.addFact(JSON.stringify({ predicate: 'parent', terms: ['bob', 'eve'] }));
+    program.addFact(JSON.stringify({ predicate: 'parent', terms: ['carol', 'frank'] }));
 
     console.log('Facts added:');
     console.log('  parent(alice, bob)');
     console.log('  parent(alice, carol)');
     console.log('  parent(bob, david)');
     console.log('  parent(bob, eve)');
-    console.log('  parent(carol, frank)\n');
+    console.log('  parent(carol, frank)');
+    console.log(`  Total facts: ${program.factCount()}\n`);
 
     // Add rule: grandparent(X, Z) :- parent(X, Y), parent(Y, Z)
-    engine.addRule(
-        'grandparent',          // head predicate
-        ['X', 'Z'],             // head variables
-        [
-            { predicate: 'parent', args: ['X', 'Y'] },
-            { predicate: 'parent', args: ['Y', 'Z'] }
+    // Rules use JSON format: {"head": {...}, "body": [...]}
+    program.addRule(JSON.stringify({
+        head: { predicate: 'grandparent', terms: ['X', 'Z'] },
+        body: [
+            { predicate: 'parent', terms: ['X', 'Y'] },
+            { predicate: 'parent', terms: ['Y', 'Z'] }
         ]
-    );
+    }));
 
     console.log('Rule added:');
-    console.log('  grandparent(X, Z) :- parent(X, Y), parent(Y, Z)\n');
+    console.log('  grandparent(X, Z) :- parent(X, Y), parent(Y, Z)');
+    console.log(`  Total rules: ${program.ruleCount()}\n`);
 
-    // Evaluate to derive all facts
-    engine.evaluate();
+    // Evaluate to derive all facts using semi-naive evaluation
+    const evalResult = evaluateDatalog(program);
+    console.log('Evaluation completed.');
+    console.log(`  Result: ${evalResult}\n`);
 
     // Query grandparents
-    const grandparents = engine.query('grandparent', ['?who', '?grandchild']);
+    const grandparents = queryDatalog(program, 'grandparent');
+    const results = JSON.parse(grandparents);
     console.log('Query: grandparent(?who, ?grandchild)');
     console.log('Results:');
-    for (const result of grandparents) {
-        console.log(`  ${result.who} is grandparent of ${result.grandchild}`);
+    for (const result of results) {
+        console.log(`  ${result.terms[0]} is grandparent of ${result.terms[1]}`);
     }
     console.log();
 }
@@ -65,173 +72,214 @@ async function basicDatalogExample() {
 // Example 2: Recursive Rules (Transitive Closure)
 // =============================================================================
 
-async function recursiveDatalogExample() {
+function recursiveDatalogExample() {
     console.log('=== Recursive Rules (Transitive Closure) ===\n');
 
-    const engine = new DatalogEngine();
+    const program = new DatalogProgram();
 
     // Add edge facts for a graph
-    engine.addFact('edge', ['a', 'b']);
-    engine.addFact('edge', ['b', 'c']);
-    engine.addFact('edge', ['c', 'd']);
-    engine.addFact('edge', ['d', 'e']);
-    engine.addFact('edge', ['a', 'c']); // shortcut
+    program.addFact(JSON.stringify({ predicate: 'edge', terms: ['a', 'b'] }));
+    program.addFact(JSON.stringify({ predicate: 'edge', terms: ['b', 'c'] }));
+    program.addFact(JSON.stringify({ predicate: 'edge', terms: ['c', 'd'] }));
+    program.addFact(JSON.stringify({ predicate: 'edge', terms: ['d', 'e'] }));
+    program.addFact(JSON.stringify({ predicate: 'edge', terms: ['a', 'c'] })); // shortcut
 
     console.log('Graph edges: a->b, b->c, c->d, d->e, a->c\n');
 
     // Base case: path(X, Y) :- edge(X, Y)
-    engine.addRule(
-        'path',
-        ['X', 'Y'],
-        [{ predicate: 'edge', args: ['X', 'Y'] }]
-    );
+    program.addRule(JSON.stringify({
+        head: { predicate: 'path', terms: ['X', 'Y'] },
+        body: [{ predicate: 'edge', terms: ['X', 'Y'] }]
+    }));
 
     // Recursive case: path(X, Z) :- edge(X, Y), path(Y, Z)
-    engine.addRule(
-        'path',
-        ['X', 'Z'],
-        [
-            { predicate: 'edge', args: ['X', 'Y'] },
-            { predicate: 'path', args: ['Y', 'Z'] }
+    program.addRule(JSON.stringify({
+        head: { predicate: 'path', terms: ['X', 'Z'] },
+        body: [
+            { predicate: 'edge', terms: ['X', 'Y'] },
+            { predicate: 'path', terms: ['Y', 'Z'] }
         ]
-    );
+    }));
 
     console.log('Rules added:');
     console.log('  path(X, Y) :- edge(X, Y)         % base case');
     console.log('  path(X, Z) :- edge(X, Y), path(Y, Z)  % recursive case\n');
 
     // Evaluate using semi-naive algorithm
-    const iterations = engine.evaluateSemiNaive();
-    console.log(`Semi-naive evaluation completed in ${iterations} iterations\n`);
+    const evalResult = evaluateDatalog(program);
+    console.log(`Semi-naive evaluation completed: ${evalResult}\n`);
 
     // Query all paths from 'a'
-    const paths = engine.query('path', ['a', '?end']);
-    console.log('Query: path(a, ?end)');
-    console.log('Results (nodes reachable from a):');
-    for (const result of paths) {
-        console.log(`  a can reach ${result.end}`);
+    const paths = queryDatalog(program, 'path');
+    const results = JSON.parse(paths);
+
+    console.log('Query: All paths');
+    console.log('Results (nodes reachable from each source):');
+    for (const result of results) {
+        console.log(`  ${result.terms[0]} can reach ${result.terms[1]}`);
     }
     console.log();
 }
 
 // =============================================================================
-// Example 3: Stratified Negation
+// Example 3: Fraud Detection Rules
 // =============================================================================
 
-async function negationDatalogExample() {
-    console.log('=== Stratified Negation ===\n');
-
-    const engine = new DatalogEngine();
+function fraudDetectionExample() {
+    console.log('=== Fraud Detection Rules ===\n');
+
+    const program = new DatalogProgram();
+
+    // Add transaction facts: transaction(id, sender, receiver, amount)
+    program.addFact(JSON.stringify({
+        predicate: 'transaction',
+        terms: ['tx001', 'account_a', 'account_b', '50000']
+    }));
+    program.addFact(JSON.stringify({
+        predicate: 'transaction',
+        terms: ['tx002', 'account_b', 'account_c', '48000']
+    }));
+    program.addFact(JSON.stringify({
+        predicate: 'transaction',
+        terms: ['tx003', 'account_c', 'account_a', '45000']
+    }));
+
+    // Add account facts: account(id, jurisdiction)
+    program.addFact(JSON.stringify({ predicate: 'account', terms: ['account_a', 'Panama'] }));
+    program.addFact(JSON.stringify({ predicate: 'account', terms: ['account_b', 'BVI'] }));
+    program.addFact(JSON.stringify({ predicate: 'account', terms: ['account_c', 'Cayman'] }));
+
+    // Add high-risk jurisdiction facts
+    program.addFact(JSON.stringify({ predicate: 'high_risk_jurisdiction', terms: ['Panama'] }));
+    program.addFact(JSON.stringify({ predicate: 'high_risk_jurisdiction', terms: ['BVI'] }));
+    program.addFact(JSON.stringify({ predicate: 'high_risk_jurisdiction', terms: ['Cayman'] }));
+
+    console.log('Facts loaded:');
+    console.log('  3 transactions forming circular pattern');
+    console.log('  3 accounts in offshore jurisdictions\n');
+
+    // Rule: sends_to(A, B) :- transaction(_, A, B, _)
+    program.addRule(JSON.stringify({
+        head: { predicate: 'sends_to', terms: ['A', 'B'] },
+        body: [{ predicate: 'transaction', terms: ['_', 'A', 'B', '_'] }]
+    }));
+
+    // Rule: circular_flow(A, B, C) :- sends_to(A, B), sends_to(B, C), sends_to(C, A)
+    program.addRule(JSON.stringify({
+        head: { predicate: 'circular_flow', terms: ['A', 'B', 'C'] },
+        body: [
+            { predicate: 'sends_to', terms: ['A', 'B'] },
+            { predicate: 'sends_to', terms: ['B', 'C'] },
+            { predicate: 'sends_to', terms: ['C', 'A'] }
+        ]
+    }));
+
+    // Rule: offshore_account(A) :- account(A, J), high_risk_jurisdiction(J)
+    program.addRule(JSON.stringify({
+        head: { predicate: 'offshore_account', terms: ['A'] },
+        body: [
+            { predicate: 'account', terms: ['A', 'J'] },
+            { predicate: 'high_risk_jurisdiction', terms: ['J'] }
+        ]
+    }));
+
+    console.log('Fraud detection rules:');
+    console.log('  sends_to(A, B) :- transaction(_, A, B, _)');
+    console.log('  circular_flow(A, B, C) :- sends_to(A, B), sends_to(B, C), sends_to(C, A)');
+    console.log('  offshore_account(A) :- account(A, J), high_risk_jurisdiction(J)\n');
+
+    // Evaluate
+    evaluateDatalog(program);
+
+    // Query circular flows
+    const circularFlows = queryDatalog(program, 'circular_flow');
+    const circularResults = JSON.parse(circularFlows);
+    console.log('Circular payment patterns detected:');
+    for (const result of circularResults) {
+        console.log(`  ${result.terms[0]} -> ${result.terms[1]} -> ${result.terms[2]} -> ${result.terms[0]}`);
+    }
 
-    // Add employee facts
-    engine.addFact('employee', ['alice', 'engineering']);
-    engine.addFact('employee', ['bob', 'engineering']);
-    engine.addFact('employee', ['carol', 'sales']);
-    engine.addFact('employee', ['david', 'hr']);
+    // Query offshore accounts
+    const offshoreAccounts = queryDatalog(program, 'offshore_account');
+    const offshoreResults = JSON.parse(offshoreAccounts);
+    console.log('\nOffshore accounts flagged:');
+    for (const result of offshoreResults) {
+        console.log(`  ${result.terms[0]}`);
+    }
+    console.log();
+}
 
-    // Add manager facts
-    engine.addFact('manager', ['alice']);
-    engine.addFact('manager', ['carol']);
+// =============================================================================
+// Example 4: Access Control Rules
+// =============================================================================
 
-    console.log('Facts:');
-    console.log('  employee(alice, engineering), employee(bob, engineering)');
-    console.log('  employee(carol, sales), employee(david, hr)');
-    console.log('  manager(alice), manager(carol)\n');
+function accessControlExample() {
+    console.log('=== Access Control Rules ===\n');
 
-    // Rule: non_manager(X) :- employee(X, _), NOT manager(X)
-    engine.addRuleWithNegation(
-        'non_manager',
-        ['X'],
-        [{ predicate: 'employee', args: ['X', '_'] }],
-        [{ predicate: 'manager', args: ['X'] }]  // negated atoms
-    );
+    const program = new DatalogProgram();
 
-    console.log('Rule with negation:');
-    console.log('  non_manager(X) :- employee(X, _), NOT manager(X)\n');
+    // User roles
+    program.addFact(JSON.stringify({ predicate: 'role', terms: ['alice', 'admin'] }));
+    program.addFact(JSON.stringify({ predicate: 'role', terms: ['bob', 'developer'] }));
+    program.addFact(JSON.stringify({ predicate: 'role', terms: ['carol', 'developer'] }));
+    program.addFact(JSON.stringify({ predicate: 'role', terms: ['david', 'viewer'] }));
 
-    // Stratified evaluation (handles negation correctly)
-    engine.evaluateStratified();
+    // Resource permissions by role
+    program.addFact(JSON.stringify({ predicate: 'permission', terms: ['admin', 'read'] }));
+    program.addFact(JSON.stringify({ predicate: 'permission', terms: ['admin', 'write'] }));
+    program.addFact(JSON.stringify({ predicate: 'permission', terms: ['admin', 'delete'] }));
+    program.addFact(JSON.stringify({ predicate: 'permission', terms: ['developer', 'read'] }));
+    program.addFact(JSON.stringify({ predicate: 'permission', terms: ['developer', 'write'] }));
+    program.addFact(JSON.stringify({ predicate: 'permission', terms: ['viewer', 'read'] }));
 
-    // Query non-managers
-    const nonManagers = engine.query('non_manager', ['?person']);
-    console.log('Query: non_manager(?person)');
-    console.log('Results:');
-    for (const result of nonManagers) {
-        console.log(`  ${result.person} is not a manager`);
-    }
-    console.log();
-}
+    console.log('Access control facts loaded\n');
 
-// =============================================================================
-// Example 4: Aggregate Functions
-// =============================================================================
+    // Rule: can_do(User, Action) :- role(User, Role), permission(Role, Action)
+    program.addRule(JSON.stringify({
+        head: { predicate: 'can_do', terms: ['User', 'Action'] },
+        body: [
+            { predicate: 'role', terms: ['User', 'Role'] },
+            { predicate: 'permission', terms: ['Role', 'Action'] }
+        ]
+    }));
 
-async function aggregateDatalogExample() {
-    console.log('=== Aggregate Functions ===\n');
-
-    const engine = new DatalogEngine();
-
-    // Add sales facts: sale(product, amount, region)
-    engine.addFact('sale', ['laptop', '1200', 'west']);
-    engine.addFact('sale', ['laptop', '1100', 'east']);
-    engine.addFact('sale', ['phone', '800', 'west']);
-    engine.addFact('sale', ['phone', '850', 'east']);
-    engine.addFact('sale', ['tablet', '500', 'west']);
-    engine.addFact('sale', ['tablet', '450', 'east']);
-
-    console.log('Sales facts added\n');
-
-    // Rule with aggregation: total_by_product(P, sum(A)) :- sale(P, A, _)
-    engine.addAggregateRule(
-        'total_by_product',
-        ['Product', 'Total'],
-        { predicate: 'sale', args: ['Product', 'Amount', '_'] },
-        { function: 'sum', variable: 'Amount', output: 'Total' },
-        ['Product']  // group by
-    );
-
-    // Rule: avg_by_region(R, avg(A)) :- sale(_, A, R)
-    engine.addAggregateRule(
-        'avg_by_region',
-        ['Region', 'Average'],
-        { predicate: 'sale', args: ['_', 'Amount', 'Region'] },
-        { function: 'avg', variable: 'Amount', output: 'Average' },
-        ['Region']
-    );
-
-    console.log('Aggregate rules added:');
-    console.log('  total_by_product(P, sum(A)) :- sale(P, A, _)');
-    console.log('  avg_by_region(R, avg(A)) :- sale(_, A, R)\n');
-
-    engine.evaluate();
-
-    // Query totals by product
-    const totals = engine.query('total_by_product', ['?product', '?total']);
-    console.log('Total sales by product:');
-    for (const result of totals) {
-        console.log(`  ${result.product}: $${result.total}`);
+    console.log('Access control rules:');
+    console.log('  can_do(User, Action) :- role(User, Role), permission(Role, Action)\n');
+
+    evaluateDatalog(program);
+
+    // Query all permissions
+    const permissions = queryDatalog(program, 'can_do');
+    const results = JSON.parse(permissions);
+
+    console.log('Derived permissions:');
+    const permissionsByUser: { [key: string]: string[] } = {};
+    for (const result of results) {
+        const user = result.terms[0];
+        const action = result.terms[1];
+        if (!permissionsByUser[user]) {
+            permissionsByUser[user] = [];
+        }
+        permissionsByUser[user].push(action);
     }
 
-    // Query averages by region
-    const avgs = engine.query('avg_by_region', ['?region', '?avg']);
-    console.log('\nAverage sale by region:');
-    for (const result of avgs) {
-        console.log(`  ${result.region}: $${result.avg}`);
+    for (const [user, actions] of Object.entries(permissionsByUser)) {
+        console.log(`  ${user} can: ${actions.join(', ')}`);
     }
     console.log();
 }
 
 // =============================================================================
-// Example 5: RDF Graph Integration
+// Example 5: Integration with RDF Graph
 // =============================================================================
 
-async function rdfIntegrationExample() {
-    console.log('=== RDF Graph Integration ===\n');
+function rdfIntegrationExample() {
+    console.log('=== RDF Graph + Datalog Integration ===\n');
 
     // Create RDF graph
-    const db = new GraphDb('http://example.org/company');
+    const db = new GraphDB('http://example.org/company');
 
-    // Load company data
+    // Load company data in Turtle format
     const ttl = `
         @prefix ex: <http://example.org/> .
         @prefix foaf: <http://xmlns.com/foaf/0.1/> .
@@ -258,193 +306,52 @@ async function rdfIntegrationExample() {
     `;
 
     db.loadTtl(ttl, null);
-    console.log('RDF graph loaded with company data\n');
-
-    // Create Datalog engine from RDF
-    const engine = db.toDatalog();
-
-    // The RDF triples become facts:
-    // triple(subject, predicate, object)
-    console.log('RDF triples converted to Datalog facts\n');
-
-    // Add reasoning rules
-    // colleague(X, Y) :- memberOf(X, Dept), memberOf(Y, Dept), X != Y
-    engine.addRule(
-        'colleague',
-        ['X', 'Y'],
-        [
-            { predicate: 'triple', args: ['X', 'http://www.w3.org/ns/org#memberOf', 'Dept'] },
-            { predicate: 'triple', args: ['Y', 'http://www.w3.org/ns/org#memberOf', 'Dept'] }
-        ],
-        { filter: 'X != Y' }
-    );
-
-    // manager(X, Y) :- reportsTo(Y, X)
-    engine.addRule(
-        'manager',
-        ['Manager', 'Employee'],
-        [
-            { predicate: 'triple', args: ['Employee', 'http://www.w3.org/ns/org#reportsTo', 'Manager'] }
-        ]
-    );
-
-    console.log('Reasoning rules added:');
-    console.log('  colleague(X, Y) :- memberOf(X, Dept), memberOf(Y, Dept), X != Y');
-    console.log('  manager(M, E) :- reportsTo(E, M)\n');
+    console.log(`RDF graph loaded with ${db.countTriples()} triples\n`);
+
+    // Query to extract facts for Datalog
+    const membershipQuery = `
+        PREFIX org: <http://www.w3.org/ns/org#>
+        SELECT ?person ?dept WHERE {
+            ?person org:memberOf ?dept .
+        }
+    `;
 
-    engine.evaluate();
+    const memberships = db.querySelect(membershipQuery);
 
-    // Query colleagues
-    const colleagues = engine.query('colleague', ['?person1', '?person2']);
-    console.log('Colleagues (same department):');
-    for (const result of colleagues) {
-        console.log(`  ${result.person1.split('/').pop()} and ${result.person2.split('/').pop()}`);
-    }
+    // Create Datalog program from SPARQL results
+    const program = new DatalogProgram();
 
-    // Query managers
-    const managers = engine.query('manager', ['?manager', '?employee']);
-    console.log('\nManagement relationships:');
-    for (const result of managers) {
-        console.log(`  ${result.manager.split('/').pop()} manages ${result.employee.split('/').pop()}`);
+    console.log('Converting RDF to Datalog facts:');
+    for (const row of memberships) {
+        const person = row.bindings.person.split('/').pop() || '';
+        const dept = row.bindings.dept.split('/').pop() || '';
+        program.addFact(JSON.stringify({ predicate: 'member_of', terms: [person, dept] }));
+        console.log(`  member_of(${person}, ${dept})`);
     }
     console.log();
-}
-
-// =============================================================================
-// Example 6: Access Control Rules (Practical Application)
-// =============================================================================
-
-async function accessControlExample() {
-    console.log('=== Access Control Rules ===\n');
-
-    const engine = new DatalogEngine();
-
-    // User roles
-    engine.addFact('role', ['alice', 'admin']);
-    engine.addFact('role', ['bob', 'developer']);
-    engine.addFact('role', ['carol', 'developer']);
-    engine.addFact('role', ['david', 'viewer']);
-
-    // Resource permissions by role
-    engine.addFact('permission', ['admin', 'read']);
-    engine.addFact('permission', ['admin', 'write']);
-    engine.addFact('permission', ['admin', 'delete']);
-    engine.addFact('permission', ['developer', 'read']);
-    engine.addFact('permission', ['developer', 'write']);
-    engine.addFact('permission', ['viewer', 'read']);
-
-    // Resource ownership
-    engine.addFact('owns', ['alice', 'resource1']);
-    engine.addFact('owns', ['bob', 'resource2']);
 
-    console.log('Access control facts loaded\n');
-
-    // Rule: can_access(User, Resource, Action) :- role(User, Role), permission(Role, Action)
-    engine.addRule(
-        'can_access',
-        ['User', 'Resource', 'Action'],
-        [
-            { predicate: 'role', args: ['User', 'Role'] },
-            { predicate: 'permission', args: ['Role', 'Action'] }
+    // Add rule: colleague(X, Y) :- member_of(X, Dept), member_of(Y, Dept)
+    program.addRule(JSON.stringify({
+        head: { predicate: 'colleague', terms: ['X', 'Y'] },
+        body: [
+            { predicate: 'member_of', terms: ['X', 'Dept'] },
+            { predicate: 'member_of', terms: ['Y', 'Dept'] }
         ]
-    );
-
-    // Rule: owner_override(User, Resource, delete) :- owns(User, Resource)
-    engine.addRule(
-        'can_access',
-        ['User', 'Resource', 'delete'],
-        [
-            { predicate: 'owns', args: ['User', 'Resource'] }
-        ]
-    );
+    }));
 
-    console.log('Access control rules:');
-    console.log('  can_access(U, R, A) :- role(U, Role), permission(Role, A)');
-    console.log('  can_access(U, R, delete) :- owns(U, R)  % owner override\n');
-
-    engine.evaluate();
-
-    // Check specific access
-    const checkAccess = (user: string, action: string) => {
-        const results = engine.query('can_access', [user, '?resource', action]);
-        return results.length > 0;
-    };
-
-    const checks = [
-        ['alice', 'delete'],
-        ['bob', 'write'],
-        ['bob', 'delete'],
-        ['david', 'read'],
-        ['david', 'write']
-    ];
-
-    console.log('Access checks:');
-    for (const [user, action] of checks) {
-        const allowed = checkAccess(user, action);
-        const icon = allowed ? '✓' : '✗';
-        console.log(`  ${icon} ${user} can ${action}: ${allowed}`);
-    }
+    console.log('Reasoning rule: colleague(X, Y) :- member_of(X, Dept), member_of(Y, Dept)\n');
 
-    // Bob can delete resource2 because he owns it
-    const bobCanDelete = engine.query('can_access', ['bob', 'resource2', 'delete']);
-    console.log(`\n  Bob can delete resource2 (owner): ${bobCanDelete.length > 0}`);
-    console.log();
-}
+    evaluateDatalog(program);
 
-// =============================================================================
-// Example 7: Incremental Updates
-// =============================================================================
-
-async function incrementalExample() {
-    console.log('=== Incremental Updates ===\n');
-
-    const engine = new DatalogEngine();
-
-    // Initial facts
-    engine.addFact('friend', ['alice', 'bob']);
-    engine.addFact('friend', ['bob', 'carol']);
-
-    // Bidirectional friendship rule
-    engine.addRule(
-        'friends_with',
-        ['X', 'Y'],
-        [{ predicate: 'friend', args: ['X', 'Y'] }]
-    );
-    engine.addRule(
-        'friends_with',
-        ['X', 'Y'],
-        [{ predicate: 'friend', args: ['Y', 'X'] }]
-    );
-
-    // Transitive friends-of-friends
-    engine.addRule(
-        'fof',
-        ['X', 'Z'],
-        [
-            { predicate: 'friends_with', args: ['X', 'Y'] },
-            { predicate: 'friends_with', args: ['Y', 'Z'] }
-        ],
-        { filter: 'X != Z' }
-    );
-
-    engine.evaluate();
-
-    console.log('Initial state:');
-    let fofs = engine.query('fof', ['alice', '?friend']);
-    console.log(`  Alice's friends-of-friends: ${fofs.map(r => r.friend).join(', ')}\n`);
-
-    // Incremental update: add new friendship
-    console.log('Adding new fact: friend(carol, david)');
-    engine.addFact('friend', ['carol', 'david']);
-
-    // Incremental evaluation (only processes new facts)
-    engine.evaluateIncremental();
-
-    console.log('\nAfter incremental update:');
-    fofs = engine.query('fof', ['alice', '?friend']);
-    console.log(`  Alice's friends-of-friends: ${fofs.map(r => r.friend).join(', ')}`);
-
-    console.log('\nIncremental evaluation is much faster for dynamic graphs!');
+    // Query colleagues
+    const colleagues = queryDatalog(program, 'colleague');
+    const results = JSON.parse(colleagues);
+    console.log('Colleagues (same department):');
+    for (const result of results) {
+        if (result.terms[0] !== result.terms[1]) {  // Exclude self-pairs
+            console.log(`  ${result.terms[0]} and ${result.terms[1]}`);
+        }
+    }
     console.log();
 }
 
@@ -452,23 +359,23 @@ async function incrementalExample() {
 // Run All Examples
 // =============================================================================
 
-async function main() {
-    console.log('========================================');
-    console.log('   Datalog Reasoning Examples');
-    console.log('========================================\n');
+function main() {
+    console.log('╔════════════════════════════════════════════════════════════════════╗');
+    console.log('║             Datalog Reasoning Examples - rust-kgdb SDK             ║');
+    console.log('╠════════════════════════════════════════════════════════════════════╣');
+    console.log('║  Using DatalogProgram with JSON-based fact/rule API                ║');
+    console.log('╚════════════════════════════════════════════════════════════════════╝\n');
 
     try {
-        await basicDatalogExample();
-        await recursiveDatalogExample();
-        await negationDatalogExample();
-        await aggregateDatalogExample();
-        await rdfIntegrationExample();
-        await accessControlExample();
-        await incrementalExample();
-
-        console.log('========================================');
-        console.log('   All examples completed successfully!');
-        console.log('========================================');
+        basicDatalogExample();
+        recursiveDatalogExample();
+        fraudDetectionExample();
+        accessControlExample();
+        rdfIntegrationExample();
+
+        console.log('════════════════════════════════════════════════════════════════════');
+        console.log('  All Datalog examples completed successfully!');
+        console.log('════════════════════════════════════════════════════════════════════');
     } catch (error) {
         console.error('Error running examples:', error);
         process.exit(1);