@yegor256/dogent 0.7.7 → 0.8.0

package/package.json

@@ -40,7 +40,7 @@
     "lint": "eslint .",
     "test": "mocha 'test/**/*.js' --timeout 60000"
   },
-  "version": "0.7.7",
+  "version": "0.8.0",
   "dependencies": {
     "minimist": "^1.2.8"
   }

package/src/args.js

@@ -13,13 +13,15 @@ const minimist = require('minimist');
  * The command-line arguments handed to dogent. It leans on minimist to split
  * the raw argv into recognized options and the manifesto paths that remain.
  * The `--sarif` flag switches the report to SARIF, while `--offline` forbids
- * any talk to the LLM even when a token sits in the environment. Everything
- * after a `--` separator counts as a path, never as an option.
+ * any talk to the LLM even when a token sits in the environment. The `--help`
+ * flag, also spelled `-h`, asks for the usage banner. The `--version` flag
+ * asks for the release number. Everything after a `--` separator counts as a
+ * path, never as an option.
  */
 class Args {
-  constructor(argv, flags = ['sarif', 'offline']) {
+  constructor(argv, flags = ['sarif', 'offline', 'help', 'version']) {
     this.flags = flags;
-    this.parsed = minimist(argv, {boolean: flags, '--': true});
+    this.parsed = minimist(argv, {boolean: flags, alias: {help: 'h'}, '--': true});
   }
   sarif() {
     return this.parsed.sarif === true;
@@ -27,12 +29,18 @@ class Args {
   offline() {
     return this.parsed.offline === true;
   }
+  help() {
+    return this.parsed.help === true;
+  }
+  version() {
+    return this.parsed.version === true;
+  }
   paths() {
     return this.parsed._.concat(this.parsed['--']).map(String);
   }
   unknown() {
     return Object.keys(this.parsed)
-      .filter((key) => key !== '_' && key !== '--' && !this.flags.includes(key))
+      .filter((key) => key !== '_' && key !== '--' && key !== 'h' && !this.flags.includes(key))
       .map((key) => `${key.length === 1 ? '-' : '--'}${key}`);
   }
 }

package/src/dogent.js

@@ -14,19 +14,37 @@ const Sources = require('./sources');
 const Openai = require('./openai');
 const Oracle = require('./oracle');
 const Usage = require('./usage');
+const version = require('./version');
 const rules = require('./rules');
 
 const args = new Args(process.argv.slice(2));
 const sarif = args.sarif();
+const banner = 'Usage: dogent [--sarif] [--offline] <file.md|dir>...';
+if (args.version()) {
+  process.stdout.write(`${version}\n`);
+  process.exit(0);
+}
+if (args.help()) {
+  process.stdout.write(
+    `${banner}\n\n` +
+    'Lint agentic manifesto files like SKILL.md and CLAUDE.md.\n\n' +
+    'Options:\n' +
+    '  --sarif    render the report as SARIF JSON\n' +
+    '  --offline  never call the LLM, even when a token exists\n' +
+    '  --version  show the version and exit\n' +
+    '  --help     show this help and exit\n'
+  );
+  process.exit(0);
+}
 const unknown = args.unknown();
 if (unknown.length > 0) {
   process.stderr.write(`Unknown option: ${unknown[0]}\n`);
-  process.stderr.write('Usage: dogent [--sarif] [--offline] <file.md|dir>...\n');
+  process.stderr.write(`${banner}\n`);
   process.exit(2);
 }
 const paths = args.paths();
 if (paths.length === 0) {
-  process.stderr.write('Usage: dogent [--sarif] [--offline] <file.md|dir>...\n');
+  process.stderr.write(`${banner}\n`);
   process.exit(2);
 }
 const scanned = new Sources(paths).files();

package/src/rules/atomic.js

@@ -12,18 +12,20 @@ const Region = require('../region');
  * Atomic.
  *
  * Demands that every line carry exactly one instruction. A standalone
- * checker only spots the loud signs: a sentence terminator sitting
- * mid-line with more text after it, or two verb phrases welded together
- * with a semicolon, an " and ", or a " then ". The prompt hands the
- * subtler clause-counting to the AI oracle, which catches the
- * multi-instruction lines that carry no such welding token.
+ * checker spots only the unambiguous signs: a sentence terminator
+ * sitting mid-line with more text after it, or two clauses welded
+ * together by a semicolon. An " and " or " then " is left alone, since
+ * no suffix heuristic can tell a second verb from a coordinated object
+ * or temporal adverb without reading the word as language. The prompt
+ * hands that subtler clause-counting to the AI oracle, which weighs the
+ * full sentence before judging a line as multi-instruction.
  */
 class Atomic {
   constructor() {
     this.id = 'atomic';
   }
   prompt() {
-    return `${this.id}: flag any line that carries more than one instruction, counting distinct clauses even when no semicolon, "and", or "then" welds them together`;
+    return `${this.id}: flag any line that carries more than one instruction, counting distinct clauses whether or not a semicolon, "and", or "then" welds them, yet never count a coordinated object or noun phrase trailing "and" or "then" as a second instruction`;
   }
   violations(document) {
     const uri = document.uri();
@@ -37,11 +39,8 @@ class Atomic {
   }
   judge(text, line, uri) {
     const clean = text.replace(/^\s*(?:[-*+]|\d+\.)\s+/u, '').trimEnd();
-    const weld = /(?<!,)\s(?:and|then)\s+(?<verb>[a-z]+)\s+\S/u.exec(clean);
-    const welded = weld !== null &&
-      !/^(?:the|a|an)$/u.test(weld.groups.verb) &&
-      !/(?:ly|al|ial|ous|ive|less|ic|ary|ory|able|ible|ate)$/u.test(weld.groups.verb);
-    if (!/[.!?]\s+\S/u.test(clean) && !/;/u.test(clean) && !welded) {
+    const masked = clean.replace(/\b(?:e\.g|i\.e|etc)\./giu, (match) => match.replace(/\./gu, ' '));
+    if (!/[.!?]\s+\S/u.test(masked) && !/;/u.test(masked)) {
       return [];
     }
     return [new Violation(

package/src/rules/simple.js

@@ -8,12 +8,31 @@
 const Violation = require('../violation');
 const Region = require('../region');
 
+/**
+ * Counts the commas that sit inside a coordinated `A, B, or C` list run,
+ * so an enumeration can be discounted before clause commas are weighed.
+ * @param {string} text The line to scan
+ * @return {number} The number of commas belonging to coordinated lists
+ */
+const listCommas = function listCommas(text) {
+  const runs = text.match(/(?:[^,]+,\s*)+(?:or|and)\b/giu);
+  if (runs === null) {
+    return 0;
+  }
+  return runs.reduce((sum, run) => {
+    const inner = run.match(/,/gu);
+    return sum + (inner === null ? 0 : inner.length);
+  }, 0);
+};
+
 /**
  * Simple.
  *
  * Demands simple grammar over ambiguity. A standalone checker can only
  * guess: it counts commas and conjunctions to flag lines that pile up
- * clauses. Its prompt hands the subtler tangle judgement to the oracle,
+ * clauses. Commas inside a coordinated `A, B, or C` list are discounted
+ * first, so a lone enumeration sitting in one clause does not read as
+ * tangled. Its prompt hands the subtler tangle judgement to the oracle,
  * which weighs true clause depth rather than counting punctuation.
  */
 class Simple {
@@ -36,8 +55,9 @@ class Simple {
   judge(text, line, uri) {
     const commas = text.match(/,/gu);
     const commaCount = commas === null ? 0 : commas.length;
+    const clauseCommas = commaCount - listCommas(text);
     const hasConjunction = /\b(?:if|when|unless|because|although|while)\b/iu.test(text);
-    const tangled = hasConjunction && commaCount >= 2;
+    const tangled = hasConjunction && clauseCommas >= 2;
     if (!tangled) {
       return [];
     }

package/src/usage.js

@@ -45,7 +45,7 @@ class Usage {
     return this.sent / 1e6 * price.input + this.received / 1e6 * price.output;
   }
   text() {
-    return `OpenAI: ${this.model}, ${this.sent} sent, ${this.received} received, ~${(this.cost() * 100).toFixed(2)}¢`;
+    return `OpenAI: ${this.model}, ${this.sent}+${this.received} tokens, ${(this.cost() * 100).toFixed(2)}¢`;
   }
 }
 

package/src/version.js

@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+ * SPDX-License-Identifier: MIT
+ */
+
+'use strict';
+
+/**
+ * Version.
+ *
+ * The current release of dogent, replaced on every release by rultor.
+ * The default `0.8.0` marks an unreleased build straight from source.
+ */
+const version = '0.8.0';
+
+module.exports = version;