clingo-mcp 0.1.0

package/README.md

@@ -0,0 +1,81 @@
+# Clingo-MCP Server
+
+A neurosymbolic AI server combining Clingo's Answer Set Programming (ASP) solver with Model Context Protocol (MCP) for hybrid AI applications.
+
+**Features:**
+- Answer Set Programming solver via WebAssembly
+- In-memory program session: build up programs incrementally
+- Session management: save/load ASP programs to disk
+- Six core tools:
+  - `solve`: Run an ASP program and get answer sets
+  - `addToProgram`: Add facts/rules to current session
+  - `clearProgram`: Clear the current session
+  - `getProgram`: View the current program
+  - `saveSession`: Persist program to disk
+  - `loadSession`: Restore previous sessions
+- Type safety via Zod schema validation for all I/O
+- WebAssembly runtime: Clingo compiled to WASM
+
+**Integration with Cline/Roo/Copilot:**
+```json
+{
+  "mcpServers": {
+    "clingo-mcp": {
+      "command": "node",
+      "args": [
+        "clingo-mcp/dist/index.js"
+      ],
+      "disabled": false,
+      "alwaysAllow": [
+        "solve",
+        "addToProgram",
+        "clearProgram",
+        "getProgram",
+        "saveSession",
+        "loadSession"
+      ],
+      "timeout": 30
+    }
+  }
+}
+```
+
+**Development:**
+```bash
+git clone https://github.com/NewJerseyStyle/clingo-mcp
+cd clingo-mcp
+npm install
+npm run build
+```
+
+**Example ASP Program:**
+```asp
+% Define persons
+person(alice).
+person(bob).
+person(carol).
+
+% Define friendships
+friend(alice, bob).
+friend(bob, carol).
+
+% Rule: friendship is symmetric
+friend(X, Y) :- friend(Y, X).
+
+% Rule: transitive friendship
+indirect_friend(X, Z) :- friend(X, Y), friend(Y, Z), X != Z.
+```
+
+**Example Usage:**
+```javascript
+// Using the solve tool
+const result = await solve({
+  program: "a. b :- a. {c; d}.",
+  models: 0  // 0 = all models
+});
+```
+
+---
+
+**Acknowledgements:**
+Built with [clingo-wasm](https://github.com/domoritz/clingo-wasm) and [MCP Protocol](https://modelcontextprotocol.io)

package/dist/clingoServer.js

@@ -0,0 +1,214 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ToolSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import clingo from "clingo-wasm";
+const ToolInputSchema = ToolSchema.shape.inputSchema;
+import * as fs from 'fs';
+import * as path from 'path';
+/* Schemas for Clingo tools */
+const SolveSchema = z.object({
+    program: z.string().describe("The ASP (Answer Set Programming) program to solve"),
+    models: z.number().optional().default(0).describe("Number of models to compute (0 = all models)"),
+});
+const AddToProgramSchema = z.object({
+    code: z.string().describe("ASP facts or rules to add to the current program"),
+});
+const SaveSessionSchema = z.object({
+    filename: z.string().describe("The name to save the session under"),
+});
+const LoadSessionSchema = z.object({
+    filename: z.string().describe("The name of the session to load"),
+});
+var ToolName;
+(function (ToolName) {
+    ToolName["SOLVE"] = "solve";
+    ToolName["ADD_TO_PROGRAM"] = "addToProgram";
+    ToolName["CLEAR_PROGRAM"] = "clearProgram";
+    ToolName["GET_PROGRAM"] = "getProgram";
+    ToolName["SAVE_SESSION"] = "saveSession";
+    ToolName["LOAD_SESSION"] = "loadSession";
+})(ToolName || (ToolName = {}));
+// Sessions directory path relative to project root
+const SESSIONS_DIR = './clingo-sessions';
+export const createServer = async () => {
+    // In-memory program storage (since clingo-wasm doesn't maintain state)
+    let currentProgram = "";
+    // Ensure sessions directory exists
+    if (!fs.existsSync(SESSIONS_DIR)) {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    }
+    const server = new Server({
+        name: "clingo-mcp",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = [
+            {
+                name: ToolName.SOLVE,
+                description: "Solves an ASP (Answer Set Programming) program using Clingo and returns the answer sets. The program can include the current session program.",
+                inputSchema: zodToJsonSchema(SolveSchema),
+            },
+            {
+                name: ToolName.ADD_TO_PROGRAM,
+                description: "Adds ASP facts or rules to the current in-memory program session",
+                inputSchema: zodToJsonSchema(AddToProgramSchema),
+            },
+            {
+                name: ToolName.CLEAR_PROGRAM,
+                description: "Clears the current in-memory program session",
+                inputSchema: { type: "object", properties: {}, required: [] },
+            },
+            {
+                name: ToolName.GET_PROGRAM,
+                description: "Returns the current in-memory ASP program",
+                inputSchema: { type: "object", properties: {}, required: [] },
+            },
+            {
+                name: ToolName.SAVE_SESSION,
+                description: "Saves the current ASP program session to a file for later loading",
+                inputSchema: zodToJsonSchema(SaveSessionSchema),
+            },
+            {
+                name: ToolName.LOAD_SESSION,
+                description: "Loads a previously saved ASP program session",
+                inputSchema: zodToJsonSchema(LoadSessionSchema),
+            },
+        ];
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (name === ToolName.SOLVE) {
+            const validatedArgs = SolveSchema.parse(args);
+            const { program, models } = validatedArgs;
+            try {
+                // Combine current session program with the provided program
+                const fullProgram = currentProgram ? `${currentProgram}\n${program}` : program;
+                // Run clingo with the combined program
+                const result = await clingo.run(fullProgram, models);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        }]
+                };
+            }
+            catch (e) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error solving program: ${e}`,
+                            annotations: { priority: 1.0 }
+                        }]
+                };
+            }
+        }
+        if (name === ToolName.ADD_TO_PROGRAM) {
+            const validatedArgs = AddToProgramSchema.parse(args);
+            const { code } = validatedArgs;
+            try {
+                // Append to current program with a newline separator
+                if (currentProgram) {
+                    currentProgram += "\n" + code;
+                }
+                else {
+                    currentProgram = code;
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Added to program. Current program:\n${currentProgram}`
+                        }]
+                };
+            }
+            catch (e) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error adding to program: ${e}`,
+                            annotations: { priority: 1.0 }
+                        }]
+                };
+            }
+        }
+        if (name === ToolName.CLEAR_PROGRAM) {
+            currentProgram = "";
+            return {
+                content: [{
+                        type: "text",
+                        text: "Program cleared successfully"
+                    }]
+            };
+        }
+        if (name === ToolName.GET_PROGRAM) {
+            return {
+                content: [{
+                        type: "text",
+                        text: currentProgram ? `Current program:\n${currentProgram}` : "No program loaded"
+                    }]
+            };
+        }
+        if (name === ToolName.SAVE_SESSION) {
+            const validatedArgs = SaveSessionSchema.parse(args);
+            const filename = validatedArgs.filename;
+            try {
+                if (!currentProgram.trim()) {
+                    throw new Error("No program content to save");
+                }
+                const sessionPath = path.join(SESSIONS_DIR, `${filename}.lp`);
+                fs.writeFileSync(sessionPath, currentProgram);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Session saved to ${sessionPath}`
+                        }]
+                };
+            }
+            catch (e) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error saving session: ${e}`,
+                            annotations: { priority: 1.0 }
+                        }]
+                };
+            }
+        }
+        if (name === ToolName.LOAD_SESSION) {
+            const validatedArgs = LoadSessionSchema.parse(args);
+            const filename = validatedArgs.filename;
+            try {
+                const sessionPath = path.join(SESSIONS_DIR, `${filename}.lp`);
+                if (!fs.existsSync(sessionPath)) {
+                    throw new Error(`Session file ${sessionPath} not found`);
+                }
+                currentProgram = fs.readFileSync(sessionPath, 'utf8');
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Session loaded from ${sessionPath}\nCurrent program:\n${currentProgram}`
+                        }]
+                };
+            }
+            catch (e) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error loading session: ${e}`,
+                            annotations: { priority: 1.0 }
+                        }]
+                };
+            }
+        }
+        throw new Error(`Unknown tool: ${name}`);
+    });
+    const cleanup = async () => {
+        // Clean up any resources if needed when server shuts down
+    };
+    return { server, cleanup };
+};

package/dist/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./clingoServer.js";
+async function main() {
+    const transport = new StdioServerTransport();
+    const { server, cleanup } = await createServer();
+    await server.connect(transport);
+    // Cleanup on exit
+    process.on("SIGINT", async () => {
+        await cleanup();
+        await server.close();
+        process.exit(0);
+    });
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "clingo-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for interacting with Clingo ASP solver via WebAssembly",
+  "license": "MIT",
+  "author": "NewJerseyStyle",
+  "homepage": "https://github.com/NewJerseyStyle/clingo-mcp",
+  "bugs": "https://github.com/NewJerseyStyle/clingo-mcp/issues",
+  "type": "module",
+  "bin": {
+    "mcp-server-clingo": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.0.1",
+    "clingo-wasm": "latest",
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.23.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "shx": "^0.3.4",
+    "typescript": "^5.6.2",
+    "vite": "^6.3.0"
+  }
+}