eyeleng 1.1.1 → 1.2.0

package/src/api.js

@@ -5,7 +5,7 @@ const { parseRdfSyntax, parseRdfDocument, rdfDocumentToProgram, looksLikeRdfRule
 const { parseRdfMessageLog, looksLikeRdfMessageLog } = require('./rdfMessages.js');
 const { evaluate } = require('./engine.js');
 const { analyze } = require('./analyze.js');
-const { formatTriples, sortTriples, toJSON, formatTrace, formatBindings } = require('./format.js');
+const { formatTriples, sortTriples, toJSON, formatTrace, formatProof, formatBindings } = require('./format.js');
 const { runQuery, queryResult, queryProgram, queryRunOptions, shouldUseHybridForQuery } = require('./query.js');
 const { resultTriples } = require('./output.js');
 
@@ -128,5 +128,6 @@ module.exports = {
   sortTriples,
   toJSON,
   formatTrace,
+  formatProof,
   resultTriples,
 };

package/src/cli.js

@@ -11,7 +11,7 @@ const {
   queryProgram,
   queryRunOptions,
   formatTriples,
-  formatTrace,
+  formatProof,
   formatBindings,
   toJSON,
   resultTriples,
@@ -35,15 +35,28 @@ function readPackageVersion() {
 
 const VERSION = readPackageVersion();
 
-function help() {
+function legacyHelp() {
   return `eyeleng ${VERSION}\n\nA dependency-free JavaScript implementation experiment for the SHACL 1.2 Rules draft, including SRL and RDF Rules syntax front-ends.\n\nUsage:\n  eyeleng [options] [file ...]\n\nOptions:\n  --all                 Print the full closure, including input facts\n  --json                Print JSON instead of compact triples/bindings\n  --trace               Print derivation trace to stderr, or include it in JSON\n  --stats               Print iteration and triple counts to stderr\n  --check               Parse and analyze only; do not run rules\n  --strict              Treat static warnings as errors, including recursive term generation\n  --deps                Print rule dependency edges during --check\n  --query TEXT          Run a raw SRL body pattern over the closure or backward planner\n  --query-file FILE     Read a raw SRL body pattern from a file\n  --query-mode MODE     Use auto, forward, or backward query planning (default auto)\n  --hybrid              Force aggressive hybrid orientation for function-like rules\n  --no-hybrid           Disable automatic hybrid forward/backward execution\n  --max-iterations N    Stop after N fixpoint iterations within a recursive layer\n  --no-imports          Parse IMPORTS/owl:imports but do not load imported rule sets\n  --rdf-messages        Parse input as an RDF Message Log\n  --include-message-facts Include payload facts while parsing RDF Message Logs\n  --syntax MODE         Use srl, rdf, or auto syntax detection (default auto)\n  --ruleset TERM        In RDF syntax, run only the selected srl:RuleSet\n  --version             Print version\n  -h, --help            Print this help\n\nWith no file arguments, eyeleng reads from stdin.\n`;
 }
 
+function help() {
+  return legacyHelp().replace(
+    '  --trace               Print derivation trace to stderr, or include it in JSON',
+    '  --prove               Print proof explanations',
+  ).replace(
+    'Usage:\n  eyeleng [options] [file ...]',
+    'Usage: eyeleng [options] [file-or-url.n3|- ...]',
+  ).replace(
+    'With no file arguments, eyeleng reads from stdin.',
+    'With no input arguments, eyeleng prints this help. Use - to read from stdin.',
+  );
+}
+
 function parseArgs(argv) {
   const options = {
     all: false,
     json: false,
-    trace: false,
+    prove: false,
     stats: false,
     check: false,
     strict: false,
@@ -64,7 +77,7 @@ function parseArgs(argv) {
     const arg = argv[i];
     if (arg === '--all') options.all = true;
     else if (arg === '--json') options.json = true;
-    else if (arg === '--trace') options.trace = true;
+    else if (arg === '--prove') options.prove = true;
     else if (arg === '--stats') options.stats = true;
     else if (arg === '--check') options.check = true;
     else if (arg === '--strict') options.strict = true;
@@ -105,6 +118,8 @@ function parseArgs(argv) {
       options.version = true;
     } else if (arg === '-h' || arg === '--help') {
       options.help = true;
+    } else if (arg === '-') {
+      files.push(arg);
     } else if (arg.startsWith('-')) {
       throw new Error(`Unknown option ${arg}`);
     } else {
@@ -115,13 +130,26 @@ function parseArgs(argv) {
   return { options, files };
 }
 
-function readInput(files) {
-  if (files.length === 0) return { source: fs.readFileSync(0, 'utf8'), filename: '<stdin>', baseIRI: null };
-  if (files.length === 1) {
-    const filename = path.resolve(files[0]);
-    return { source: fs.readFileSync(filename, 'utf8'), filename, baseIRI: pathToFileURL(filename).href };
+async function readInput(files, fetchImpl = globalThis.fetch) {
+  const inputs = [];
+  let readStdin = false;
+  for (const spec of files) {
+    if (spec === '-') {
+      if (readStdin) throw new Error('Standard input (-) may only be specified once');
+      readStdin = true;
+      inputs.push({ source: fs.readFileSync(0, 'utf8'), filename: '<stdin>', baseIRI: null });
+    } else if (/^https?:\/\//i.test(spec)) {
+      if (typeof fetchImpl !== 'function') throw new Error(`Cannot fetch URL ${spec}: fetch is unavailable`);
+      const response = await fetchImpl(spec);
+      if (!response.ok) throw new Error(`Cannot fetch URL ${spec}: HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ''}`);
+      inputs.push({ source: await response.text(), filename: spec, baseIRI: spec });
+    } else {
+      const filename = path.resolve(spec);
+      inputs.push({ source: fs.readFileSync(filename, 'utf8'), filename, baseIRI: pathToFileURL(filename).href });
+    }
   }
-  return { source: files.map((file) => fs.readFileSync(file, 'utf8')).join('\n'), filename: '<input>', baseIRI: null };
+  if (inputs.length === 1) return inputs[0];
+  return { source: inputs.map((input) => input.source).join('\n'), filename: '<input>', baseIRI: null };
 }
 
 function createFileImportResolver() {
@@ -166,7 +194,7 @@ function formatRuleName(name, prefixes = {}) {
   return /^https?:/.test(name) ? compactIRI(name, prefixes) : name;
 }
 
-function main(argv = process.argv.slice(2), io = process) {
+async function main(argv = process.argv.slice(2), io = process) {
   try {
     const { options, files } = parseArgs(argv);
     if (options.help) {
@@ -177,7 +205,11 @@ function main(argv = process.argv.slice(2), io = process) {
       io.stdout.write(`${VERSION}\n`);
       return 0;
     }
-    const input = readInput(files);
+    if (files.length === 0) {
+      io.stdout.write(help());
+      return 0;
+    }
+    const input = await readInput(files);
     const compiled = compile(input.source, {
       filename: input.filename,
       baseIRI: input.baseIRI,
@@ -239,15 +271,18 @@ function main(argv = process.argv.slice(2), io = process) {
     }
 
     if (options.json) {
-      io.stdout.write(`${JSON.stringify(toJSON(result, { all: options.all, trace: options.trace, analysis: options.deps }), null, 2)}\n`);
+      io.stdout.write(`${JSON.stringify(toJSON(result, { all: options.all, proof: options.prove, analysis: options.deps }), null, 2)}\n`);
     } else if (result.query) {
       const out = formatBindings(result.query.bindings, result.prefixes, result.query.select);
       if (out) io.stdout.write(`${out}\n`);
     } else {
-      if (options.trace && result.trace.length > 0) io.stderr.write(`${formatTrace(result.trace, result.prefixes)}\n`);
       const triples = resultTriples(result, compiled.program, options);
       const out = formatTriples(triples, result.prefixes);
       if (out) io.stdout.write(`${out}\n`);
+      if (options.prove) {
+        const proof = formatProof(result.trace, result.prefixes);
+        if (proof) io.stdout.write(`${out ? '\n' : ''}${proof}\n`);
+      }
     }
 
     if (options.stats) {
@@ -265,6 +300,6 @@ function main(argv = process.argv.slice(2), io = process) {
   }
 }
 
-if (require.main === module) process.exitCode = main();
+if (require.main === module) main().then((code) => { process.exitCode = code; });
 
-module.exports = { main, parseArgs, help, VERSION, createFileImportResolver };
+module.exports = { main, parseArgs, readInput, help, VERSION, createFileImportResolver };

package/src/engine.js

@@ -202,6 +202,7 @@ function applyRuleOnce(program, store, ruleIndex, context) {
             rule: rule.name || `rule#${ruleIndex + 1}`,
             triple,
             binding,
+            uses: proofUses(rule.body, binding),
           });
         }
       }
@@ -212,6 +213,17 @@ function applyRuleOnce(program, store, ruleIndex, context) {
   return { applications, added };
 }
 
+function proofUses(body, binding) {
+  return body
+    .filter((clause) => clause.type === 'triple')
+    .map((clause) => ({
+      s: instantiateTerm(clause.triple.s, binding),
+      p: instantiateTerm(clause.triple.p, binding),
+      o: instantiateTerm(clause.triple.o, binding),
+    }))
+    .filter((triple) => ![triple.s, triple.p, triple.o].some((term) => term && term.type === 'var'));
+}
+
 function prepareBodyContext(program, store, context) {
   if (!context.hybridBackwardPredicates || context.hybridBackwardPredicates.size === 0) return context;
   return {

package/src/format.js

@@ -20,6 +20,35 @@ function formatTrace(trace, prefixes = {}) {
   return trace.map((entry) => `#${entry.iteration} ${entry.rule} => ${formatTriple(entry.triple, prefixes)}`).join('\n');
 }
 
+function formatProof(trace, prefixes = {}) {
+  if (!trace.length) return '';
+  const lines = ['@prefix pe: <https://eyereasoner.github.io/pe#> .', ''];
+  for (const entry of trace) {
+    const conclusion = formatTriple(entry.triple, prefixes);
+    lines.push(`{ ${conclusion} } pe:why {`);
+    lines.push(`  { ${conclusion} }`);
+    lines.push(`    pe:by [ pe:rule ${quoteString(entry.rule)} ]${proofDetails(entry, prefixes)} .`);
+    lines.push('}.', '');
+  }
+  return lines.join('\n').trimEnd();
+}
+
+function proofDetails(entry, prefixes) {
+  const details = [];
+  const bindings = Object.entries(entry.binding || {}).sort(([a], [b]) => a.localeCompare(b));
+  if (bindings.length > 0) {
+    details.push(`\n    pe:binding ${bindings.map(([name, value]) => `[ pe:var ${quoteString(name)}; pe:value ${formatTerm(value, prefixes)} ]`).join(', ')}`);
+  }
+  if (entry.uses && entry.uses.length > 0) {
+    details.push(`\n    pe:uses ${entry.uses.map((triple) => `{ ${formatTriple(triple, prefixes)} }`).join(', ')}`);
+  }
+  return details.length ? `;${details.join(';')}` : '';
+}
+
+function quoteString(value) {
+  return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
+}
+
 function formatBindings(bindings, prefixes = {}, select = null) {
   const columns = select && select.length > 0 ? select : inferColumns(bindings);
   return bindings
@@ -51,7 +80,7 @@ function toJSON(result, options = {}) {
     prefixes: result.prefixes,
     diagnostics: result.diagnostics || [],
     triples: sortTriples(triples, result.prefixes).map(jsonSafeTriple),
-    trace: options.trace ? result.trace : undefined,
+    proof: options.proof ? result.trace : undefined,
   };
   if (result.query) json.query = jsonSafeValue(result.query);
   if (result.analysis && options.analysis) json.analysis = result.analysis;
@@ -80,4 +109,4 @@ function jsonSafeValue(value) {
   return value;
 }
 
-module.exports = { sortTriples, formatTriples, formatTrace, formatBindings, formatBinding, toJSON };
+module.exports = { sortTriples, formatTriples, formatTrace, formatProof, formatBindings, formatBinding, toJSON };

package/src/parser.js

@@ -296,7 +296,7 @@ class Parser {
   }
 
   parseTripleStatement(options = {}) {
-    const subjectNode = this.parseGraphNode(options);
+    const subjectNode = this.parseGraphNode({ ...options, position: 'subject' });
     const triples = [...subjectNode.triples];
     triples.push(...this.parsePropertyListForSubject(subjectNode.term, options));
     return triples;
@@ -310,7 +310,7 @@ class Parser {
       if (terminators.some((value) => this.checkValue(value)) || this.checkValue('.')) break;
       const predicate = options.allowPath ? this.parseVerbPathOrSimple(options) : this.parseVerbTerm(options);
       do {
-        const objectNode = this.parseGraphNode(options);
+        const objectNode = this.parseGraphNode({ ...options, position: 'object' });
         triples.push(...objectNode.triples);
         const baseTriple = { s: subject, p: predicate, o: objectNode.term };
         triples.push(baseTriple);
@@ -377,6 +377,7 @@ class Parser {
         currentReifier = this.parseOptionalReifier(options);
         triples.push({ s: currentReifier, p: iri(RDF_REIFIES), o: reified });
       } else if (this.matchValue('{|')) {
+        if (this.checkValue('|}')) throw this.error('Annotation blocks may not be empty');
         const annotationSubject = currentReifier || this.freshGraphNode(options);
         triples.push({ s: annotationSubject, p: iri(RDF_REIFIES), o: reified });
         triples.push(...this.parsePropertyListForSubject(annotationSubject, options, ['|}']));
@@ -426,7 +427,7 @@ class Parser {
   }
 
   parseVerbTerm(options = {}) {
-    const term = this.parseTerm(options);
+    const term = this.parseTerm({ ...options, position: 'predicate' });
     if (term.type !== 'iri' && term.type !== 'var') throw this.error('Expected IRI or variable as predicate');
     return term;
   }
@@ -549,7 +550,10 @@ class Parser {
     if (token.value === '<<(') return this.parseTripleTermAfterOpen(options);
     if (token.value === '<<') throw this.error('Use << s p o >> as a graph node reifier; use <<( s p o )>> for a triple term', token);
     if (token.type === 'word') {
-      if (token.value === 'a') return iri(RDF_TYPE);
+      if (token.value === 'a') {
+        if (options.position !== 'predicate') throw this.error('a is only allowed as a predicate', token);
+        return iri(RDF_TYPE);
+      }
       if (token.value === 'true') return literal(true, XSD_BOOLEAN);
       if (token.value === 'false') return literal(false, XSD_BOOLEAN);
       if (token.value.startsWith('_:')) return blankNode(token.value.slice(2));
@@ -583,7 +587,13 @@ class Parser {
       return literal(coerceLexicalLiteral(token.value, datatype), datatype, null);
     }
     if (this.checkType('word') && /^@[A-Za-z]+(?:-[A-Za-z0-9]+)*(?:--[A-Za-z]+)?$/.test(this.peek().value)) {
-      const tag = this.advance().value.slice(1).toLowerCase();
+      const tagToken = this.advance();
+      const rawTag = tagToken.value.slice(1);
+      const direction = rawTag.includes('--') ? rawTag.slice(rawTag.lastIndexOf('--') + 2) : null;
+      if (direction && direction !== 'ltr' && direction !== 'rtl') {
+        throw this.error(`Invalid base direction --${direction}; expected --ltr or --rtl`, tagToken);
+      }
+      const tag = rawTag.toLowerCase();
       const [lang, langDir = null] = tag.split('--');
       return literal(token.value, null, lang, langDir);
     }

package/src/rdfSyntax.js

@@ -1160,6 +1160,7 @@ function parseN3(source, options = {}) {
   const syntaxProfile = String(options.profile || options.profileId || '').toLowerCase();
   const rdf12Surface = syntaxProfile === 'turtle' || syntaxProfile === 'trig';
   const implicitStatementNodes = new Set();
+  function implicitStatementNodeKey(term) { return `${term.kind}:${term.value}`; }
 
   function freshBlank() { bnodeCounter += 1; return blank(`b${bnodeCounter}`); }
   function peek(offset = 0) { return tokens[i + offset]; }
@@ -1310,7 +1311,7 @@ function parseN3(source, options = {}) {
     expect('>>');
     const node = reifier || freshBlank();
     out.push(triple(node, iri(RDF_REIFIES), tripleTerm(s, p, o), graph));
-    if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+    implicitStatementNodes.add(implicitStatementNodeKey(node));
     return node;
   }
 
@@ -1339,7 +1340,7 @@ function parseN3(source, options = {}) {
     if (accept(']')) return node;
     parsePredicateObjectList(node, out, graph);
     expect(']');
-    if (node.kind === 'blank') implicitStatementNodes.add(node.value);
+    if (node.kind === 'blank') implicitStatementNodes.add(implicitStatementNodeKey(node));
     return node;
   }
 
@@ -1417,9 +1418,8 @@ function parseN3(source, options = {}) {
       if (options3.requireDot) expect('.'); else accept('.');
       return;
     }
-    if (peek()?.type === '<<' && peek(1)?.type === '(') throw new Error('Triple term cannot be used as a subject');
-    const subject = parseTerm(out, graph, { noLiteral: true, noA: true });
-    if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && subject.kind === 'blank' && implicitStatementNodes.has(subject.value)) {
+    const subject = parseTerm(out, graph, { noLiteral: !rdf12Surface, noA: true });
+    if ((peek()?.type === '.' || peek()?.type === '}' || peek()?.type === undefined) && implicitStatementNodes.has(implicitStatementNodeKey(subject))) {
       if (options3.requireDot) expect('.'); else accept('.');
       return;
     }

package/test/api.test.js

@@ -746,6 +746,41 @@ RULE { :test :annotation ?source } WHERE {
   assert.match(output, /:test :annotation :witness \./);
 });
 
+test('DATA blocks accept RDF 1.2 symmetric and standalone reifier syntax', () => {
+  const symmetric = parse(`
+PREFIX : <http://example/>
+DATA {
+  123 :q 456 .
+  <<( :s :p :o )>> :q <<( :s1 :p1 :o1 )>> .
+}
+`);
+  assert.equal(symmetric.data.length, 2);
+  assert.equal(symmetric.data[0].s.type, 'literal');
+  assert.equal(symmetric.data[1].s.type, 'triple');
+
+  const standalone = parse(`
+PREFIX : <http://example/>
+DATA { << :a :b :c ~:r >> . }
+`);
+  assert.equal(standalone.data.length, 1);
+  assert.equal(standalone.data[0].s.value, 'http://example/r');
+  assert.equal(standalone.data[0].p.value, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies');
+});
+
+test('SRL rejects invalid base directions, subject a, and empty annotations', () => {
+  const invalidPatterns = [
+    'RULE { } WHERE { :s :p "abc"@en--LTR }',
+    'RULE { :s :p "abc"@en--LTR } WHERE { ?a ?b ?c }',
+    'RULE { } WHERE { a :p "abc" }',
+    'RULE { a :p "abc" } WHERE { ?a ?b ?c }',
+    'RULE { } WHERE { :s :p :o ~:r {| |} }',
+    'RULE { :s :p :o ~:r {| |} } WHERE { ?a ?b ?c }',
+  ];
+  for (const pattern of invalidPatterns) {
+    assert.throws(() => parse(`PREFIX : <http://example/>\n${pattern}`), Error, pattern);
+  }
+});
+
 
 test('strict conformance allows recursive constant BIND aliases', () => {
   assert.doesNotThrow(() => compile(`

package/test/cli.test.js

@@ -4,7 +4,7 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const path = require('node:path');
 const { test, main } = require('./harness.js').createHarness('CLI');
-const { help, parseArgs } = require('../src/cli.js');
+const { help, parseArgs, readInput, main: cliMain } = require('../src/cli.js');
 
 function longOptions(text) {
   return Array.from(text.matchAll(/(^|\s)(--[a-z][a-z0-9-]*)\b/gm), (match) => match[2])
@@ -37,6 +37,11 @@ test('RDF Message Log flags are accepted by parseArgs', () => {
   assert.equal(parseArgs(['--include-message-facts']).options.includeMessageFacts, true);
 });
 
+test('--prove enables proof explanations and --trace is rejected', () => {
+  assert.equal(parseArgs(['--prove']).options.prove, true);
+  assert.throws(() => parseArgs(['--trace']), /Unknown option --trace/);
+});
+
 test('query mode flag is accepted by parseArgs', () => {
   assert.equal(parseArgs(['--query-mode', 'auto']).options.queryMode, 'auto');
   assert.equal(parseArgs(['--query-mode', 'forward']).options.queryMode, 'forward');
@@ -49,4 +54,31 @@ test('query mode flag is accepted by parseArgs', () => {
   assert.throws(() => parseArgs(['--stream-messages']), /Unknown option --stream-messages/);
 });
 
+test('stdin marker and URLs are accepted as inputs', async () => {
+  assert.deepEqual(parseArgs(['-']).files, ['-']);
+  assert.deepEqual(parseArgs(['https://example.test/rules.n3']).files, ['https://example.test/rules.n3']);
+  const input = await readInput(['https://example.test/rules.n3'], async () => ({
+    ok: true,
+    text: async () => 'DATA { <a> <b> <c> }',
+  }));
+  assert.equal(input.filename, 'https://example.test/rules.n3');
+  assert.equal(input.baseIRI, 'https://example.test/rules.n3');
+});
+
+test('no arguments print the same help as -h', async () => {
+  function capture() {
+    let stdout = '';
+    let stderr = '';
+    return {
+      io: { stdout: { write: (text) => { stdout += text; } }, stderr: { write: (text) => { stderr += text; } } },
+      output: () => ({ stdout, stderr }),
+    };
+  }
+  const empty = capture();
+  const explicit = capture();
+  assert.equal(await cliMain([], empty.io), 0);
+  assert.equal(await cliMain(['-h'], explicit.io), 0);
+  assert.deepEqual(empty.output(), explicit.output());
+});
+
 main();

package/tools/browser-bundle.js

@@ -129,6 +129,7 @@ function buildModuleWrapper() {
     'sortTriples',
     'toJSON',
     'formatTrace',
+    'formatProof',
   ];
 
   const chunks = [];

package/tools/bundle.js

@@ -106,7 +106,9 @@ function buildCli() {
   chunks.push('    __modules[id](localRequire, module, module.exports);');
   chunks.push('    return module.exports;');
   chunks.push('  }');
-  chunks.push(`  process.exitCode = __require(${js(cliEntry)}).main(process.argv.slice(2));`);
+  chunks.push(`  Promise.resolve(__require(${js(cliEntry)}).main(process.argv.slice(2)))`);
+  chunks.push('    .then((code) => { process.exitCode = code; })');
+  chunks.push("    .catch((error) => { console.error(error); process.exitCode = 1; });");
   chunks.push('}());');
   chunks.push('');