eyeprolog 1.2.5 → 1.2.7

package/package.json

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

package/src/iso.js

@@ -1135,28 +1135,49 @@ function convertedTermText(text, solver) {
   return result;
 }
 function readTermFromStream(stream, solver) {
-  let sawCandidate = false;
-  for (const candidate of termTextCandidates(stream)) {
-    sawCandidate = true;
-    try {
-      const operatorState = createParserOperatorState(solver.program.operators.values(), false);
-      const clauses = parseClauses(convertedTermText(candidate.text, solver), {
-        sourceMetadata: false,
-        operatorState,
-        doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
-      });
-      if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
-      stream.position = candidate.end;
-      return clauses[0].head;
-    } catch (_) {
-      // A dot inside a graphic operator, such as =.., is only a possible
-      // terminator. Keep scanning until a complete term parses.
+  let requestedInteractiveTerm = false;
+  while (true) {
+    let sawCandidate = false;
+    for (const candidate of termTextCandidates(stream)) {
+      sawCandidate = true;
+      try {
+        const operatorState = createParserOperatorState(solver.program.operators.values(), false);
+        const clauses = parseClauses(convertedTermText(candidate.text, solver), {
+          sourceMetadata: false,
+          operatorState,
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        });
+        if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
+        stream.position = candidate.end;
+        return clauses[0].head;
+      } catch (_) {
+        // A dot inside a graphic operator, such as =.., is only a possible
+        // terminator. Keep scanning until a complete term parses.
+      }
+    }
+
+    // The interactive top level may attach a synchronous reader to the
+    // standard user_input stream. Ask it for one complete read-term only when
+    // this read operation actually reaches the end of buffered input. This is
+    // deliberately a stream hook, not goal-shape recognition, so conjunctions
+    // and reads reached through user predicates behave the same as read/1.
+    if (!sawCandidate && !requestedInteractiveTerm &&
+        typeof stream.interactiveReadTerm === 'function') {
+      requestedInteractiveTerm = true;
+      const text = stream.interactiveReadTerm();
+      if (text != null) {
+        stream.content += String(text);
+        stream.pastEnd = false;
+        continue;
+      }
     }
+
+    stream.position = String(stream.content).length;
+    if (!sawCandidate) return atom('end_of_file');
+    throw new PrologError('syntax_error(read_term)');
   }
-  stream.position = String(stream.content).length;
-  if (!sawCandidate) return atom('end_of_file');
-  throw new PrologError('syntax_error(read_term)');
 }
+
 function* readBuiltin({ solver, goal, env }) {
   const stream = inputStreamFor(solver, goal, env);
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));

package/src/repl.js

@@ -1,5 +1,6 @@
 // Interactive top level for the eyeprolog command.
 import fs from 'node:fs/promises';
+import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { formalErrorTerm } from './iso.js';
@@ -20,11 +21,11 @@ export async function runRepl(engine, options = {}) {
   const errorOutput = options.errorOutput ?? process.stderr;
   const reader = new LineReader(input, output);
   const sources = [];
-  let state = makeState(engine, sources, output, options);
+  let state = makeState(engine, sources, output, options, null, reader);
   let exitCode = 0;
 
   try {
-    state.solver.runInitializations();
+    runWithTerminalSignals(reader, () => state.solver.runInitializations());
     while (true) {
       const text = await readQuery(reader);
       if (text == null) break;
@@ -34,16 +35,16 @@ export async function runRepl(engine, options = {}) {
         const goal = parseGoal(engine, state, text);
         if (!options.isoStrict && isUseModuleGoal(goal)) {
           sources.push({ text: `:- ${text}.\n`, filename: '<repl>' });
-          state = makeState(engine, sources, output, options, state);
-          state.solver.runInitializations();
+          state = makeState(engine, sources, output, options, state, reader);
+          runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write('   true.\n');
           continue;
         }
         const consultFiles = options.isoStrict ? null : consultDesignations(engine, goal);
         if (consultFiles != null) {
           for (const filename of consultFiles) sources.push(await readSource(filename));
-          state = makeState(engine, sources, output, options, state);
-          state.solver.runInitializations();
+          state = makeState(engine, sources, output, options, state, reader);
+          runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write('   true.\n');
           continue;
         }
@@ -78,6 +79,8 @@ export async function runRepl(engine, options = {}) {
 }
 
 class LineReader {
+  static syncWait = new Int32Array(new SharedArrayBuffer(4));
+
   constructor(input, output) {
     this.input = input;
     this.output = output;
@@ -142,13 +145,91 @@ class LineReader {
     return control;
   }
 
+  canReadTermSynchronously() {
+    return this.terminal && Number.isInteger(this.input.fd);
+  }
+
+  readInteractiveTermSync() {
+    if (!this.canReadTermSynchronously()) return null;
+    let source = '';
+    let prompt = '|: ';
+    while (true) {
+      this.output.write(prompt);
+      const line = this.readTerminalLineSync();
+      if (line == null) return source.trim() ? source : null;
+      source += `${line}\n`;
+      const end = terminalFullStop(source);
+      if (end >= 0) return source.slice(0, end + 1) + '\n';
+      prompt = '|    ';
+    }
+  }
+
+  readTerminalLineSync() {
+    const byte = Buffer.allocUnsafe(1);
+    const bytes = [];
+    while (true) {
+      let count;
+      try {
+        count = readSync(this.input.fd, byte, 0, 1, null);
+      } catch (error) {
+        // Node keeps terminal fds non-blocking.  Once readline is suspended,
+        // a synchronous read can therefore report EAGAIN while waiting for
+        // the user. Sleep briefly and retry; terminal signals still retain
+        // their native action because no readline signal handler is installed.
+        if (error?.code === 'EAGAIN' || error?.code === 'EWOULDBLOCK') {
+          Atomics.wait(LineReader.syncWait, 0, 0, 10);
+          continue;
+        }
+        throw error;
+      }
+      // In canonical terminal mode Ctrl-D on an empty line makes read(2)
+      // return zero bytes.  Scope that EOF to the current Prolog read rather
+      // than closing the outer readline iterator / top-level loop.
+      if (count === 0) {
+        return bytes.length === 0 ? null : Buffer.from(bytes).toString('utf8');
+      }
+      if (byte[0] === 10) {
+        if (bytes.at(-1) === 13) bytes.pop();
+        return Buffer.from(bytes).toString('utf8');
+      }
+      bytes.push(byte[0]);
+    }
+  }
+
+  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 makeState(engine, sources, output, options = {}, previousState = null) {
+function runWithTerminalSignals(reader, operation) {
+  const suspended = reader.suspendForComputation();
+  try {
+    return operation();
+  } finally {
+    reader.resumeAfterComputation(suspended);
+  }
+}
+
+function makeState(engine, sources, output, options = {}, previousState = null, reader = null) {
   const strictIso = options.isoStrict === true;
   const program = engine.Program.parseSources(sources, { strictIso, sourceMetadata: strictIso });
   const solver = new engine.Solver(program, {
@@ -156,6 +237,14 @@ function makeState(engine, sources, output, options = {}, previousState = null)
     isoStrict: strictIso,
     ioOptions: { write: (text) => output.write(String(text)) },
   });
+  const userInput = solver.io.resolve('user_input');
+  if (userInput && reader?.canReadTermSynchronously()) {
+    // The solver is synchronous.  While pullSolution() has readline suspended,
+    // let ISO term input request a complete terminal term exactly when read/1-2
+    // or read_term/2-3 actually executes.  This also works inside conjunctions
+    // and user predicates instead of only when read/* is the whole REPL goal.
+    userInput.interactiveReadTerm = () => reader.readInteractiveTermSync();
+  }
   const flagOverrides = new Map(previousState?.flagOverrides ?? []);
   for (const [name, value] of flagOverrides) {
     const definition = solver.prologFlags.get(name);
@@ -191,6 +280,10 @@ async function readQuery(reader) {
 }
 
 async function prepareInteractiveTermInput(state, goal, reader) {
+  // Real terminals are serviced on demand from readTermFromStream() while the
+  // synchronous solver is running.  Keep the older async preloader only as a
+  // fallback for piped/non-TTY REPL tests and scripted input.
+  if (reader.canReadTermSynchronously()) return;
   const stream = interactiveTermInputStream(state, goal);
   if (stream == null || terminalFullStop(String(stream.content).slice(stream.position)) >= 0) return;
 
@@ -369,7 +462,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 +476,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 +529,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,74 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL term input is on demand in conjunctions and Ctrl-D does not exit the top level',
+      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 'read(X), read(Y).\n'; sleep 0.15; ` +
+          `printf 'foo.\n'; sleep 0.15; printf 'bar.\n'; sleep 0.15; ` +
+          `printf 'read(Z).\n'; sleep 0.15; printf '\\004'; sleep 0.15; ` +
+          `printf 'true.\n'; sleep 0.15; printf 'halt.\n'; } | ` +
+          `script -qefc ${shellQuote(command)} /dev/null`;
+        const result = spawnSync('sh', ['-c', scriptCommand], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          timeout: 5000,
+        });
+        assertEqual(result.error?.code, undefined, 'interactive read timeout');
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stdout, 'X = foo, Y = bar.', 'conjunction reads');
+        assertIncludes(result.stdout, 'Z = end_of_file.', 'Ctrl-D read result');
+        assertIncludes(result.stdout, '?- true.', 'top level resumes after Ctrl-D');
+        assertIncludes(result.stdout, '   true.', 'post-EOF query executes');
+      },
+    },
+    {
+      name: 'interactive user_input hook serves reads reached through user predicates',
+      run: () => {
+        const program = Program.parse('pair(A, B) :- read(A), read(B).\n');
+        const solver = new Solver(program, { registry: getEyePrologRegistry() });
+        const stream = solver.io.resolve('user_input');
+        const pending = ['left.\n', 'right.\n'];
+        let requests = 0;
+        stream.interactiveReadTerm = () => {
+          requests++;
+          return pending.shift() ?? null;
+        };
+        const goal = parseGoalText('pair(X, Y)');
+        const answers = [...solver.solve([goal], new Env(), 0)];
+        assertEqual(answers.length, 1, 'answer count');
+        assertEqual(termToString(copyResolved(goal.args[0], answers[0])), 'left', 'first read');
+        assertEqual(termToString(copyResolved(goal.args[1], answers[0])), 'right', 'second read');
+        assertEqual(requests, 2, 'on-demand read count');
+      },
+    },
+    {
+      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 +3177,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
@@ -6224,21 +6228,27 @@ not be a valid right operand of the displayed `=/2`, EyeProlog adds parentheses,
 for example `T = (a = b).` rather than the invalid `T = a = b.`. Use `[file].`
 or `['file.pl'].` to
 consult local source, and `halt.` or `halt(Status).` to leave the top level.
-A direct top-level `read/1-2` or `read_term/2-3` from `user_input` requests the
-next full-stop-terminated Prolog term with a `|: ` input prompt instead of
-treating the interactive input stream as already exhausted. For example:
+When `read/1-2` or `read_term/2-3` actually reaches interactive
+`user_input`, the top level requests the next full-stop-terminated Prolog term
+with a `|: ` input prompt instead of treating the terminal stream as already
+exhausted. The request is made at execution time, so multiple reads in one goal
+and reads reached through user predicates work independently. For example:
 
 ```text
-?- read(X).
+?- read(X), read(Y).
 |: hello.
-   X = hello.
-```
-
-The top-level prompt itself is a host-interface convention rather than part of
-ISO/IEC 13211-1; the term that follows it is parsed by the same ISO term-input
-machinery as `read/1-2` and `read_term/2-3` on other text streams. Up and Down
-recall queries from the current session. Explicit `eyeprolog -h` displays
-command-line help.
+|: world.
+   X = hello, Y = world.
+```
+
+Typing `Ctrl-D` at an empty `|: ` prompt makes that Prolog read return
+`end_of_file`; it does not close the surrounding EyeProlog top-level loop, so a
+new `?- ` query can still be entered afterwards. The top-level prompts and this
+terminal EOF convention are host-interface behavior rather than part of
+ISO/IEC 13211-1; terms supplied to the reads are parsed by the same ISO
+term-input machinery as `read/1-2` and `read_term/2-3` on other text streams.
+Up and Down recall queries from the current session. Explicit `eyeprolog -h`
+displays command-line help.
 
 ### Selecting goals