lptp-mcp-server 0.1.0

package/src/__tests__/mcp_lptp_server.test.ts

@@ -0,0 +1,97 @@
+import { applyTactic, verifyLemma, checkProof } from '../lptpExecutor';
+import * as path from 'path';
+
+describe('LPTP Tactic Applications', () => {
+    // These tests currently fail since we haven't implemented the functions yet!
+    // Strict TDD: Write the test, verify failure, then write the implementation.
+
+    describe('verifyLemma', () => {
+        it('should correctly verify a grammatically sound lemma without tactics', async () => {
+            const proof = "succeeds member(?y, [?y|?l]) by completion";
+            const result = await verifyLemma(proof);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('parsed and verified successfully');
+        });
+    });
+
+    describe('checkProof', () => {
+        it('should correctly execute the check/1 predicate against an existing file', async () => {
+            // Resolve relative to LPTP_ROOT_DIR or walk up from test location
+            const lptpRoot = process.env['LPTP_ROOT_DIR'] || path.resolve(__dirname, '..', '..', '..', '..', '..');
+            const mockFilePath = path.join(lptpRoot, 'test', 'proof', 'proof1.pr');
+            const result = await checkProof(mockFilePath);
+            // When SWI-Prolog is present, success depends on proof validity.
+            // We only assert the call completes and returns a string output.
+            expect(result.output).toBeDefined();
+            expect(typeof result.output).toBe('string');
+        });
+    });
+
+    describe('applyTactic', () => {
+        // Test definitions for the exhaustive tactic list required
+
+        it('handles the `auto(N)` tactic', async () => {
+            const formula = "sub([?y|?l1], ?l2)";
+            const result = await applyTactic(formula, "[auto(11)]", "all [l1,l2]: sub(?l1,?l2) <=> (all x: succeeds member(?x,?l1) => succeeds member(?x,?l2))");
+            expect(result.success).toBe(true);
+            expect(result.derivation).toBeDefined();
+        });
+
+        it('handles the `ind` tactic', async () => {
+            const formula = "all [y,l1,l2]: succeeds append(?l1,?l2,?l3) => succeeds member(?y,?l1) \\/ succeeds member(?y,?l2)";
+            const result = await applyTactic(formula, "[ind]");
+            expect(result.success).toBe(true);
+            expect(result.derivation).toContain('assume(');
+        });
+
+        it('handles the `case` tactic', async () => {
+            const formula = "succeeds member(?x, ?l1) \\/ succeeds member(?x, ?l2)";
+            const result = await applyTactic(formula, "[case]");
+            expect(result.success).toBe(true);
+            expect(result.derivation).toContain('by gap');
+        });
+
+        it('handles the `elim` tactic', async () => {
+            const formula = "succeeds member(?x, [?y|?l])";
+            const result = await applyTactic(formula, "[elim]");
+            expect(result.success).toBe(true);
+        });
+
+        it('handles the `fact` tactic', async () => {
+            const formula = "succeeds member(?x, ?l1) => succeeds append(?l1, ?l2, ?l3)";
+            const result = await applyTactic(formula, "[fact]");
+            expect(result.success).toBe(true);
+        });
+
+        it('handles the `tot` tactic', async () => {
+            const formula = "terminates append(?l1, ?l2, ?l3)";
+            const result = await applyTactic(formula, "[tot]");
+            expect(result.success).toBe(true);
+        });
+
+        it('handles the `unfold` tactic', async () => {
+            const formula = "succeeds append([?h|?t], ?l2, [?h|?t3])";
+            const result = await applyTactic(formula, "[unfold]");
+            expect(result.success).toBe(true);
+        });
+
+        it('handles the `ex` tactic', async () => {
+            const formula = "ex [y]: succeeds member(?y, ?l)";
+            const result = await applyTactic(formula, "[ex]");
+            expect(result.success).toBe(true);
+        });
+
+        it('handles the `comp` tactic', async () => {
+            const formula = "succeeds append([], ?l, ?l)";
+            const result = await applyTactic(formula, "completion");
+            expect(result.success).toBe(true);
+        });
+
+        it('handles the `indqf` tactic', async () => {
+            const formula = "p(?x) => q(?x)";
+            const result = await applyTactic(formula, "[indqf]");
+            expect(result.success).toBe(true);
+            expect(result.derivation).toContain('assume(');
+        });
+    });
+});

package/src/backends/gprolog.ts

@@ -0,0 +1,87 @@
+import * as path from 'path';
+import type { PrologBackend, ResourceLimits } from './types';
+
+/**
+ * GNU Prolog backend.
+ *
+ * CLI pattern (from Makefile line 839):
+ *   cat ./src/allg.pl | ./bin/lptp-gnu-prolog
+ *
+ * Key differences from SWI-Prolog:
+ *   - Uses a pre-compiled binary (bin/lptp-gnu-prolog) with LPTP baked in
+ *   - No consult needed — LPTP is compiled into the binary
+ *   - Input is piped via stdin: echo "goal." | bin/lptp-gnu-prolog
+ *   - No Prolog-level resource limits — Node.js timeout only
+ *   - PREVENT_PRE_COMPILATION=true avoids .gr compilation on startup
+ */
+export class GprologBackend implements PrologBackend {
+    readonly id = 'gprolog' as const;
+    readonly displayName = 'GNU Prolog';
+
+    private getBinaryPath(): string {
+        const root = process.env['LPTP_ROOT_DIR'];
+        if (root) return path.join(root, 'bin', 'lptp-gnu-prolog');
+
+        // Walk up from __dirname to find bin/lptp-gnu-prolog
+        let dir = __dirname;
+        for (let i = 0; i < 8; i++) {
+            const candidate = path.join(dir, 'bin', 'lptp-gnu-prolog');
+            if (require('fs').existsSync(candidate)) return candidate;
+            dir = path.dirname(dir);
+        }
+
+        throw new Error(
+            'GNU Prolog binary (bin/lptp-gnu-prolog) not found. ' +
+            'Set LPTP_ROOT_DIR to your LPTP checkout root, or build the binary with: cd src && make gprolog'
+        );
+    }
+
+    isAvailable(): boolean {
+        try {
+            this.getBinaryPath();
+            return require('fs').existsSync(this.getBinaryPath());
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * GNU Prolog has no Prolog-level resource limits.
+     * Returns the goal unchanged, wrapped in once/1 for determinism.
+     */
+    wrapWithLimits(goal: string, _limits?: ResourceLimits): string {
+        return `once(${goal})`;
+    }
+
+    buildExecCommand(_lptpSrc: string, tmpFile: string, _limits?: ResourceLimits): string {
+        const binary = this.getBinaryPath();
+        // LPTP is compiled into the binary — no consult needed
+        return `echo "exec('${tmpFile}')." | ${binary}`;
+    }
+
+    buildCheckCommand(_lptpSrc: string, checkPath: string, _limits?: ResourceLimits): string {
+        const binary = this.getBinaryPath();
+        return `echo "check('${checkPath}')." | ${binary}`;
+    }
+
+    buildCompileGrCommand(_lptpSrc: string, tmpFile: string, _limits?: ResourceLimits): string {
+        const binary = this.getBinaryPath();
+        return `echo "exec('${tmpFile}')." | ${binary}`;
+    }
+
+    suppressWarningsGoal(): string {
+        return '';
+    }
+
+    nodeTimeout(limits: ResourceLimits = {}, defaultMs: number = 30_000): number {
+        // Node.js timeout is the only guard for GNU Prolog.
+        if (limits.timeLimitS != null) {
+            return limits.timeLimitS * 1000 + 5000;
+        }
+        return defaultMs;
+    }
+
+    execEnv(): Record<string, string> {
+        return { PREVENT_PRE_COMPILATION: 'true' };
+    }
+}

package/src/backends/registry.ts

@@ -0,0 +1,70 @@
+import type { BackendId, PrologBackend } from './types';
+import { SwiplBackend } from './swipl';
+import { ScryerBackend } from './scryer';
+import { GprologBackend } from './gprolog';
+
+let cachedBackend: PrologBackend | null = null;
+
+function instantiate(id: BackendId): PrologBackend {
+    switch (id) {
+        case 'swipl':  return new SwiplBackend();
+        case 'scryer': return new ScryerBackend();
+        case 'gprolog': return new GprologBackend();
+    }
+}
+
+/**
+ * Returns the active Prolog backend.
+ *
+ * Selection logic:
+ *   1. If LPTP_PROLOG_BACKEND env var is set, use that backend (throw if unavailable).
+ *   2. Otherwise auto-detect in order: swipl -> scryer -> gprolog (first available wins).
+ *   3. If none found, throw a descriptive error.
+ *
+ * Result is cached for the lifetime of the server process.
+ */
+export function getBackend(): PrologBackend {
+    if (cachedBackend) return cachedBackend;
+
+    const envChoice = process.env['LPTP_PROLOG_BACKEND'] as BackendId | undefined;
+
+    if (envChoice) {
+        const validIds: BackendId[] = ['swipl', 'scryer', 'gprolog'];
+        if (!validIds.includes(envChoice)) {
+            throw new Error(
+                `LPTP_PROLOG_BACKEND="${envChoice}" is not valid. ` +
+                `Choose one of: ${validIds.join(', ')}`
+            );
+        }
+        const backend = instantiate(envChoice);
+        if (!backend.isAvailable()) {
+            throw new Error(
+                `LPTP_PROLOG_BACKEND="${envChoice}" requested but ` +
+                `${backend.displayName} is not available on this system.`
+            );
+        }
+        cachedBackend = backend;
+        return cachedBackend;
+    }
+
+    // Auto-detect: try each backend in preference order
+    const probeOrder: BackendId[] = ['swipl', 'scryer', 'gprolog'];
+    for (const id of probeOrder) {
+        const backend = instantiate(id);
+        if (backend.isAvailable()) {
+            cachedBackend = backend;
+            return cachedBackend;
+        }
+    }
+
+    throw new Error(
+        'No Prolog backend found. Install SWI-Prolog (swipl), ' +
+        'Scryer Prolog (scryer-prolog), or build GNU Prolog binary ' +
+        '(cd src && make gprolog). Or set LPTP_PROLOG_BACKEND explicitly.'
+    );
+}
+
+/** Reset cached backend — useful for tests. */
+export function resetBackendCache(): void {
+    cachedBackend = null;
+}

package/src/backends/scryer.ts

@@ -0,0 +1,83 @@
+import { execSync } from 'child_process';
+import type { PrologBackend, ResourceLimits } from './types';
+
+const DEFAULT_INFERENCE_LIMIT = 1_000_000;
+
+/**
+ * Scryer Prolog backend.
+ *
+ * CLI pattern (from Makefile line 819):
+ *   scryer-prolog -g "consult('./src/lptp.pl'),exec('file')." -g "halt."
+ *
+ * Key differences from SWI-Prolog:
+ *   - Goals passed to -g need a trailing period
+ *   - Supports call_with_inference_limit/3 from iso_ext module
+ *   - No call_with_time_limit or call_with_depth_limit — Node.js timeout covers those
+ *   - Quiet mode via QUIET_MODE=true environment variable
+ *   - No message_hook suppression needed
+ */
+export class ScryerBackend implements PrologBackend {
+    readonly id = 'scryer' as const;
+    readonly displayName = 'Scryer Prolog';
+
+    isAvailable(): boolean {
+        try { execSync('which scryer-prolog', { stdio: 'ignore' }); return true; }
+        catch { return false; }
+    }
+
+    /**
+     * Wraps a Prolog goal with Scryer-specific resource limits.
+     * Only inference limit is supported at the Prolog level via
+     * call_with_inference_limit/3 (iso_ext module).
+     * Time and depth limits fall back to Node.js timeout.
+     */
+    wrapWithLimits(goal: string, limits: ResourceLimits = {}): string {
+        let wrapped = `once(${goal})`;
+
+        const infLim = limits.inferenceLimit ?? DEFAULT_INFERENCE_LIMIT;
+        wrapped = `call_with_inference_limit((${wrapped}), ${infLim}, _InfRes)`;
+
+        return wrapped;
+    }
+
+    buildExecCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string {
+        const wrappedGoal = this.wrapWithLimits(
+            `(consult('${lptpSrc}'), exec('${tmpFile}'))`,
+            limits
+        );
+        return `scryer-prolog -g "${wrappedGoal}." -g "halt."`;
+    }
+
+    buildCheckCommand(lptpSrc: string, checkPath: string, limits?: ResourceLimits): string {
+        const wrappedGoal = this.wrapWithLimits(
+            `(consult('${lptpSrc}'), check('${checkPath}'))`,
+            limits ?? { inferenceLimit: 10_000_000 }
+        );
+        return `scryer-prolog -g "${wrappedGoal}." -g "halt."`;
+    }
+
+    buildCompileGrCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string {
+        const wrappedGoal = this.wrapWithLimits(
+            `(consult('${lptpSrc}'), exec('${tmpFile}'))`,
+            limits
+        );
+        return `scryer-prolog -g "${wrappedGoal}." -g "halt."`;
+    }
+
+    suppressWarningsGoal(): string {
+        return '';
+    }
+
+    nodeTimeout(limits: ResourceLimits = {}, defaultMs: number = 30_000): number {
+        // Scryer has no Prolog-level time limit, so Node.js timeout is the primary guard.
+        // Use the timeLimitS hint if provided, otherwise fall back to defaultMs.
+        if (limits.timeLimitS != null) {
+            return limits.timeLimitS * 1000 + 5000;
+        }
+        return defaultMs;
+    }
+
+    execEnv(): Record<string, string> {
+        return { QUIET_MODE: 'true' };
+    }
+}

package/src/backends/swipl.ts

@@ -0,0 +1,88 @@
+import { execSync } from 'child_process';
+import type { PrologBackend, ResourceLimits } from './types';
+
+const DEFAULT_PROLOG_TIME_LIMIT_S = 25;
+const DEFAULT_INFERENCE_LIMIT     = 1_000_000;
+
+export class SwiplBackend implements PrologBackend {
+    readonly id = 'swipl' as const;
+    readonly displayName = 'SWI-Prolog';
+
+    isAvailable(): boolean {
+        try { execSync('which swipl', { stdio: 'ignore' }); return true; }
+        catch { return false; }
+    }
+
+    /**
+     * Wraps a SWI-Prolog goal with resource limits:
+     *   once/1                       — deterministic, no backtracking
+     *   call_with_time_limit/2       — wall-clock timeout (throws time_limit_exceeded)
+     *   call_with_inference_limit/3  — inference bound (binds Result)
+     *   call_with_depth_limit/3      — depth bound (binds Result)
+     *
+     * If any limit is exceeded the process writes a diagnostic and halts with
+     * a non-zero exit code so the Node.js side captures it as an error.
+     */
+    wrapWithLimits(goal: string, limits: ResourceLimits = {}): string {
+        const timeS  = limits.timeLimitS ?? DEFAULT_PROLOG_TIME_LIMIT_S;
+        const infLim = limits.inferenceLimit ?? DEFAULT_INFERENCE_LIMIT;
+
+        // Build from inside out:
+        //   innermost: once(Goal)
+        //   then: call_with_inference_limit(…, InfLim, InfRes)
+        //   then: call_with_time_limit(TimeS, …)
+        //   outermost: catch(…, time_limit_exceeded, diagnostic)
+        let wrapped = `once(${goal})`;
+
+        // Inference limit guard
+        wrapped = `call_with_inference_limit((${wrapped}), ${infLim}, _InfRes)`;
+
+        // Optional depth limit
+        if (limits.depthLimit != null) {
+            wrapped = `call_with_depth_limit((${wrapped}), ${limits.depthLimit}, _DepthRes)`;
+        }
+
+        // Time limit guard (outermost catch)
+        wrapped = `catch(call_with_time_limit(${timeS}, (${wrapped})), time_limit_exceeded, (write('TIME_LIMIT_EXCEEDED'), nl, halt(2)))`;
+
+        return wrapped;
+    }
+
+    buildExecCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string {
+        const wrappedGoal = this.wrapWithLimits(
+            `(consult('${lptpSrc}'), exec('${tmpFile}'))`,
+            limits
+        );
+        return `swipl -q -g "${wrappedGoal}, halt" -t "halt(1)"`;
+    }
+
+    buildCheckCommand(lptpSrc: string, checkPath: string, limits?: ResourceLimits): string {
+        const suppressWarnings = this.suppressWarningsGoal();
+        const wrappedGoal = this.wrapWithLimits(
+            `(${suppressWarnings}, consult('${lptpSrc}'), check('${checkPath}'))`,
+            limits ?? { timeLimitS: 110, inferenceLimit: 10_000_000 }
+        );
+        return `swipl -q -g "${wrappedGoal}, halt" -t "halt(1)"`;
+    }
+
+    buildCompileGrCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string {
+        const wrappedGoal = this.wrapWithLimits(
+            `(consult('${lptpSrc}'), exec('${tmpFile}'))`,
+            limits
+        );
+        return `swipl -q -g "${wrappedGoal}, halt" -t "halt(1)"`;
+    }
+
+    suppressWarningsGoal(): string {
+        return `asserta((user:message_hook(_,warning,_) :- !))`;
+    }
+
+    nodeTimeout(limits: ResourceLimits = {}, defaultMs: number = 30_000): number {
+        const timeS = limits.timeLimitS ?? DEFAULT_PROLOG_TIME_LIMIT_S;
+        return timeS * 1000 + 5000;
+    }
+
+    execEnv(): Record<string, string> {
+        return {};
+    }
+}

package/src/backends/types.ts

@@ -0,0 +1,36 @@
+export type BackendId = 'swipl' | 'scryer' | 'gprolog';
+
+export interface ResourceLimits {
+    timeLimitS?: number;
+    inferenceLimit?: number;
+    depthLimit?: number;
+}
+
+export interface PrologBackend {
+    readonly id: BackendId;
+    readonly displayName: string;
+
+    /** Returns true when the backend's binary / compiled artifact is on PATH or at expected location. */
+    isAvailable(): boolean;
+
+    /** Build shell command that runs `exec(TmpFile)` through LPTP. */
+    buildExecCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+
+    /** Build shell command that runs `check(CheckPath)` through LPTP. */
+    buildCheckCommand(lptpSrc: string, checkPath: string, limits?: ResourceLimits): string;
+
+    /** Build shell command that compiles a .gr file through LPTP. */
+    buildCompileGrCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+
+    /** Wrap a Prolog goal with backend-specific resource limits. */
+    wrapWithLimits(goal: string, limits?: ResourceLimits): string;
+
+    /** Return a Prolog goal that suppresses backend-specific warnings, or '' if N/A. */
+    suppressWarningsGoal(): string;
+
+    /** Compute Node.js exec timeout (ms) from limits. */
+    nodeTimeout(limits?: ResourceLimits, defaultMs?: number): number;
+
+    /** Extra environment variables for child_process.exec. */
+    execEnv(): Record<string, string>;
+}