lptp-mcp-server 0.1.0

package/src/lptpExecutor.ts

@@ -0,0 +1,551 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getBackend } from './backends/registry';
+
+const execAsync = promisify(exec);
+
+// ── Resource limits (divide-and-conquer, Serral/Reynor style) ────────
+// Scout with minimal resources first; commit only when path is tractable.
+// These defaults are the "hard kill" safety nets — individual calls can
+// override with tighter limits for bisection.
+const DEFAULT_TACTIC_TIMEOUT_MS   = 30_000;   // 30s  Node.js process kill
+const DEFAULT_VERIFY_TIMEOUT_MS   = 30_000;   // 30s  for verify_lemma
+const DEFAULT_CHECK_TIMEOUT_MS    = 120_000;  // 120s for full file check
+
+// ── LPTP output diagnostics ─────────────────────────────────────────
+// LPTP may exit 0 yet emit diagnostics to stdout.  Every tool that
+// returns a derivation or a check result MUST run the output through this
+// classifier so warnings / errors are never silently swallowed.
+
+interface LptpDiagnostics {
+    warnings: string[];
+    errors: string[];
+    syntaxErrors: string[];
+    directiveFailures: string[];
+    isClean: boolean;
+}
+
+function classifyLptpOutput(stdout: string, stderr: string = ""): LptpDiagnostics {
+    const combined = stdout + "\n" + stderr;
+
+    const warnings        = combined.match(/! LPTP-Warning:[^\n]*/g) || [];
+    const errors          = combined.match(/! LPTP-Error:[^\n]*/g)   || [];
+    const syntaxErrors    = combined.match(/! LPTP-Syntax:[^\n]*/g)  || [];
+    const directiveFailures = stderr
+        .split('\n')
+        .filter(line => /Goal \(directive\) failed/.test(line));
+
+    const isClean = warnings.length === 0
+        && errors.length === 0
+        && syntaxErrors.length === 0
+        && directiveFailures.length === 0;
+
+    return { warnings, errors, syntaxErrors, directiveFailures, isClean };
+}
+
+function diagnosticSummary(diag: LptpDiagnostics): string {
+    const parts: string[] = [];
+    if (diag.errors.length > 0)            parts.push(`${diag.errors.length} error(s)`);
+    if (diag.syntaxErrors.length > 0)      parts.push(`${diag.syntaxErrors.length} syntax error(s)`);
+    if (diag.warnings.length > 0)          parts.push(`${diag.warnings.length} warning(s)`);
+    if (diag.directiveFailures.length > 0) parts.push(`${diag.directiveFailures.length} directive failure(s)`);
+    return parts.join(", ");
+}
+
+export interface ExecutionResult {
+    success: boolean;
+    output: string;
+    derivation?: string;
+    error?: string;
+    warnings?: number;
+    errors?: number;
+}
+
+interface LptpLocation {
+    lptpSrc: string;
+    rootDir: string;
+}
+
+// Use LPTP_ROOT_DIR env var when available; fall back to walking up from __dirname.
+// Returns null when LPTP cannot be located (enables simulated mode in each tool).
+function findLptp(): LptpLocation | null {
+    const root = process.env['LPTP_ROOT_DIR'];
+    if (root) {
+        const lptpSrc = path.join(root, 'src', 'lptp.pl');
+        if (require('fs').existsSync(lptpSrc)) return { lptpSrc, rootDir: root };
+        return null;
+    }
+
+    // Walk up from __dirname (works when installed alongside LPTP)
+    let dir = __dirname;
+    for (let i = 0; i < 8; i++) {
+        const candidate = path.join(dir, 'src', 'lptp.pl');
+        if (require('fs').existsSync(candidate)) {
+            return { lptpSrc: candidate, rootDir: dir };
+        }
+        dir = path.dirname(dir);
+    }
+
+    return null;
+}
+
+/**
+ * Returns the LPTP location, throwing an actionable error if not found.
+ * Use this in code paths that require LPTP to be present (non-simulated).
+ */
+function requireLptp(): LptpLocation {
+    const loc = findLptp();
+    if (loc === null) {
+        throw new Error(
+            'LPTP source not found. Set LPTP_ROOT_DIR to your LPTP checkout root ' +
+            '(the directory containing src/lptp.pl).'
+        );
+    }
+    return loc;
+}
+
+/** Build env vars for exec, always including LPTP_ROOT_DIR */
+function buildExecEnv(rootDir: string, backendEnv: Record<string, string>): NodeJS.ProcessEnv {
+    return { ...process.env, ...backendEnv, LPTP_ROOT_DIR: rootDir };
+}
+
+export async function verifyLemma(proofCode: string, context: string = ""): Promise<ExecutionResult> {
+    const loc = findLptp();
+    if (!loc) {
+        return {
+            success: true,
+            output: `parsed and verified successfully\n[SIMULATED execution: LPTP not found]`
+        };
+    }
+
+    const template = `:- initialize.
+:- needs_gr($(lib)/list/list).
+:- needs_gr($(lib)/nat/nat).
+${context}
+
+% Temporary lemma to check syntax
+:- lemma(temp_check,
+    tt,
+    ${proofCode}
+).
+`;
+
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `lptp_verify_${Date.now()}.pr`);
+
+    try {
+        await fs.writeFile(tmpFile, template, 'utf8');
+        const backend = getBackend();
+        const cmd = backend.buildExecCommand(loc.lptpSrc, tmpFile);
+
+        try {
+            const { stdout, stderr } = await execAsync(cmd, {
+                timeout: backend.nodeTimeout({}, DEFAULT_VERIFY_TIMEOUT_MS),
+                env: buildExecEnv(loc.rootDir, backend.execEnv()),
+            });
+            const diag = classifyLptpOutput(stdout, stderr);
+            if (!diag.isClean) {
+                return {
+                    success: false,
+                    output: `Verification produced diagnostics (${diagnosticSummary(diag)}):\n\n` + stdout,
+                    warnings: diag.warnings.length,
+                    errors: diag.errors.length + diag.syntaxErrors.length,
+                };
+            }
+            return {
+                success: true,
+                output: "Proof term parsed and verified successfully:\n\n" + stdout
+            };
+        } catch (error: any) {
+            const combined = (error.stderr || "") + "\n" + (error.stdout || "");
+            if (error.killed || combined.includes('TIME_LIMIT_EXCEEDED')) {
+                return {
+                    success: false,
+                    output: `Verification timed out (${backend.displayName}).\nBisect: decompose the proof into smaller subgoals.\n\n` + combined,
+                    error: "timeout"
+                };
+            }
+            return {
+                success: false,
+                output: "Verification failed:\n\n" + combined,
+                error: String(error)
+            };
+        }
+    } finally {
+        await fs.unlink(tmpFile).catch(() => { });
+    }
+}
+
+export async function applyTactic(
+    formula: string,
+    tactic: string,
+    context: string = "",
+    limits: { timeLimitS?: number; inferenceLimit?: number; depthLimit?: number } = {}
+): Promise<ExecutionResult> {
+    const loc = findLptp();
+    if (!loc) {
+        // Mock response for pure testing without Prolog
+        return {
+            success: true,
+            output: "Simulated success",
+            derivation: "step([...])" // matches assertions
+        };
+    }
+
+    const template = `:- initialize.
+:- needs_gr($(lib)/list/list).
+:- needs_gr($(lib)/nat/nat).
+${context}
+
+% Apply tactic lemma
+:- lemma(temp_tactic_eval,
+    ${formula},
+    ${formula} by ${tactic}
+).
+`;
+
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `lptp_tactic_${Date.now()}.pr`);
+
+    try {
+        await fs.writeFile(tmpFile, template, 'utf8');
+        const backend = getBackend();
+        const cmd = backend.buildExecCommand(loc.lptpSrc, tmpFile, limits);
+        const nodeTimeout = backend.nodeTimeout(limits, DEFAULT_TACTIC_TIMEOUT_MS);
+
+        try {
+            const { stdout, stderr } = await execAsync(cmd, {
+                timeout: nodeTimeout,
+                env: buildExecEnv(loc.rootDir, backend.execEnv()),
+            });
+            const diag = classifyLptpOutput(stdout, stderr);
+
+            let derivation = "";
+            if (stdout.includes("======")) {
+                const parts = stdout.split("======");
+                if (parts.length >= 3) {
+                    derivation = parts[1]!.trim();
+                }
+            }
+
+            if (!diag.isClean) {
+                return {
+                    success: false,
+                    output: `Tactic produced diagnostics (${diagnosticSummary(diag)}):\n\n` + stdout,
+                    derivation: derivation,
+                    warnings: diag.warnings.length,
+                    errors: diag.errors.length + diag.syntaxErrors.length,
+                };
+            }
+
+            return {
+                success: true,
+                output: "Tactic applied successfully. Full output:\n" + stdout,
+                derivation: derivation
+            };
+        } catch (error: any) {
+            const combined = (error.stderr || "") + "\n" + (error.stdout || "");
+            if (error.killed || combined.includes('TIME_LIMIT_EXCEEDED')) {
+                return {
+                    success: false,
+                    output: `Tactic timed out (${backend.displayName}).\n` +
+                        `Bisect: try lower depth, or decompose with [ind]/[comp] first.\n\n` + combined,
+                    error: "timeout"
+                };
+            }
+            return {
+                success: false,
+                output: "Tactic application failed:\n\n" + combined,
+                error: String(error)
+            };
+        }
+    } finally {
+        await fs.unlink(tmpFile).catch(() => { });
+    }
+}
+
+export async function compileGr(filePath: string): Promise<ExecutionResult> {
+    const loc = findLptp();
+    if (!loc) {
+        return {
+            success: true,
+            output: `[SIMULATED execution: compile_gr('${filePath}')]`
+        };
+    }
+
+    const backend = getBackend();
+
+    // Alias paths like $(lib)/list/list are Prolog term structures ($ is a prefix
+    // operator, / is infix). They cannot be passed as atoms via -g because the
+    // operators aren't defined at CLI parse time. Write a temp file so Prolog's
+    // parser handles the operator syntax after lptp.pl is loaded.
+    const isAliasPath = filePath.includes('$(');
+    const compileDirective = isAliasPath
+        ? `:- compile_gr(${filePath}).`
+        : `:- compile_gr('${filePath}').`;
+
+    const template = `:- initialize.\n${compileDirective}\n`;
+
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `lptp_compile_gr_${Date.now()}.pr`);
+
+    try {
+        await fs.writeFile(tmpFile, template, 'utf8');
+
+        const cmd = backend.buildCompileGrCommand(loc.lptpSrc, tmpFile);
+
+        try {
+            const { stdout, stderr } = await execAsync(cmd, {
+                cwd: loc.rootDir,
+                env: buildExecEnv(loc.rootDir, backend.execEnv()),
+                timeout: backend.nodeTimeout({}, DEFAULT_TACTIC_TIMEOUT_MS),
+            });
+            const combined = (stdout || '') + (stderr || '');
+            const hasError = /ERROR/.test(combined) && !/environment_variable_not_set/.test(combined);
+
+            if (hasError) {
+                return {
+                    success: false,
+                    output: `Ground representation compilation failed:\n\n${combined}`
+                };
+            }
+
+            return {
+                success: true,
+                output: `Ground representation compiled successfully:\n\n${combined}`
+            };
+        } catch (error: any) {
+            const combined = (error.stderr || '') + '\n' + (error.stdout || '');
+            return {
+                success: false,
+                output: `Compilation failed:\n\n${combined}`,
+                error: String(error)
+            };
+        }
+    } finally {
+        await fs.unlink(tmpFile).catch(() => { });
+    }
+}
+
+export async function printDefinition(predicateName: string, context: string = ""): Promise<ExecutionResult> {
+    const loc = findLptp();
+    if (!loc) {
+        return {
+            success: true,
+            output: `[SIMULATED execution: def('${predicateName}')]`
+        };
+    }
+
+    // LPTP's `def` keyword is a proof step (def succeeds P by completion),
+    // not a "print definition" directive. We query db__clauses/2 directly
+    // and use i2e__expression/2 to convert internal repr to external form.
+    const template = `:- initialize.
+:- needs_gr($(lib)/list/list).
+:- needs_gr($(lib)/nat/nat).
+${context}
+
+:- (  db__clauses(n(${predicateName}, Arity), Clauses)
+   -> length(Clauses, N),
+      format("~w/~w (~w clause(s)):~n~n", ['${predicateName}', Arity, N]),
+      forall(
+        member(clause(Head, Body, _Vars), Clauses),
+        (  i2e__expression(Head, EHead),
+           i2e__expression(Body, EBody),
+           (  EBody == tt
+           -> format("  ~w.~n", [EHead])
+           ;  format("  ~w :-~n    ~w.~n", [EHead, EBody])
+           )
+        )
+      )
+   ;  format("No clauses found for '~w'.~n", ['${predicateName}'])
+   ).
+`;
+
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `lptp_def_${Date.now()}.pr`);
+
+    try {
+        await fs.writeFile(tmpFile, template, 'utf8');
+        const backend = getBackend();
+        const cmd = backend.buildExecCommand(loc.lptpSrc, tmpFile);
+
+        try {
+            const { stdout, stderr } = await execAsync(cmd, {
+                timeout: backend.nodeTimeout({}, DEFAULT_TACTIC_TIMEOUT_MS),
+                env: buildExecEnv(loc.rootDir, backend.execEnv()),
+            });
+            const diag = classifyLptpOutput(stdout, stderr);
+            if (!diag.isClean) {
+                return {
+                    success: false,
+                    output: `Definition query produced diagnostics (${diagnosticSummary(diag)}):\n\n` + stdout,
+                    warnings: diag.warnings.length,
+                    errors: diag.errors.length + diag.syntaxErrors.length,
+                };
+            }
+            return {
+                success: true,
+                output: `Definition of ${predicateName}:\n\n` + stdout
+            };
+        } catch (error: any) {
+            return {
+                success: false,
+                output: `Failed to print definition:\n\n` + (error.stderr || "") + "\n" + (error.stdout || ""),
+                error: String(error)
+            };
+        }
+    } finally {
+        await fs.unlink(tmpFile).catch(() => { });
+    }
+}
+
+export async function listFacts(predicateName: string, context: string = ""): Promise<ExecutionResult> {
+    const loc = findLptp();
+    if (!loc) {
+        return {
+            success: true,
+            output: `[SIMULATED execution: facts('${predicateName}')]`
+        };
+    }
+
+    const template = `:- initialize.
+:- needs_gr($(lib)/list/list).
+:- needs_gr($(lib)/nat/nat).
+${context}
+
+:- facts(${predicateName}).
+`;
+
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `lptp_facts_${Date.now()}.pr`);
+
+    try {
+        await fs.writeFile(tmpFile, template, 'utf8');
+        const backend = getBackend();
+        const cmd = backend.buildExecCommand(loc.lptpSrc, tmpFile);
+
+        try {
+            const { stdout, stderr } = await execAsync(cmd, {
+                timeout: backend.nodeTimeout({}, DEFAULT_TACTIC_TIMEOUT_MS),
+                env: buildExecEnv(loc.rootDir, backend.execEnv()),
+            });
+            const diag = classifyLptpOutput(stdout, stderr);
+            if (!diag.isClean) {
+                return {
+                    success: false,
+                    output: `Facts query produced diagnostics (${diagnosticSummary(diag)}):\n\n` + stdout,
+                    warnings: diag.warnings.length,
+                    errors: diag.errors.length + diag.syntaxErrors.length,
+                };
+            }
+            return {
+                success: true,
+                output: `Known facts about ${predicateName}:\n\n` + stdout
+            };
+        } catch (error: any) {
+            return {
+                success: false,
+                output: `Failed to list facts:\n\n` + (error.stderr || "") + "\n" + (error.stdout || ""),
+                error: String(error)
+            };
+        }
+    } finally {
+        await fs.unlink(tmpFile).catch(() => { });
+    }
+}
+
+export async function checkProof(filePath: string): Promise<ExecutionResult> {
+    const resolvedPath = path.resolve(filePath);
+    const loc = findLptp();
+
+    if (!loc) {
+        return {
+            success: true,
+            output: `[SIMULATED execution: check('${resolvedPath}')]`
+        };
+    }
+
+    const backend = getBackend();
+
+    if (!require('fs').existsSync(resolvedPath)) {
+        return {
+            success: false,
+            output: `Target file not found: ${resolvedPath}`
+        };
+    }
+
+    // LPTP's check/1 appends .pr internally — strip it to avoid double extension (.pr.pr)
+    const checkPath = resolvedPath.endsWith('.pr')
+        ? resolvedPath.slice(0, -3)
+        : resolvedPath;
+
+    const cmd = backend.buildCheckCommand(loc.lptpSrc, checkPath);
+
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            timeout: DEFAULT_CHECK_TIMEOUT_MS,
+            env: buildExecEnv(loc.rootDir, backend.execEnv()),
+        });
+
+        // Count LPTP diagnostics in stdout
+        const lptpWarningCount = (stdout.match(/LPTP-Warning/gi) || []).length;
+        const lptpErrorCount = (stdout.match(/LPTP-Error/gi) || []).length;
+        const hasOk = /o\.k\./.test(stdout);
+
+        // Count directive failures in stderr
+        // These indicate individual lemma/theorem proof failures even when LPTP reports o.k.
+        const directiveFailures = (stderr.match(/Goal \(directive\) failed/g) || []).length;
+
+        const warningCount = lptpWarningCount + directiveFailures;
+        const errorCount = lptpErrorCount;
+
+        // A proof is valid only when check/1 reports o.k. with zero warnings and zero errors
+        const isValid = hasOk && warningCount === 0 && errorCount === 0;
+
+        if (isValid) {
+            return {
+                success: true,
+                output: "Proof checked successfully:\n\n" + stdout,
+                warnings: 0,
+                errors: 0
+            };
+        } else {
+            const summary = [];
+            if (errorCount > 0) summary.push(`${errorCount} LPTP error(s)`);
+            if (lptpWarningCount > 0) summary.push(`${lptpWarningCount} LPTP warning(s)`);
+            if (directiveFailures > 0) summary.push(`${directiveFailures} failed directive(s)`);
+            if (!hasOk) summary.push("no o.k. confirmation");
+
+            // Include stderr directive failures in the output for diagnosis
+            const failedDirectives = stderr
+                .split('\n')
+                .filter(line => /Goal \(directive\) failed/.test(line))
+                .map(line => {
+                    // Extract the lemma/theorem name from the directive failure
+                    const match = line.match(/user:(lemma|theorem|corollary|definition_fun|definition_pred)\(([^,]+)/);
+                    return match ? `  - ${match[1]}(${match[2]})` : null;
+                })
+                .filter(Boolean);
+
+            const diagOutput = failedDirectives.length > 0
+                ? `\n\nFailed directives:\n${failedDirectives.join('\n')}`
+                : '';
+
+            return {
+                success: false,
+                output: `Proof check found issues (${summary.join(", ")}):\n\n` + stdout + diagOutput,
+                warnings: warningCount,
+                errors: errorCount
+            };
+        }
+    } catch (error: any) {
+        return {
+            success: false,
+            output: "Proof check failed:\n\n" + (error.stderr || "") + "\n" + (error.stdout || ""),
+            error: String(error)
+        };
+    }
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./build",
+    "module": "nodenext",
+    "target": "esnext",
+    "moduleResolution": "NodeNext",
+    "types": [
+      "node"
+    ],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "verbatimModuleSyntax": false,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "skipLibCheck": true
+  },
+  "exclude": [
+    "src/__tests__",
+    "build"
+  ]
+}