eyeprolog 1.2.19 → 1.2.20

package/package.json

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

package/src/repl.js

@@ -488,8 +488,15 @@ async function solveQuery(engine, state, goal, reader, output) {
   let automatic = 0;
   let answersShown = 0;
   let firstAnswer = true;
+  let formattingAfterAdvance = false;
   while (!current.result.done) {
     const next = pullSolution(solver, solutions, reader);
+    // The control prompt has no trailing space while it waits for input. The
+    // first space appears as soon as the user requests another solution and
+    // remains visible while pullSolution() computes; the second appears only
+    // when the requested leaf answer is ready to format.
+    if (formattingAfterAdvance) output.write(' ');
+    formattingAfterAdvance = false;
     output.write(current.output);
     output.write(`${firstAnswer ? '   ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
     answersShown++;
@@ -501,14 +508,15 @@ async function solveQuery(engine, state, goal, reader, output) {
 
     if (automatic > 0 || automatic === Infinity) {
       if (automatic !== Infinity) automatic--;
-      output.write('\n;  ');
+      output.write('\n; ');
+      formattingAfterAdvance = true;
     } else {
       while (true) {
-        const controlLine = await reader.readControl('\n;  ');
+        const controlLine = await reader.readControl('\n;');
         if (controlLine == null || controlLine === '' || controlLine === '\r' || controlLine === '\n' ||
             controlLine.trimStart().startsWith('.')) {
           if (typeof solutions.return === 'function') solutions.return();
-          output.write('... .\n');
+          output.write('  ... .\n');
           return null;
         }
         const control = controlLine === ' ' ? ' ' : controlLine.trimStart()[0];
@@ -527,18 +535,22 @@ async function solveQuery(engine, state, goal, reader, output) {
           break;
         }
         if (control === 'w' || control === 'p') {
-          output.write(`${formatAnswer(engine, state, variables, current.result.value)}`);
+          output.write(`  ${formatAnswer(engine, state, variables, current.result.value)}`);
           continue;
         }
         if (control === 'h') {
           output.write(ANSWER_HELP);
           continue;
         }
-        output.write('Action? ');
+        output.write(' Action? ');
       }
+      output.write(' ');
+      formattingAfterAdvance = true;
     }
 
     if (next.error) {
+      if (formattingAfterAdvance) output.write(' ');
+      formattingAfterAdvance = false;
       output.write(next.output);
       if (next.error?.name === 'HaltSignal') return { halted: true, code: next.error.code };
       throw next.error;

package/test/run-regression.mjs

@@ -790,6 +790,61 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL answer prompt distinguishes waiting from computation',
+      run: () => {
+        const helper = `
+          import { spawn } from 'node:child_process';
+
+          const child = spawn(${JSON.stringify(process.execPath)}, [${JSON.stringify(bin)}], {
+            cwd: ${JSON.stringify(packageRoot)},
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          child.stdout.setEncoding('utf8');
+          child.stderr.setEncoding('utf8');
+          let stdout = '';
+          let stderr = '';
+          let sawComputingPrompt = false;
+          child.stdout.on('data', (text) => {
+            stdout += text;
+            if (stdout.endsWith('\\n; ')) sawComputingPrompt = true;
+          });
+          child.stderr.on('data', (text) => { stderr += text; });
+
+          async function waitFor(predicate, label) {
+            const deadline = Date.now() + 5000;
+            while (!predicate()) {
+              if (Date.now() >= deadline) {
+                throw new Error(label + ' timeout; stdout=' + JSON.stringify(stdout) + '; stderr=' + JSON.stringify(stderr));
+              }
+              await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+          }
+
+          child.stdin.write('use_module(library(prologue)).\\n');
+          await waitFor(() => stdout.includes('   true.\\n?- '), 'module import');
+          child.stdin.write('(N = 0; N = 1; (call_nth(repeat, 100000), N = 2)).\\n');
+          await waitFor(() => stdout.endsWith('   N = 0\\n;'), 'waiting prompt');
+          child.stdin.write(';\\n');
+          await waitFor(() => sawComputingPrompt, 'computing prompt');
+          await waitFor(() => stdout.endsWith(';  N = 1\\n;'), 'formatted answer');
+          child.stdin.write('\\n');
+          await waitFor(() => stdout.endsWith('  ... .\\n?- '), 'stopped enumeration');
+          child.stdin.write('halt.\\n');
+          const status = await new Promise((resolve) => child.once('exit', resolve));
+          if (status !== 0) throw new Error('child status ' + status + '; stderr=' + stderr);
+          process.stdout.write('waiting;computing;formatting');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--input-type=module',
+          '--eval',
+          helper,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `prompt helper status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'waiting;computing;formatting', 'prompt state sequence');
+      },
+    },
     {
       name: 'REPL f stops at five-answer boundaries instead of adding five answers',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -6284,7 +6284,9 @@ When another answer exists in an interactive terminal, press `;`, Space, or
 enumeration, `a` enumerates all remaining answers, and `f` advances to the
 next five-answer boundary (5, 10, 15, ... displayed leaf answers), regardless
 of how many answers were stepped through individually beforehand. `h` displays
-the answer-control help. While a query is actively
+the answer-control help. The answer prompt is `;` with no trailing space while
+it waits for input; after an advance command, one space marks active search and
+a second marks an answer ready for formatting. 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