eyeprolog 1.2.5 → 1.2.6

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/repl.js

@@ -24,7 +24,7 @@ export async function runRepl(engine, options = {}) {
   let exitCode = 0;
 
   try {
-    state.solver.runInitializations();
+    runWithTerminalSignals(reader, () => state.solver.runInitializations());
     while (true) {
       const text = await readQuery(reader);
       if (text == null) break;
@@ -35,7 +35,7 @@ export async function runRepl(engine, options = {}) {
         if (!options.isoStrict && isUseModuleGoal(goal)) {
           sources.push({ text: `:- ${text}.\n`, filename: '<repl>' });
           state = makeState(engine, sources, output, options, state);
-          state.solver.runInitializations();
+          runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write('   true.\n');
           continue;
         }
@@ -43,7 +43,7 @@ export async function runRepl(engine, options = {}) {
         if (consultFiles != null) {
           for (const filename of consultFiles) sources.push(await readSource(filename));
           state = makeState(engine, sources, output, options, state);
-          state.solver.runInitializations();
+          runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write('   true.\n');
           continue;
         }
@@ -142,12 +142,39 @@ class LineReader {
     return control;
   }
 
+  suspendForComputation() {
+    if (!this.terminal || !this.readline) return false;
+    // Node readline installs terminal signal handling while the interface is
+    // open. During a synchronous Prolog search that prevents the terminal's
+    // normal SIGINT/SIGTSTP actions from taking effect until JavaScript yields.
+    // Close readline while the solver is running so Ctrl-C can terminate and
+    // Ctrl-Z can suspend an otherwise non-terminating computation immediately.
+    this.history = [...this.readline.history];
+    this.readline.close();
+    this.readline = null;
+    this.lines = null;
+    return true;
+  }
+
+  resumeAfterComputation(suspended) {
+    if (suspended && !this.readline) this.open();
+  }
+
   close() {
     if (this.input.isRaw) this.input.setRawMode(false);
     this.readline?.close();
   }
 }
 
+function runWithTerminalSignals(reader, operation) {
+  const suspended = reader.suspendForComputation();
+  try {
+    return operation();
+  } finally {
+    reader.resumeAfterComputation(suspended);
+  }
+}
+
 function makeState(engine, sources, output, options = {}, previousState = null) {
   const strictIso = options.isoStrict === true;
   const program = engine.Program.parseSources(sources, { strictIso, sourceMetadata: strictIso });
@@ -369,7 +396,7 @@ async function solveQuery(engine, state, goal, reader, output) {
   const solver = state.solver;
   solver.solutionsSeen = 0;
   const solutions = solver.solve([goal], new engine.Env(), 0);
-  let current = pullSolution(solver, solutions);
+  let current = pullSolution(solver, solutions, reader);
   if (current.error) {
     if (current.error?.name === 'HaltSignal') return { halted: true, code: current.error.code };
     throw current.error;
@@ -383,7 +410,7 @@ async function solveQuery(engine, state, goal, reader, output) {
   let automatic = 0;
   let firstAnswer = true;
   while (!current.result.done) {
-    const next = pullSolution(solver, solutions);
+    const next = pullSolution(solver, solutions, reader);
     output.write(current.output);
     output.write(`${firstAnswer ? '   ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
     firstAnswer = false;
@@ -436,16 +463,18 @@ async function solveQuery(engine, state, goal, reader, output) {
   return null;
 }
 
-function pullSolution(solver, solutions) {
+function pullSolution(solver, solutions, reader) {
   const stream = solver.io.resolve('user_output');
   const originalWrite = stream?.write;
   let captured = '';
   if (stream) stream.write = (text) => { captured += String(text); };
+  const suspended = reader.suspendForComputation();
   try {
     return { result: solutions.next(), output: captured };
   } catch (error) {
     return { error, output: captured };
   } finally {
+    reader.resumeAfterComputation(suspended);
     if (stream) stream.write = originalWrite;
   }
 }

package/test/run-regression.mjs

@@ -719,6 +719,27 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL releases terminal signals while a query computes',
+      run: () => {
+        if (process.platform === 'win32') return;
+        const available = spawnSync('sh', ['-c',
+          'command -v script >/dev/null 2>&1 && script --version 2>/dev/null | grep -qi util-linux']);
+        if (available.status !== 0) return;
+        const command = `${shellQuote(process.execPath)} ${shellQuote(bin)}`;
+        const scriptCommand =
+          `{ printf 'repeat, fail.\n'; sleep 0.2; printf '\\003'; } | ` +
+          `script -qefc ${shellQuote(command)} /dev/null`;
+        const result = spawnSync('sh', ['-c', scriptCommand], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          timeout: 3000,
+        });
+        assertEqual(result.error?.code, undefined, 'terminal interrupt timeout');
+        assertEqual(result.status, 130, 'SIGINT exit status');
+        assertIncludes(result.stdout, '?- repeat, fail.', 'terminal query echo');
+      },
+    },
     {
       name: 'REPL accepts multiline period-terminated queries',
       run: () => {
@@ -3109,6 +3130,10 @@ function between(text, startMarker, endMarker) {
   return text.slice(contentStart, end);
 }
 
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\"'\"'")}'`;
+}
+
 function runCli(args, options = {}) {
   return spawnSync(process.execPath, [bin, ...args], {
     cwd: packageRoot,

package/the-art-of-eyeprolog.md

@@ -6216,7 +6216,11 @@ may span lines and end with a full stop, as in Scryer Prolog:
 When another answer exists in an interactive terminal, press `;`, Space, or
 `n` to ask for it immediately; no Return is needed. Return or `.` stops
 enumeration, `a` enumerates all remaining answers, `f` enumerates the next
-five, and `h` displays the answer-control help. A
+five, and `h` displays the answer-control help. While a query is actively
+computing, EyeProlog releases readline's terminal signal handling: `Ctrl-C`
+therefore terminates the current EyeProlog process immediately, and on POSIX
+terminals `Ctrl-Z` suspends it in the usual shell-managed way. This remains a
+host top-level convention rather than an ISO/IEC 13211-1 language feature. A
 period-terminated query with no solutions prints `false.`; a solution without
 visible variable bindings prints `true.`. Answer substitutions are rendered as
 valid Prolog syntax under the current operator table: when a bound value would