@levalicious/server-memory 0.0.2 → 0.0.4

package/README.md

@@ -125,6 +125,63 @@ Example:
     - Relations between requested entities
   - Silently skips non-existent nodes
 
+- **get_neighbors**
+  - Get neighboring entities connected to a specific entity within a given depth
+  - Input: `entityName` (string), `depth` (number, default: 1)
+  - Returns entities connected within specified depth
+
+- **find_path**
+  - Find a path between two entities in the knowledge graph
+  - Input: `fromEntity` (string), `toEntity` (string), `maxDepth` (number, default: 5)
+  - Returns path between entities if one exists
+
+- **get_entities_by_type**
+  - Get all entities of a specific type
+  - Input: `entityType` (string)
+  - Returns all entities matching the specified type
+
+- **get_entity_types**
+  - Get all unique entity types in the knowledge graph
+  - No input required
+  - Returns list of all entity types
+
+- **get_relation_types**
+  - Get all unique relation types in the knowledge graph
+  - No input required
+  - Returns list of all relation types
+
+- **get_stats**
+  - Get statistics about the knowledge graph
+  - No input required
+  - Returns entity count, relation count, entity types count, relation types count
+
+- **get_orphaned_entities**
+  - Get entities that have no relations
+  - No input required
+  - Returns entities with no connections
+
+- **validate_graph**
+  - Validate the knowledge graph and return missing entities referenced in relations
+  - No input required
+  - Returns list of missing entities
+
+- **evaluate_bcl**
+  - Evaluate a Binary Combinatory Logic (BCL) program
+  - Input: `program` (string), `maxSteps` (number, default: 1000000)
+  - BCL syntax: T:=00|01|1TT where 00=K, 01=S, 1=application
+  - Returns evaluation result with halt status
+
+- **add_bcl_term**
+  - Add a BCL term to the constructor, maintaining valid syntax
+  - Input: `term` (string)
+  - Valid values: '1' or 'App' (application), '00' or 'K' (K combinator), '01' or 'S' (S combinator)
+  - Returns completion status
+
+- **clear_bcl_term**
+  - Clear the current BCL term being constructed and reset the constructor state
+  - No input required
+  - Resets BCL constructor
+
 # Usage with Claude Desktop
 
 ### Setup
@@ -186,9 +243,7 @@ The server can be configured using the following environment variables:
 
 For quick installation, use one of the one-click installation buttons below:
 
-[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPM-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=memory&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-memory%22%5D%7D) [![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPM-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=memory&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-memory%22%5D%7D&quality=insiders)
-
-[![Install with Docker in VS Code](https://img.shields.io/badge/VS_Code-Docker-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=memory&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22-v%22%2C%22claude-memory%3A%2Fapp%2Fdist%22%2C%22--rm%22%2C%22mcp%2Fmemory%22%5D%7D) [![Install with Docker in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Docker-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=memory&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22-i%22%2C%22-v%22%2C%22claude-memory%3A%2Fapp%2Fdist%22%2C%22--rm%22%2C%22mcp%2Fmemory%22%5D%7D&quality=insiders)
+[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPM-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=memory&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40levalicious%2Fserver-memory%22%5D%7D) [![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPM-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=memory&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40levalicious%2Fserver-memory%22%5D%7D&quality=insiders)
 
 For manual installation, add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing `Ctrl + Shift + P` and typing `Preferences: Open Settings (JSON)`.
 
@@ -278,4 +333,4 @@ docker build -t mcp/memory -f src/memory/Dockerfile .
 
 ## License
 
-This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

package/dist/index.js

@@ -15,6 +15,8 @@ const MEMORY_FILE_PATH = process.env.MEMORY_FILE_PATH
     : defaultMemoryPath;
 // The KnowledgeGraphManager class contains all operations to interact with the knowledge graph
 class KnowledgeGraphManager {
+    bclCtr = 0;
+    bclTerm = "";
     async loadGraph() {
         try {
             const data = await fs.readFile(MEMORY_FILE_PATH, "utf-8");
@@ -243,133 +245,174 @@ class KnowledgeGraphManager {
     }
     // 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}`
-                            };
-                        }
-                    }
+        let max_size = program.length;
+        let mode = 0;
+        let ctr = 1;
+        let t0 = program;
+        let t1 = '';
+        let t2 = '';
+        let t3 = '';
+        let t4 = '';
+        while (stepCount < maxSteps) {
+            if (t0.length == 0)
+                break;
+            let b = t0[0];
+            t0 = t0.slice(1);
+            if (mode === 0) {
+                t1 += b;
+                let size = t1.length + t0.length;
+                if (size > max_size)
+                    max_size = size;
+                if (t1.slice(-4) === '1100') {
+                    mode = 1;
+                    t1 = t1.slice(0, -4);
                 }
-                // 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}`
-                                };
-                            }
-                        }
-                    }
+                else if (t1.slice(-5) === '11101') {
+                    mode = 3;
+                    t1 = t1.slice(0, -5);
                 }
             }
-            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;
+            else if (mode === 1) {
+                t2 += b;
+                if (b == '1') {
+                    ctr += 1;
+                }
+                else if (b == '0') {
+                    ctr -= 1;
+                    t2 += t0[0];
+                    t0 = t0.slice(1);
+                }
+                if (ctr === 0) {
+                    mode = 2;
+                    ctr = 1;
+                }
+            }
+            else if (mode === 2) {
+                if (b == '1') {
+                    ctr += 1;
+                }
+                else if (b == '0') {
+                    ctr -= 1;
+                    t0 = t0.slice(1);
+                }
+                if (ctr === 0) {
+                    t0 = t2 + t0;
+                    t2 = '';
+                    mode = 0;
+                    ctr = 1;
+                    stepCount += 1;
+                }
+            }
+            else if (mode === 3) {
+                t2 += b;
+                if (b == '1') {
+                    ctr += 1;
+                }
+                else if (b == '0') {
+                    ctr -= 1;
+                    t2 += t0[0];
+                    t0 = t0.slice(1);
+                }
+                if (ctr === 0) {
+                    mode = 4;
+                    ctr = 1;
+                }
             }
-            current = result.newTerm;
-            if (current.length > max_size) {
-                max_size = current.length;
+            else if (mode === 4) {
+                t3 += b;
+                if (b == '1') {
+                    ctr += 1;
+                }
+                else if (b == '0') {
+                    ctr -= 1;
+                    t3 += t0[0];
+                    t0 = t0.slice(1);
+                }
+                if (ctr === 0) {
+                    mode = 5;
+                    ctr = 1;
+                }
+            }
+            else if (mode === 5) {
+                t4 += b;
+                if (b == '1') {
+                    ctr += 1;
+                }
+                else if (b == '0') {
+                    ctr -= 1;
+                    t4 += t0[0];
+                    t0 = t0.slice(1);
+                }
+                if (ctr === 0) {
+                    t0 = '11' + t2 + t4 + '1' + t3 + t4 + t0;
+                    t2 = '';
+                    t3 = '';
+                    t4 = '';
+                    mode = 0;
+                    ctr = 1;
+                    stepCount += 1;
+                }
             }
-            stepCount++;
         }
         const halted = stepCount < maxSteps;
         return {
-            result: current,
+            result: t1,
             info: `${stepCount} steps, max size ${max_size}`,
-            halted
+            halted,
+            errored: halted && mode != 0,
         };
     }
-    // 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 };
+    async addBCLTerm(term) {
+        const termset = ["1", "00", "01"];
+        if (!term || term.trim() === "") {
+            throw new Error("BCL term cannot be empty");
         }
-        // Check for 00 (K combinator)
-        if (startPos + 1 < input.length && input.substring(startPos, startPos + 2) === '00') {
-            return { success: true, term: '00', nextPos: startPos + 2 };
+        // Term can be 1, 00, 01, or K, S, App (application)
+        const validTerms = ["1", "App", "00", "K", "01", "S"];
+        if (!validTerms.includes(term)) {
+            throw new Error(`Invalid BCL term: ${term}\nExpected one of: ${validTerms.join(", ")}`);
         }
-        // Check for 01 (S combinator) 
-        if (startPos + 1 < input.length && input.substring(startPos, startPos + 2) === '01') {
-            return { success: true, term: '01', nextPos: startPos + 2 };
+        let processedTerm = 0;
+        if (term === "00" || term === "K")
+            processedTerm = 1;
+        else if (term === "01" || term === "S")
+            processedTerm = 2;
+        this.bclTerm += termset[processedTerm];
+        if (processedTerm === 0) {
+            if (this.bclCtr === 0)
+                this.bclCtr += 1;
+            this.bclCtr += 1;
         }
-        // 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 };
+        else {
+            this.bclCtr -= 1;
+        }
+        if (this.bclCtr <= 0) {
+            const constructedProgram = this.bclTerm;
+            this.bclCtr = 0;
+            this.bclTerm = "";
+            return `Constructed Program: ${constructedProgram}`;
+        }
+        else {
+            return `Need ${this.bclCtr} more term(s) to complete the program.`;
         }
-        return { success: false, term: '', nextPos: startPos };
+    }
+    async clearBCLTerm() {
+        this.bclCtr = 0;
+        this.bclTerm = "";
     }
 }
 const knowledgeGraphManager = new KnowledgeGraphManager();
 // The server instance and tools exposed to Claude
 const server = new Server({
     name: "memory-server",
-    version: "0.0.0",
+    icons: [
+        { src: "data:image/svg+xml;base64,PHN2ZyBmaWxsPSJjdXJyZW50Q29sb3IiIGZpbGwtcnVsZT0iZXZlbm9kZCIgaGVpZ2h0PSIxZW0iIHN0eWxlPSJmbGV4Om5vbmU7bGluZS1oZWlnaHQ6MSIgdmlld0JveD0iMCAwIDI0IDI0IiB3aWR0aD0iMWVtIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjx0aXRsZT5Nb2RlbENvbnRleHRQcm90b2NvbDwvdGl0bGU+PHBhdGggZD0iTTIwLjEgNS41MlYxLjVoLS4xOGMtMy4zNi4xNS02LjE1IDIuMzEtNy44MyA0LjAybC0uMDkuMDktLjA5LS4wOUMxMC4yIDMuODEgNy40NCAxLjY1IDQuMDggMS41SDMuOXY0LjAySDB2Ni45M2MwIDEuNjguMDYgMy4zNi4xOCA0Ljc0YTUuNTcgNS41NyAwIDAgMCA1LjE5IDUuMWMyLjEzLjEyIDQuMzguMjEgNi42My4yMXM0LjUtLjA5IDYuNjMtLjI0YTUuNTcgNS41NyAwIDAgMCA1LjE5LTUuMWMuMTItMS4zOC4xOC0zLjA2LjE4LTQuNzR2LTYuOXptMCA2LjkzYzAgMS41OS0uMDYgMy4xNS0uMTggNC40MS0uMDkuODEtLjc1IDEuNDctMS41NiAxLjVhOTAgOTAgMCAwIDEtMTIuNzIgMGMtLjgxLS4wMy0xLjUtLjY5LTEuNTYtMS41LS4xMi0xLjI2LS4xOC0yLjg1LS4xOC00LjQxVjUuNTJjMi44Mi4xMiA1LjY0IDMuMTUgNi40OCA0LjMyTDEyIDEyLjA5bDEuNjItMi4yNWMuODQtMS4yIDMuNjYtNC4yIDYuNDgtNC4zMnoiLz48L3N2Zz4=",
+            mimeType: "image/svg+xml",
+            sizes: ["any"]
+        }
+    ],
+    version: "0.0.4",
 }, {
     capabilities: {
         tools: {},
@@ -651,6 +694,28 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["program"],
                 },
             },
+            {
+                name: "add_bcl_term",
+                description: "Add a BCL term to the constructor, maintaining valid syntax. Returns completion status.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        term: {
+                            type: "string",
+                            description: "BCL term to add. Valid values: '1' or 'App' (application), '00' or 'K' (K combinator), '01' or 'S' (S combinator)"
+                        },
+                    },
+                    required: ["term"],
+                },
+            },
+            {
+                name: "clear_bcl_term",
+                description: "Clear the current BCL term being constructed and reset the constructor state",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
         ],
     };
 });
@@ -701,6 +766,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             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) }] };
+        case "add_bcl_term":
+            return { content: [{ type: "text", text: await knowledgeGraphManager.addBCLTerm(args.term) }] };
+        case "clear_bcl_term":
+            await knowledgeGraphManager.clearBCLTerm();
+            return { content: [{ type: "text", text: "BCL term constructor cleared successfully" }] };
         default:
             throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levalicious/server-memory",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "MCP server for enabling memory for Claude through a knowledge graph",
   "license": "MIT",
   "author": "Levalicious",
@@ -19,7 +19,7 @@
     "watch": "tsc --watch"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.16.0"
+    "@modelcontextprotocol/sdk": "1.21.0"
   },
   "devDependencies": {
     "@types/node": "^24",