eyeling 1.22.15 → 1.23.0

package/index.js

@@ -7,6 +7,7 @@ const cp = require('node:child_process');
 
 const bundleApi = require('./eyeling.js');
 const { dataFactory, normalizeReasonerInputSync } = require('./lib/rdfjs');
+const { isN3SourceListInput } = require('./lib/multisource');
 const engine = require('./lib/engine');
 
 function reason(opt = {}, input = '') {
@@ -16,11 +17,6 @@ function reason(opt = {}, input = '') {
   if (Array.isArray(opt)) opt = { args: opt };
   if (opt == null || typeof opt !== 'object') opt = {};
 
-  const n3Input = normalizeReasonerInputSync(input);
-  if (typeof n3Input !== 'string') {
-    throw new TypeError('reason(opt, input): input must resolve to an N3 string');
-  }
-
   const args = [];
 
   // default: proof comments OFF for API output (machine-friendly)
@@ -53,13 +49,38 @@ function reason(opt = {}, input = '') {
   const maxBuffer = Number.isFinite(opt.maxBuffer) ? opt.maxBuffer : 50 * 1024 * 1024;
 
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-'));
-  const inputFile = path.join(dir, 'input.n3');
+
+  function normalizeSourceForTempFile(source) {
+    if (typeof source === 'string') return source;
+    if (source && typeof source === 'object' && !Array.isArray(source)) {
+      const text = typeof source.n3 === 'string' ? source.n3 : typeof source.text === 'string' ? source.text : null;
+      if (text !== null) {
+        return typeof source.baseIri === 'string' && source.baseIri ? `@base <${source.baseIri}> .\n${text}` : text;
+      }
+    }
+    throw new TypeError('reason(opt, input): each source must be a string or an object with an n3/text field');
+  }
 
   try {
-    fs.writeFileSync(inputFile, n3Input, 'utf8');
+    const inputFiles = [];
+    if (isN3SourceListInput(input)) {
+      input.sources.forEach((source, index) => {
+        const inputFile = path.join(dir, `input-${index + 1}.n3`);
+        fs.writeFileSync(inputFile, normalizeSourceForTempFile(source), 'utf8');
+        inputFiles.push(inputFile);
+      });
+    } else {
+      const n3Input = normalizeReasonerInputSync(input);
+      if (typeof n3Input !== 'string') {
+        throw new TypeError('reason(opt, input): input must resolve to an N3 string');
+      }
+      const inputFile = path.join(dir, 'input.n3');
+      fs.writeFileSync(inputFile, n3Input, 'utf8');
+      inputFiles.push(inputFile);
+    }
 
     const eyelingPath = path.join(__dirname, 'eyeling.js');
-    const res = cp.spawnSync(process.execPath, [eyelingPath, ...args, inputFile], { encoding: 'utf8', maxBuffer });
+    const res = cp.spawnSync(process.execPath, [eyelingPath, ...args, ...inputFiles], { encoding: 'utf8', maxBuffer });
 
     if (res.error) throw res.error;
 

package/lib/cli.js

@@ -13,6 +13,7 @@ const { pathToFileURL } = require('node:url');
 const engine = require('./engine');
 const deref = require('./deref');
 const { PrefixEnv } = require('./prelude');
+const { parseN3Text, mergeParsedDocuments } = require('./multisource');
 
 function offsetToLineCol(text, offset) {
   const chars = Array.from(text);
@@ -96,8 +97,9 @@ function main() {
 
   function printHelp(toStderr = false) {
     const msg =
-      `Usage: ${prog} [options] [file.n3|-]\n\n` +
-      `When no file is given and stdin is piped, read N3 from stdin.\n\n` +
+      `Usage: ${prog} [options] [file-or-url.n3|- ...]\n\n` +
+      `When no file is given and stdin is piped, read N3 from stdin.\n` +
+      `When multiple inputs are given, parse each source separately, merge ASTs, then reason once.\n\n` +
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
@@ -141,7 +143,7 @@ function main() {
       builtinModules.push(a.slice('--builtin='.length));
       continue;
     }
-    if (!a.startsWith('-')) positional.push(a);
+    if (a === '-' || !a.startsWith('-')) positional.push(a);
   }
 
   const showAst = argv.includes('--ast') || argv.includes('-a');
@@ -167,17 +169,12 @@ function main() {
     if (typeof engine.setSuperRestrictedMode === 'function') engine.setSuperRestrictedMode(true);
   }
 
-  // Positional args (the N3 file)
+  // Positional args (one or more N3 sources).
   const useImplicitStdin = positional.length === 0 && !process.stdin.isTTY;
   if (positional.length === 0 && !useImplicitStdin) {
     printHelp(false);
     process.exit(0);
   }
-  if (positional.length > 1) {
-    console.error('Error: expected at most one input [file.n3|-].');
-    printHelp(true);
-    process.exit(1);
-  }
 
   for (const spec of builtinModules) {
     try {
@@ -189,35 +186,47 @@ function main() {
     }
   }
 
-  const sourceLabel = useImplicitStdin || positional[0] === '-' ? '<stdin>' : positional[0];
-  const baseIri = __sourceLabelToBaseIri(sourceLabel);
-
-  let text;
-  try {
-    text = __readInputSourceSync(sourceLabel);
-  } catch (e) {
-    if (sourceLabel === '<stdin>') console.error(`Error reading stdin: ${e.message}`);
-    else console.error(`Error reading file ${JSON.stringify(sourceLabel)}: ${e.message}`);
+  const sourceLabels = useImplicitStdin ? ['<stdin>'] : positional.map((item) => (item === '-' ? '<stdin>' : item));
+  if (sourceLabels.filter((item) => item === '<stdin>').length > 1) {
+    console.error('Error: stdin can only be used once.');
     process.exit(1);
   }
 
-  let toks;
-  let prefixes, triples, frules, brules, qrules;
-  try {
-    toks = engine.lex(text);
-    const parser = new engine.Parser(toks);
-    if (baseIri) parser.prefixes.setBase(baseIri);
-    [prefixes, triples, frules, brules, qrules] = parser.parseDocument();
-    // Make the parsed prefixes available to log:trace output (CLI path)
-    engine.setTracePrefixes(prefixes);
-  } catch (e) {
-    if (e && e.name === 'N3SyntaxError') {
-      console.error(formatN3SyntaxError(e, text, sourceLabel));
+  const parsedSources = [];
+  for (const sourceLabel of sourceLabels) {
+    let text;
+    try {
+      text = __readInputSourceSync(sourceLabel);
+    } catch (e) {
+      if (sourceLabel === '<stdin>') console.error(`Error reading stdin: ${e.message}`);
+      else console.error(`Error reading source ${JSON.stringify(sourceLabel)}: ${e.message}`);
       process.exit(1);
     }
-    throw e;
+
+    try {
+      parsedSources.push(
+        parseN3Text(text, {
+          baseIri: __sourceLabelToBaseIri(sourceLabel),
+          label: sourceLabel,
+        }),
+      );
+    } catch (e) {
+      if (e && e.name === 'N3SyntaxError') {
+        console.error(formatN3SyntaxError(e, text, sourceLabel));
+        process.exit(1);
+      }
+      throw e;
+    }
   }
 
+  const mergedDocument = mergeParsedDocuments(parsedSources);
+  const prefixes = mergedDocument.prefixes;
+  const triples = mergedDocument.triples;
+  const frules = mergedDocument.frules;
+  const brules = mergedDocument.brules;
+  const qrules = mergedDocument.logQueryRules;
+  const tokenSets = parsedSources.map((source) => ({ tokens: source.tokens, prefixes: source.prefixes }));
+
   if (showAst) {
     function astReplacer(unusedJsonKey, value) {
       if (value instanceof Set) return Array.from(value);
@@ -359,7 +368,10 @@ function main() {
   const mayAutoRenderOutputStrings = programMayProduceOutputStrings(triples, frules, qrules);
 
   if (streamMode && !hasQueries && !mayAutoRenderOutputStrings) {
-    const usedInInput = prefixesUsedInInputTokens(toks, prefixes);
+    const usedInInput = new Set();
+    for (const source of tokenSets) {
+      for (const pfx of prefixesUsedInInputTokens(source.tokens, source.prefixes)) usedInInput.add(pfx);
+    }
     const outPrefixes = restrictPrefixEnv(prefixes, usedInInput);
 
     // Ensure log:trace uses the same compact prefix set as the output.

package/lib/engine.js

@@ -38,6 +38,7 @@ const EMPTY_LIST_TERM = new ListTerm([]);
 const { lex, N3SyntaxError } = require('./lexer');
 const { Parser } = require('./parser');
 const { liftBlankRuleVars } = require('./rules');
+const { parseN3SourceList } = require('./multisource');
 
 const {
   makeBuiltins,
@@ -3379,7 +3380,8 @@ function reasonStream(input, opts = {}) {
     builtinModules = null,
   } = opts;
 
-  const parsedInput = normalizeParsedReasonerInputSync(input);
+  const parsedSourceList = parseN3SourceList(input, { baseIri });
+  const parsedInput = parsedSourceList || normalizeParsedReasonerInputSync(input);
   const rdfFactory = rdfjs ? getDataFactory(dataFactory) : null;
 
   const __oldEnforceHttps = deref.getEnforceHttpsEnabled();
@@ -3522,7 +3524,7 @@ function reasonRdfJs(input, opts = {}) {
 
   Promise.resolve().then(async () => {
     try {
-      const normalizedInput = await normalizeReasonerInputAsync(input);
+      const normalizedInput = parseN3SourceList(input, restOpts) || (await normalizeReasonerInputAsync(input));
       reasonStream(normalizedInput, {
         ...restOpts,
         rdfjs: false,

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/package.json

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

package/test/api.test.js

@@ -2309,6 +2309,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() {