lptp-mcp-server 0.1.0

package/src/index.ts

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { applyTactic, verifyLemma, checkProof, compileGr, printDefinition, listFacts } from "./lptpExecutor";
+
+const server = new Server(
+    {
+        name: "LPTP-MCP-Server",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+const LPTP_GRAMMAR_SNIPPET = `
+Term Encoding:
+?x             -> $(x)                      % Variable
+0              -> [n(0, 0)]                 % Constant
+heaps          -> [n(heaps, 0)]             % Constant
+s(?x)          -> [n(s, 1), $(x)]           % Compound (successor)
+[?h|?t]        -> [n('.', 2), $(h), $(t)]   % List (cons)
+[]             -> [n('[]', 0)]              % Empty list
+
+Goals:
+true                -> [&]                              % Empty conjunction
+fail                -> [\\/]                             % Empty disjunction
+?x = s(0)           -> [=, $(x), [n(s,1), [n(0,0)]]]   % Equation
+member(?x, ?l)      -> [n(member, 2), $(x), $(l)]      % Atom
+~member(?x, [])     -> [~, [n(member, 2), $(x), [n('[]', 0)]]]  % Negation
+G1 & G2             -> [&, G1, G2]                      % Conjunction
+G1 \\/ G2            -> [\\/, G1, G2]                     % Disjunction
+
+Formulas:
+tt                  -> [&]                              % Verum
+ff                  -> [\\/]                             % Falsum
+s(?x) = s(?y)       -> [=, [n(s,1), $(x)], [n(s,1), $(y)]]
+succeeds A          -> [succeeds, AtomInternal]
+fails A             -> [fails, AtomInternal]
+terminates G        -> [terminates, GoalInternal]
+\u03c6 & \u03c8               -> [&, \u03c6Internal, \u03c8Internal]
+\u03c6 \\/ \u03c8              -> [\\/, \u03c6Internal, \u03c8Internal]
+\u03c6 => \u03c8              -> [=>, \u03c6Internal, \u03c8Internal]
+all [x]: \u03c6          -> @(all, [x], \u03c6Internal)
+ex [x]: \u03c6           -> @(ex, [x], \u03c6Internal)
+`;
+
+// ── Shared schema fragments ──────────────────────────────────────────
+
+const formulaSchema = {
+    type: "object" as const,
+    properties: {
+        formula: {
+            type: "string" as const,
+            description: "The target formal mathematical expression you want to decompose applying the given tactic.",
+        },
+        context: {
+            type: "string" as const,
+            description: "Any external required definitions or `:- needs_gr(...)` references.",
+        },
+    },
+    required: ["formula"],
+};
+
+const predicateSchema = {
+    type: "object" as const,
+    properties: {
+        predicate_name: {
+            type: "string" as const,
+            description: "The predicate name (e.g. 'append', 'member', 'nat').",
+        },
+        context: {
+            type: "string" as const,
+            description: "Any external required definitions or `:- needs_gr(...)` references.",
+        },
+    },
+    required: ["predicate_name"],
+};
+
+// ── Tool definitions ─────────────────────────────────────────────────
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            // ── Meta tools ───────────────────────────────────────
+            {
+                name: "get_lptp_grammar",
+                description: "Returns a basic summary of LPTP Grammar for LLM reasoning.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            // ── Proof verification ───────────────────────────────
+            {
+                name: "verify_lemma",
+                description: "Validates a snippet of LPTP proof code (e.g., lemma/3, theorem/3) by running it securely through SWI-Prolog. You can inject external context or axioms.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        proof_code: {
+                            type: "string",
+                            description: "The complete `lemma(...)` or syntax token you expect LPTP to compile.",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Definitions, :- needs_gr() statements, or axioms evaluating before the target lemma.",
+                        },
+                    },
+                    required: ["proof_code"],
+                },
+            },
+            {
+                name: "check_proof",
+                description: "Runs LPTP's native check/1 predicate on an existing .pr proof file on disk. Returns all verification errors or confirms the entire proof is valid.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        file_path: {
+                            type: "string",
+                            description: "Absolute path to the .pr proof file to verify with check/1.",
+                        },
+                    },
+                    required: ["file_path"],
+                },
+            },
+            // ── Generic tactic application ───────────────────────
+            {
+                name: "apply_tactic",
+                description: "Applies an LPTP tactic (e.g., `[ind]`, `[auto(5)]`, `completion`) to a given logical formula and returns the expanded proof derivation tree generated by the theorem prover. Essential for navigating proof trees interactivity.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        formula: {
+                            type: "string",
+                            description: "The target formal mathematical expression you want to decompose applying the given tactic.",
+                        },
+                        tactic: {
+                            type: "string",
+                            description: "The LPTP tactic token, e.g. `[ind]`, `[auto(5)]`, `[unfold]`, `completion`.",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Any external required definitions or `:- needs_gr(...)` references.",
+                        },
+                    },
+                    required: ["formula", "tactic"],
+                },
+            },
+            // ── Individual tactics (from etc/lptp-swi-prolog-mode.el) ──
+            {
+                name: "tactic_auto",
+                description: "Try to prove the formula automatically using LPTP's auto tactic with configurable search depth. Combines multiple proof strategies. Resource-limited: uses call_with_inference_limit/3 and call_with_time_limit/2 to prevent hangs.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        formula: {
+                            type: "string",
+                            description: "The target formal mathematical expression to prove.",
+                        },
+                        depth: {
+                            type: "number",
+                            description: "Search depth for automatic proof (default: 5).",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Any external required definitions or `:- needs_gr(...)` references.",
+                        },
+                        inference_limit: {
+                            type: "number",
+                            description: "Max inference steps before aborting (default: 1000000). Use lower values (e.g. 50000) for bisection scouting.",
+                        },
+                        time_limit_seconds: {
+                            type: "number",
+                            description: "Max wall-clock seconds before aborting (default: 25). Use lower values (e.g. 5) for fast scouting.",
+                        },
+                    },
+                    required: ["formula"],
+                },
+            },
+            {
+                name: "tactic_case",
+                description: "Try to prove the formula by case splitting on disjunctions or pattern matches.",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_comp",
+                description: "Try to prove the formula by taking a completion formula (fixed-point semantics of program clauses).",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_elim",
+                description: "Try to prove the formula by expanding (eliminating) a predicate definition.",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_ex",
+                description: "Try to prove the formula by existential elimination (instantiating an existential quantifier).",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_fact",
+                description: "Try to prove the formula by applying a known fact (lemma, theorem, corollary, or axiom).",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_ind",
+                description: "Try to prove the formula by structural induction on an inductively defined predicate.",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_indqf",
+                description: "Try to prove the formula by quantifier-free induction (induction without universally quantified induction hypothesis).",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_tot",
+                description: "Try to prove the formula by case splitting on totality (termination) of a predicate call.",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_unfold",
+                description: "Try to prove the formula by unfolding an abbreviation or definition.",
+                inputSchema: formulaSchema,
+            },
+            {
+                name: "tactic_debug",
+                description: "Show the available formulas and assumptions in the current proof context. Useful for understanding what facts are available to complete a proof step.",
+                inputSchema: formulaSchema,
+            },
+            // ── Query tools ──────────────────────────────────────
+            {
+                name: "print_definition",
+                description: "Print the completion definition of a predicate. Shows the IND(P) fixed-point axioms (success, failure, termination) generated from the program clauses.",
+                inputSchema: predicateSchema,
+            },
+            {
+                name: "list_facts",
+                description: "List all known theorems, lemmas, and corollaries about a predicate. Useful for discovering what has already been proved.",
+                inputSchema: predicateSchema,
+            },
+            // ── Compilation ──────────────────────────────────────
+            {
+                name: "compile_gr",
+                description: "Compiles a .pl (Prolog program) file into its LPTP ground representation (.gr). The .gr file is written next to the .pl source. Accepts LPTP alias paths (e.g. '$(examples)/gen_99p/list_ops') or filesystem paths (e.g. 'examples/gen_99p/list_ops'). Path must omit the .pl extension.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        file_path: {
+                            type: "string",
+                            description: "Path to the .pl file WITHOUT the .pl extension. Supports LPTP aliases like $(examples), $(lib) or filesystem paths.",
+                        },
+                    },
+                    required: ["file_path"],
+                },
+            },
+        ],
+    };
+});
+
+// ── Tool dispatch ────────────────────────────────────────────────────
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const args = request.params.arguments as any;
+
+    switch (request.params.name) {
+        case "get_lptp_grammar": {
+            return {
+                content: [{ type: "text", text: LPTP_GRAMMAR_SNIPPET }],
+            };
+        }
+        case "verify_lemma": {
+            const result = await verifyLemma(args.proof_code, args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "check_proof": {
+            const result = await checkProof(args.file_path);
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "compile_gr": {
+            const result = await compileGr(args.file_path);
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        // ── Generic tactic ───────────────────────────────────
+        case "apply_tactic": {
+            const result = await applyTactic(args.formula, args.tactic, args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        // ── Individual tactics ───────────────────────────────
+        case "tactic_auto": {
+            const depth = args.depth ?? 5;
+            const limits: { timeLimitS?: number; inferenceLimit?: number } = {};
+            if (args.inference_limit != null) limits.inferenceLimit = args.inference_limit;
+            if (args.time_limit_seconds != null) limits.timeLimitS = args.time_limit_seconds;
+            const result = await applyTactic(args.formula, `[auto(${depth})]`, args.context || "", limits);
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_case": {
+            const result = await applyTactic(args.formula, "[case]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_comp": {
+            const result = await applyTactic(args.formula, "[comp]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_elim": {
+            const result = await applyTactic(args.formula, "[elim]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_ex": {
+            const result = await applyTactic(args.formula, "[ex]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_fact": {
+            const result = await applyTactic(args.formula, "[fact]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_ind": {
+            const result = await applyTactic(args.formula, "[ind]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_indqf": {
+            const result = await applyTactic(args.formula, "[indqf]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_tot": {
+            const result = await applyTactic(args.formula, "[tot]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_unfold": {
+            const result = await applyTactic(args.formula, "[unfold]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "tactic_debug": {
+            const result = await applyTactic(args.formula, "[debug]", args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        // ── Query tools ──────────────────────────────────────
+        case "print_definition": {
+            const result = await printDefinition(args.predicate_name, args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        case "list_facts": {
+            const result = await listFacts(args.predicate_name, args.context || "");
+            return { content: [{ type: "text", text: result.output }] };
+        }
+        default:
+            throw new Error("Unknown tool");
+    }
+});
+
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("LPTP-MCP-Server running on stdio");
+}
+
+runServer().catch((error) => {
+    console.error("Failed to run MCP Server:");
+    console.error(error);
+    process.exit(1);
+});