eyeleng 1.1.2 → 1.2.1

package/README.md

@@ -3,15 +3,49 @@
 [![npm version](https://img.shields.io/npm/v/eyeleng.svg)](https://www.npmjs.com/package/eyeleng)
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20342577-blue.svg)](https://doi.org/10.5281/zenodo.20342577)
 
-`eyeleng` stands for **EYE Logic Engine**. It is a compact JavaScript implementation of SHACL 1.2 Rules with two rule front-ends:
+The `leng` in `eyeleng` stands for **Logic Engine Next Generation**. Eyeleng's main purpose is **automatic hybrid reasoning**: it combines forward materialization with tabled backward proving and automatically chooses how rules should be evaluated.
+
+Eyeleng is a compact JavaScript implementation of SHACL 1.2 Rules with two rule front-ends:
 
 - **SRL** — the Shape Rules Language syntax used by the SHACL 1.2 Rules draft.
 - **RDF Rules** — a Turtle/RDF syntax for rule sets.
 
-Eyeleng is a compact reasoner over RDF-style triples. It still uses forward chaining for ordinary finite materialization, but the default execution mode now includes conservative auto-hybrid planning: selected function-like predicates can be proved just in time by a tabled backward prover when they are demanded by a query or by another rule body. It is deliberately small, dependency-free at runtime, readable as ordinary JavaScript, and usable from the CLI, Node.js, and the browser playground.
+Eyeleng is a compact automatic hybrid reasoner over RDF-style triples. It uses forward chaining for ordinary finite materialization while its default execution mode applies conservative hybrid planning: selected function-like predicates can be proved just in time by a tabled backward prover when they are demanded by a query or another rule body. It is deliberately small, dependency-free at runtime, readable as ordinary JavaScript, and usable from the CLI, Node.js, and the browser playground.
 
 Eyeleng implements the rules/reasoning surface. It is **not** a SHACL validation engine and does not emit SHACL validation reports.
 
+## Why Eyeleng?
+
+Eyeleng is a next-generation path for rule-based RDF reasoning: it combines a language being developed on the W3C standards track with an execution model that automatically uses both forward and backward reasoning.
+
+The central choice is **SHACL 1.2 Rules instead of N3 as the native rule language**. SHACL 1.2 Rules is being developed by the W3C Data Shapes Working Group as a W3C Working Draft on the Recommendation track. It defines both an RDF representation of rule sets and the concise Shape Rules Language (SRL), together with `infer` and `query` operations. By contrast, the current N3 specification is a W3C Community Group Report. Community Group Reports are useful specifications, but they are not on the W3C standards track and are not W3C-endorsed standards.
+
+That standards position does not require giving up the kinds of programs traditionally written in N3. The N3 examples translated to SRL or RDF Rules and tested with Eyeleng so far have retained their intended reasoning behavior. This is practical evidence that existing N3 rule programs can migrate to the SHACL Rules model, although Eyeleng does not parse N3 syntax directly and this is not yet a claim that every possible N3 extension has a translation.
+
+Eyeleng also removes a choice that N3 engines commonly expose to the rule author. In EYE, Eyeling, and Eyeron, `=>` and `<=` explicitly select forward and backward rules. In Eyeleng, rules describe the logical relationship while the engine analyzes dependencies and demand. It materializes ordinary consequences forward and can prove safe, function-like predicates backward with tabling only when they are needed. This avoids exposing internal helper triples merely because they were required during a computation, while preserving forward closure where materialization is appropriate.
+
+The related engines therefore mark stages and implementation choices rather than hard limits on what Eyeleng may replace:
+
+| Project | Native language and runtime | Main reason to choose it |
+| --- | --- | --- |
+| **EYE** | N3 on SWI-Prolog | The mature, extensive N3 implementation and ecosystem |
+| **Eyeling** | N3 implemented in JavaScript | Direct JavaScript and RDF-JS integration with explicit forward and backward N3 rules |
+| **Eyeron** | N3 implemented in Rust, with native and WebAssembly APIs | Rust-native or WebAssembly deployment with N3 proofs and built-ins |
+| **Eyeleng** | SHACL 1.2 SRL and RDF Rules implemented in JavaScript | A W3C Recommendation-track language plus automatic hybrid reasoning |
+
+Choose Eyeleng when you want to:
+
+- build new rule systems on SHACL 1.2 Rules rather than a Community Group language;
+- migrate N3 reasoning workloads to SRL or RDF Rules;
+- let the engine choose between materialization and goal-directed evaluation;
+- use tabling for recursive, function-like computations without publishing their intermediate facts;
+- combine stratified negation, dependency analysis, RDF 1.2 syntax, and rule execution in one compact engine;
+- run the same dependency-free implementation from a CLI, Node.js, or a browser.
+
+In short: **Eyeleng aims to carry the practical reasoning power demonstrated by the EYE family into SHACL 1.2 Rules, with automatic hybrid execution as the default rather than explicit reasoning direction as a language-level choice.**
+
+Standards references: [SHACL 1.2 Rules](https://www.w3.org/TR/shacl12-rules/), [Notation3 Community Group](https://www.w3.org/groups/cg/n3-dev/), and [W3C document types](https://www.w3.org/standards/types/).
+
 ## Quick start
 
 ```sh
@@ -43,7 +77,7 @@ It derives:
 
 Open the [Playground](https://eyereasoner.github.io/eyeleng/playground) for a self-contained browser UI with URL loading, autosave, share links, diagnostics, queries, and SRL/RDF Rules syntax selection.
 
-## How the reasoner works
+## How automatic hybrid reasoning works
 
 Eyeleng computes the closure of a rule set:
 
@@ -189,15 +223,23 @@ The replay data includes message streams, envelopes, offsets, next-envelope link
 
 ## CLI
 
+```text
+Usage: eyeleng [options] [file-or-url.n3|- ...]
+```
+
+With no input arguments, Eyeleng prints help. Pass `-` to read from standard input; local files and HTTP(S) URLs can be combined as positional inputs.
+
 Common commands:
 
 ```sh
 ./eyeleng.js examples/family.srl
 ./eyeleng.js --all examples/family.srl
 ./eyeleng.js --check --deps examples/stratified-negation.srl
-./eyeleng.js --json --trace --stats examples/if-then.srl
+./eyeleng.js --json --prove --stats examples/if-then.srl
 ./eyeleng.js --query-file examples/query-body.txt examples/query.srl
 ./eyeleng.js --syntax rdf examples/w3c-rule-set-snippet.ttl
+cat examples/family.srl | ./eyeleng.js -
+./eyeleng.js https://example.org/rules.n3
 ```
 
 Important options:
@@ -205,7 +247,7 @@ Important options:
 ```text
 --all                 print the full closure, including input facts
 --json                print JSON instead of compact triples/bindings
---trace               print derivation trace to stderr, or include it in JSON
+--prove               print proof explanations
 --stats               print iteration and triple counts to stderr
 --check               parse and analyze only; do not run rules
 --strict              treat static warnings as errors, including recursive term generation

package/dist/browser/eyeleng.browser.js

@@ -15,7 +15,7 @@
       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');
       
@@ -138,6 +138,7 @@
         sortTriples,
         toJSON,
         formatTrace,
+        formatProof,
         resultTriples,
       };
       
@@ -4263,6 +4264,7 @@
                   rule: rule.name || `rule#${ruleIndex + 1}`,
                   triple,
                   binding,
+                  uses: proofUses(rule.body, binding),
                 });
               }
             }
@@ -4273,6 +4275,17 @@
         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 {
@@ -6063,6 +6076,35 @@
         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
@@ -6094,7 +6136,7 @@
           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;
@@ -6123,7 +6165,7 @@
         return value;
       }
       
-      module.exports = { sortTriples, formatTriples, formatTrace, formatBindings, formatBinding, toJSON };
+      module.exports = { sortTriples, formatTriples, formatTrace, formatProof, formatBindings, formatBinding, toJSON };
       
     },
     "src/query.js": function (require, module, exports) {

package/examples/README.md

@@ -1,5 +1,7 @@
 # W3C SHACL 1.2 Rules draft examples
 
+Eyeleng—where `leng` stands for **Logic Engine Next Generation**—is built for automatic hybrid reasoning, combining forward materialization with tabled backward proving.
+
 This directory contains runnable examples, including files mirrored from the SHACL 1.2 Rules draft.
 It also includes SRL adaptations of selected eyeling N3 examples.
 
@@ -7,3 +9,5 @@ It also includes SRL adaptations of selected eyeling N3 examples.
 - `.ttl` files exercise the RDF Rules syntax front-end.
 
 All `.srl` and `.ttl` files in this directory are run by `test/examples.test.js`; most have golden TriG outputs in `examples/output/*.trig`.
+
+For a minimal starting point, `socrates.srl` derives the classic conclusion that Socrates is mortal from the facts that Socrates is human and every human is mortal.

package/examples/output/socrates.trig

@@ -0,0 +1 @@
+:Socrates a :Mortal .

package/examples/socrates.srl

@@ -0,0 +1,12 @@
+PREFIX : <http://example.org/socrates#>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+
+DATA {
+  :Socrates a :Human .
+  :Human rdfs:subClassOf :Mortal .
+}
+
+RULE { ?individual a ?superclass } WHERE {
+  ?individual a ?class .
+  ?class rdfs:subClassOf ?superclass .
+}

package/eyeleng.js

@@ -17,7 +17,7 @@
         queryProgram,
         queryRunOptions,
         formatTriples,
-        formatTrace,
+        formatProof,
         formatBindings,
         toJSON,
         resultTriples,
@@ -41,15 +41,28 @@
       
       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,
@@ -70,7 +83,7 @@
           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;
@@ -111,6 +124,8 @@
             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 {
@@ -121,13 +136,26 @@
         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() {
@@ -172,7 +200,7 @@
         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) {
@@ -183,7 +211,11 @@
             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,
@@ -245,15 +277,18 @@
           }
       
           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) {
@@ -271,9 +306,9 @@
         }
       }
       
-      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 };
       
     },
     "src/api.js": function (require, module, exports) {
@@ -284,7 +319,7 @@
       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');
       
@@ -407,6 +442,7 @@
         sortTriples,
         toJSON,
         formatTrace,
+        formatProof,
         resultTriples,
       };
       
@@ -4532,6 +4568,7 @@
                   rule: rule.name || `rule#${ruleIndex + 1}`,
                   triple,
                   binding,
+                  uses: proofUses(rule.body, binding),
                 });
               }
             }
@@ -4542,6 +4579,17 @@
         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 {
@@ -6332,6 +6380,35 @@
         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
@@ -6363,7 +6440,7 @@
           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;
@@ -6392,7 +6469,7 @@
         return value;
       }
       
-      module.exports = { sortTriples, formatTriples, formatTrace, formatBindings, formatBinding, toJSON };
+      module.exports = { sortTriples, formatTriples, formatTrace, formatProof, formatBindings, formatBinding, toJSON };
       
     },
     "src/query.js": function (require, module, exports) {
@@ -6544,5 +6621,7 @@
     __modules[id](localRequire, module, module.exports);
     return module.exports;
   }
-  process.exitCode = __require("src/cli.js").main(process.argv.slice(2));
+  Promise.resolve(__require("src/cli.js").main(process.argv.slice(2)))
+    .then((code) => { process.exitCode = code; })
+    .catch((error) => { console.error(error); process.exitCode = 1; });
 }());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeleng",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "description": "The EYE Logic Engine: a JavaScript implementation of SHACL Rules, including SRL and RDF Rules syntax front-ends.",
   "keywords": [
     "SRL",
@@ -14,7 +14,7 @@
   },
   "homepage": "https://github.com/eyereasoner/eyeleng#readme",
   "bin": {
-    "eyeleng": "./eyeleng.js"
+    "eyeleng": "eyeleng.js"
   },
   "files": [
     "LICENSE.md",