@levalicious/server-memory 0.0.0 → 0.0.1

package/dist/index.js

@@ -241,6 +241,129 @@ class KnowledgeGraphManager {
         });
         return Array.from(missingEntities);
     }
+    // BCL (Binary Combinatory Logic) evaluator
+    async evaluateBCL(program, maxSteps) {
+        let current = program;
+        let stepCount = 0;
+        // Find and apply one reduction rule to the leftmost applicable position
+        const applyOneRule = (term) => {
+            // Scan left-to-right for rule applications
+            for (let pos = 0; pos <= term.length - 6; pos++) { // minimum pattern "1100xy" needs at least 6 chars
+                // Rule 1: 1100xy → x
+                if (pos <= term.length - 6 && term.substring(pos, pos + 4) === '1100') {
+                    let parsePos = pos + 4;
+                    // Parse x
+                    const xResult = this.parseBCLTerm(term, parsePos);
+                    if (xResult.success) {
+                        parsePos = xResult.nextPos;
+                        // Parse y
+                        const yResult = this.parseBCLTerm(term, parsePos);
+                        if (yResult.success) {
+                            // Apply Rule 1: 1100xy → x
+                            const before = term.substring(0, pos);
+                            const after = term.substring(yResult.nextPos);
+                            const newTerm = before + xResult.term + after;
+                            return {
+                                newTerm,
+                                applied: true,
+                                rule: `Rule 1: 1100${xResult.term}${yResult.term} → ${xResult.term}`
+                            };
+                        }
+                    }
+                }
+                // Rule 2: 11101xyz → 11xz1yz (need minimum 8 chars)
+                if (pos <= term.length - 8 && term.substring(pos, pos + 5) === '11101') {
+                    let parsePos = pos + 5;
+                    // Parse x
+                    const xResult = this.parseBCLTerm(term, parsePos);
+                    if (xResult.success) {
+                        parsePos = xResult.nextPos;
+                        // Parse y
+                        const yResult = this.parseBCLTerm(term, parsePos);
+                        if (yResult.success) {
+                            parsePos = yResult.nextPos;
+                            // Parse z
+                            const zResult = this.parseBCLTerm(term, parsePos);
+                            if (zResult.success) {
+                                // Apply Rule 2: 11101xyz → 11xz1yz
+                                const x = xResult.term;
+                                const y = yResult.term;
+                                const z = zResult.term;
+                                const before = term.substring(0, pos);
+                                const after = term.substring(zResult.nextPos);
+                                const replacement = `11${x}${z}1${y}${z}`;
+                                const newTerm = before + replacement + after;
+                                return {
+                                    newTerm,
+                                    applied: true,
+                                    rule: `Rule 2: 11101${x}${y}${z} → 11${x}${z}1${y}${z}`
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            return { newTerm: term, applied: false, rule: '' };
+        };
+        // Validate input is a well-formed BCL term
+        const validation = this.parseBCLTerm(current, 0);
+        if (!validation.success || validation.nextPos !== current.length) {
+            return {
+                result: current,
+                info: `Error: Invalid BCL term - parse failed at position ${validation.nextPos}`,
+                halted: false
+            };
+        }
+        let max_size = current.length;
+        while (stepCount < maxSteps) {
+            const result = applyOneRule(current);
+            if (!result.applied) {
+                // Normal form reached - no more reductions possible
+                break;
+            }
+            current = result.newTerm;
+            if (current.length > max_size) {
+                max_size = current.length;
+            }
+            stepCount++;
+        }
+        const halted = stepCount < maxSteps;
+        return {
+            result: current,
+            info: `${stepCount} steps, max size ${max_size}`,
+            halted
+        };
+    }
+    // Helper function to parse a single BCL term from a given position
+    parseBCLTerm(input, startPos) {
+        if (startPos >= input.length) {
+            return { success: false, term: '', nextPos: startPos };
+        }
+        // Check for 00 (K combinator)
+        if (startPos + 1 < input.length && input.substring(startPos, startPos + 2) === '00') {
+            return { success: true, term: '00', nextPos: startPos + 2 };
+        }
+        // Check for 01 (S combinator) 
+        if (startPos + 1 < input.length && input.substring(startPos, startPos + 2) === '01') {
+            return { success: true, term: '01', nextPos: startPos + 2 };
+        }
+        // Check for 1 (application)
+        if (input[startPos] === '1') {
+            // Parse first subterm
+            const leftResult = this.parseBCLTerm(input, startPos + 1);
+            if (!leftResult.success) {
+                return leftResult;
+            }
+            // Parse second subterm
+            const rightResult = this.parseBCLTerm(input, leftResult.nextPos);
+            if (!rightResult.success) {
+                return rightResult;
+            }
+            const term = '1' + leftResult.term + rightResult.term;
+            return { success: true, term, nextPos: rightResult.nextPos };
+        }
+        return { success: false, term: '', nextPos: startPos };
+    }
 }
 const knowledgeGraphManager = new KnowledgeGraphManager();
 // The server instance and tools exposed to Claude
@@ -516,6 +639,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {},
                 },
             },
+            {
+                name: "evaluate_bcl",
+                description: "Evaluate a Binary Combinatory Logic (BCL) program",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        program: { type: "string", description: "The BCL program as a binary string (syntax: T:=00|01|1TT) 00=K, 01=S, 1=application." },
+                        maxSteps: { type: "number", description: "Maximum number of reduction steps to perform (default: 1000000)", default: 1000000 },
+                    },
+                    required: ["program"],
+                },
+            },
         ],
     };
 });
@@ -564,6 +699,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getOrphanedEntities(), null, 2) }] };
         case "validate_graph":
             return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.validateGraph(), null, 2) }] };
+        case "evaluate_bcl":
+            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.evaluateBCL(args.program, args.maxSteps), null, 2) }] };
         default:
             throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levalicious/server-memory",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "MCP server for enabling memory for Claude through a knowledge graph",
   "license": "MIT",
   "author": "Levalicious",
@@ -26,4 +26,4 @@
     "shx": "^0.3.4",
     "typescript": "^5.6.2"
   }
-}
+}