eyeprolog 1.2.6 → 1.2.7

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.6",
+  "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,7 +21,7 @@ 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 {
@@ -34,7 +35,7 @@ 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 = makeState(engine, sources, output, options, state, reader);
           runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write('   true.\n');
           continue;
@@ -42,7 +43,7 @@ export async function runRepl(engine, options = {}) {
         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 = 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,6 +145,57 @@ 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
@@ -175,7 +229,7 @@ function runWithTerminalSignals(reader, operation) {
   }
 }
 
-function makeState(engine, sources, output, options = {}, previousState = null) {
+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, {
@@ -183,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);
@@ -218,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;
 

package/test/run-regression.mjs

@@ -719,6 +719,53 @@ 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: () => {

package/the-art-of-eyeprolog.md

@@ -6228,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