eyeling 1.22.16 → 1.23.1

package/lib/multisource.js

@@ -0,0 +1,198 @@
+/**
+ * Eyeling Reasoner — multi-source parsing helpers
+ *
+ * These helpers let the CLI/API parse several N3 documents independently and
+ * merge their parsed ASTs before reasoning. This avoids building one giant N3
+ * string while preserving the existing lexer/parser/engine pipeline.
+ */
+
+'use strict';
+
+const { lex } = require('./lexer');
+const { Parser } = require('./parser');
+const {
+  Blank,
+  ListTerm,
+  OpenListTerm,
+  GraphTerm,
+  Triple,
+  Rule,
+  PrefixEnv,
+  annotateQuotedGraphTerm,
+} = require('./prelude');
+
+function emptyParsedDocument() {
+  return {
+    prefixes: PrefixEnv.newDefault(),
+    triples: [],
+    frules: [],
+    brules: [],
+    logQueryRules: [],
+  };
+}
+
+function parseN3Text(text, opts = {}) {
+  const { baseIri = '', label = '<input>' } = opts || {};
+  const tokens = lex(text);
+  const parser = new Parser(tokens);
+  if (baseIri) parser.prefixes.setBase(baseIri);
+  const [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
+  return { prefixes, triples, frules, brules, logQueryRules, tokens, text, label };
+}
+
+function sourceBlankPrefix(sourceIndex) {
+  return `_:src${sourceIndex}_`;
+}
+
+function scopedBlankLabel(label, sourceIndex, mapping) {
+  const key = String(label || '');
+  let out = mapping.get(key);
+  if (out) return out;
+
+  const bare = key.startsWith('_:') ? key.slice(2) : key;
+  out = sourceBlankPrefix(sourceIndex) + bare;
+  mapping.set(key, out);
+  return out;
+}
+
+function scopeBlankNodesInDocument(doc, sourceIndex) {
+  const mapping = new Map();
+
+  function cloneTerm(term) {
+    if (term instanceof Blank) return new Blank(scopedBlankLabel(term.label, sourceIndex, mapping));
+    if (term instanceof ListTerm) return new ListTerm(term.elems.map(cloneTerm));
+    if (term instanceof OpenListTerm) return new OpenListTerm(term.prefix.map(cloneTerm), term.tailVar);
+    if (term instanceof GraphTerm) return annotateQuotedGraphTerm(new GraphTerm(term.triples.map(cloneTriple)));
+    return term;
+  }
+
+  function cloneTriple(triple) {
+    return new Triple(cloneTerm(triple.s), cloneTerm(triple.p), cloneTerm(triple.o));
+  }
+
+  function cloneRule(rule) {
+    const headBlankLabels = new Set();
+    if (rule && rule.headBlankLabels instanceof Set) {
+      for (const label of rule.headBlankLabels) headBlankLabels.add(scopedBlankLabel(label, sourceIndex, mapping));
+    }
+
+    const out = new Rule(
+      (rule.premise || []).map(cloneTriple),
+      (rule.conclusion || []).map(cloneTriple),
+      rule.isForward,
+      rule.isFuse,
+      headBlankLabels,
+    );
+
+    if (rule && Object.prototype.hasOwnProperty.call(rule, '__dynamicConclusionTerm')) {
+      Object.defineProperty(out, '__dynamicConclusionTerm', {
+        value: cloneTerm(rule.__dynamicConclusionTerm),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+      });
+    }
+
+    return out;
+  }
+
+  return {
+    prefixes: doc.prefixes,
+    triples: (doc.triples || []).map(cloneTriple),
+    frules: (doc.frules || []).map(cloneRule),
+    brules: (doc.brules || []).map(cloneRule),
+    logQueryRules: (doc.logQueryRules || []).map(cloneRule),
+    tokens: doc.tokens,
+    text: doc.text,
+    label: doc.label,
+  };
+}
+
+function mergePrefixEnvs(target, source) {
+  if (!source) return target;
+  const map = source.map || {};
+  for (const [prefix, iri] of Object.entries(map)) {
+    // Every parser starts with an empty default namespace. Do not let a later
+    // source that never declared ':' erase a useful default namespace from an
+    // earlier source; prefix merging is for output readability only.
+    if (iri || !Object.prototype.hasOwnProperty.call(target.map, prefix)) target.set(prefix, iri);
+  }
+  if (source.baseIri) target.setBase(source.baseIri);
+  return target;
+}
+
+function mergeParsedDocuments(docs, opts = {}) {
+  const documents = Array.isArray(docs) ? docs : [];
+  const scopeBlankNodes = typeof opts.scopeBlankNodes === 'boolean' ? opts.scopeBlankNodes : documents.length > 1;
+
+  const merged = emptyParsedDocument();
+  const mergedSources = [];
+
+  for (let i = 0; i < documents.length; i++) {
+    const originalDoc = documents[i] || emptyParsedDocument();
+    const doc = scopeBlankNodes ? scopeBlankNodesInDocument(originalDoc, i + 1) : originalDoc;
+
+    mergePrefixEnvs(merged.prefixes, doc.prefixes);
+    merged.triples.push(...(doc.triples || []));
+    merged.frules.push(...(doc.frules || []));
+    merged.brules.push(...(doc.brules || []));
+    merged.logQueryRules.push(...(doc.logQueryRules || []));
+    mergedSources.push(doc);
+  }
+
+  Object.defineProperty(merged, 'sources', {
+    value: mergedSources,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+
+  return merged;
+}
+
+function isN3SourceListInput(input) {
+  return !!(input && typeof input === 'object' && !Array.isArray(input) && Array.isArray(input.sources));
+}
+
+function normalizeN3SourceItem(source, index) {
+  const sourceNumber = index + 1;
+  if (typeof source === 'string') {
+    return { text: source, label: `<source ${sourceNumber}>`, baseIri: '' };
+  }
+  if (!source || typeof source !== 'object' || Array.isArray(source)) {
+    throw new TypeError('Each N3 source must be a string or an object with an n3/text field');
+  }
+
+  const text = typeof source.n3 === 'string' ? source.n3 : typeof source.text === 'string' ? source.text : null;
+  if (text === null) throw new TypeError('Each N3 source object must provide an n3 or text string');
+
+  return {
+    text,
+    label: typeof source.label === 'string' && source.label ? source.label : `<source ${sourceNumber}>`,
+    baseIri: typeof source.baseIri === 'string' ? source.baseIri : '',
+  };
+}
+
+function parseN3SourceList(input, opts = {}) {
+  if (!isN3SourceListInput(input)) return null;
+  const sources = input.sources.map(normalizeN3SourceItem);
+  const defaultBaseIri = typeof opts.baseIri === 'string' ? opts.baseIri : '';
+  const parsed = sources.map((source, index) =>
+    parseN3Text(source.text, {
+      label: source.label,
+      baseIri: source.baseIri || (sources.length === 1 ? defaultBaseIri : ''),
+    }),
+  );
+  return mergeParsedDocuments(parsed, {
+    scopeBlankNodes: typeof input.scopeBlankNodes === 'boolean' ? input.scopeBlankNodes : parsed.length > 1,
+  });
+}
+
+module.exports = {
+  emptyParsedDocument,
+  parseN3Text,
+  mergeParsedDocuments,
+  scopeBlankNodesInDocument,
+  isN3SourceListInput,
+  parseN3SourceList,
+};

package/lib/rules.js

@@ -7,9 +7,23 @@
 
 'use strict';
 
-const { Var, Blank, ListTerm, OpenListTerm, GraphTerm, Triple, copyQuotedGraphMetadata } = require('./prelude');
+const {
+  LOG_NS,
+  Iri,
+  Var,
+  Blank,
+  ListTerm,
+  OpenListTerm,
+  GraphTerm,
+  Triple,
+  copyQuotedGraphMetadata,
+} = require('./prelude');
 
 function liftBlankRuleVars(premise, conclusion) {
+  function isLogIncludesLikePredicate(p) {
+    return p instanceof Iri && (p.value === LOG_NS + 'includes' || p.value === LOG_NS + 'notIncludes');
+  }
+
   // Map blank labels to stable rule-local variable names.
   // This runs at rule construction time; keep it simple and allocation-light.
   const mapping = Object.create(null);
@@ -66,9 +80,19 @@ function liftBlankRuleVars(premise, conclusion) {
     return t;
   }
 
-  const newPremise = premise.map(
-    (tr) => new Triple(convertTerm(tr.s, true), convertTerm(tr.p, true), convertTerm(tr.o, true)),
-  );
+  const newPremise = premise.map((tr) => {
+    // In log:includes / log:notIncludes, quoted formula operands are formulas
+    // consumed by the builtin rather than ordinary triple patterns. Keep their
+    // local blank nodes as Blank terms so the builtin can treat them as local
+    // existentials, and bindings returned from an explicit scope are blank nodes
+    // instead of synthetic rule variables such as ?_b1.
+    const keepFormulaBlanks = isLogIncludesLikePredicate(tr.p);
+    return new Triple(
+      keepFormulaBlanks && tr.s instanceof GraphTerm ? copyQuotedTerm(tr.s) : convertTerm(tr.s, true),
+      convertTerm(tr.p, true),
+      keepFormulaBlanks && tr.o instanceof GraphTerm ? copyQuotedTerm(tr.o) : convertTerm(tr.o, true),
+    );
+  });
   return [newPremise, conclusion];
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.22.16",
+  "version": "1.23.1",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/api.test.js

@@ -1643,6 +1643,30 @@ _:x :hates { _:foo :making :mess }.
     expect: [/:(?:test)\s+:(?:contains)\s+:(?:success-literal-3)\s*\./, /:(?:test)\s+:(?:is)\s+true\s*\./],
   },
 
+  {
+    name: '60a regression: log:includes explicit-scope blank node is returned as blank, not synthetic variable',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/ns#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+
+{
+  {
+    _:b1 a :Mortal .
+  } log:includes {
+    ?CS ?CP ?CO .
+  } .
+}
+=>
+{
+  _:b2 :conclusion {
+    ?CS ?CP ?CO .
+  } .
+} .
+`,
+    expect: [/_:sk_\d+\s+:(?:conclusion)\s+\{\s*_:b\d+\s+a\s+:(?:Mortal)\s*\.\s*\}\s*\./s],
+    notExpect: [/\?_b\d+\s+a\s+:(?:Mortal)/],
+  },
+
   {
     name: '61 RDF/JS input + rule objects: reason() accepts quads with rules',
     run() {
@@ -2309,6 +2333,107 @@ _:b a ex:Person ; ex:name "B" .
 `,
     expect: [/^:test\s+:is\s+true\s*\./m],
   },
+  {
+    name: '69 CLI multi-input: parses files separately and reasons over merged AST',
+    run() {
+      const os = require('node:os');
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-multi-input-'));
+      const factsPath = path.join(tmp, 'facts.n3');
+      const rulesPath = path.join(tmp, 'rules.n3');
+
+      fs.writeFileSync(factsPath, '@prefix : <http://example.org/> .\n:Socrates a :Man .\n', 'utf8');
+      fs.writeFileSync(rulesPath, '@prefix : <http://example.org/> .\n{ ?x a :Man } => { ?x a :Mortal } .\n', 'utf8');
+
+      try {
+        const r = spawnSync(process.execPath, [path.join(ROOT, 'eyeling.js'), factsPath, rulesPath], {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe'],
+          maxBuffer: DEFAULT_MAX_BUFFER,
+        });
+        if (r.error) throw r.error;
+        if (r.status !== 0) {
+          const err = new Error(`CLI failed with exit ${r.status}`);
+          err.code = r.status;
+          err.stdout = r.stdout;
+          err.stderr = r.stderr;
+          throw err;
+        }
+        return r.stdout;
+      } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+      }
+    },
+    expect: [/:(?:Socrates)\s+a\s+:(?:Mortal)\s*\./],
+  },
+  {
+    name: '70 CLI multi-input: scopes blank node labels per source',
+    run() {
+      const os = require('node:os');
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-multi-blank-'));
+      const leftPath = path.join(tmp, 'left.n3');
+      const rightPath = path.join(tmp, 'right.n3');
+      const rulePath = path.join(tmp, 'rule.n3');
+
+      fs.writeFileSync(leftPath, '@prefix : <http://example.org/> .\n_:x :p :a .\n', 'utf8');
+      fs.writeFileSync(rightPath, '@prefix : <http://example.org/> .\n_:x :q :b .\n', 'utf8');
+      fs.writeFileSync(
+        rulePath,
+        '@prefix : <http://example.org/> .\n{ ?x :p :a . ?x :q :b . } => { :bad :merged true } .\n',
+        'utf8',
+      );
+
+      try {
+        const r = spawnSync(process.execPath, [path.join(ROOT, 'eyeling.js'), leftPath, rightPath, rulePath], {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe'],
+          maxBuffer: DEFAULT_MAX_BUFFER,
+        });
+        if (r.error) throw r.error;
+        if (r.status !== 0) {
+          const err = new Error(`CLI failed with exit ${r.status}`);
+          err.code = r.status;
+          err.stdout = r.stdout;
+          err.stderr = r.stderr;
+          throw err;
+        }
+        return r.stdout;
+      } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+      }
+    },
+    notExpect: [/^:bad\s+:merged\s+true\s*\./m],
+  },
+  {
+    name: '71 API multi-source: reason() accepts source list input',
+    run() {
+      return reason(
+        { proofComments: false },
+        {
+          sources: [
+            '@prefix : <http://example.org/> .\n:Socrates a :Man .\n',
+            '@prefix : <http://example.org/> .\n{ ?x a :Man } => { ?x a :Mortal } .\n',
+          ],
+        },
+      );
+    },
+    expect: [/:(?:Socrates)\s+a\s+:(?:Mortal)\s*\./],
+  },
+  {
+    name: '72 API multi-source: reasonStream() accepts source list input',
+    run() {
+      const result = reasonStream(
+        {
+          sources: [
+            '@prefix : <http://example.org/> .\n:Socrates a :Man .\n',
+            '@prefix : <http://example.org/> .\n{ ?x a :Man } => { ?x a :Mortal } .\n',
+          ],
+        },
+        { proof: false },
+      );
+      return result.closureN3;
+    },
+    expect: [/:(?:Socrates)\s+a\s+:(?:Mortal)\s*\./],
+  },
   {
     name: 'regression: log:semantics body alpha-renaming does not refire blank-head rule forever',
     async run() {