@yegor256/dogent 0.12.1 → 0.12.3

package/README.md

@@ -53,7 +53,7 @@ Most rewrite prompts for you or score a file, while we enforce
 Run it on any manifesto file, no installation required:
 
 ```bash
-npx @yegor256/dogent@0.11.0 SKILL.md
+npx @yegor256/dogent@0.12.1 SKILL.md
 ```
 
 Point it at a directory to lint the default manifestos it holds
@@ -266,7 +266,7 @@ Reference `dogent` as a remote hook in `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/yegor256/dogent
-    rev: 0.11.0
+    rev: 0.12.1
     hooks:
       - id: dogent
 ```

package/package.json

@@ -40,7 +40,7 @@
     "lint": "eslint .",
     "test": "mocha 'test/**/*.js' --timeout 60000"
   },
-  "version": "0.12.1",
+  "version": "0.12.3",
   "dependencies": {
     "minimist": "^1.2.8",
     "pretty-ms": "^7.0.1"

package/src/dogent.js

@@ -73,11 +73,17 @@ const scan = () => {
   return [];
 };
 const scanned = scan();
-scanned.forEach((file) => process.stderr.write(`Scanning ${file}\n`));
+const bodies = new Map(scanned.map((file) => [file, fs.readFileSync(file, 'utf8')]));
+scanned.forEach((file) => {
+  const body = bodies.get(file);
+  const lines = body === '' ? 0 : body.split('\n').length - (body.endsWith('\n') ? 1 : 0);
+  const bytes = Buffer.byteLength(body);
+  process.stderr.write(`Scanning ${file} (${lines} lines, ${bytes} bytes)\n`);
+});
 const checks = rules();
 process.stderr.write(`${scanned.length} files scanned, ${checks.length} rules applied\n`);
 const documents = scanned.map(
-  (file) => new Markdown(file, fs.readFileSync(file, 'utf8')).document()
+  (file) => new Markdown(file, bodies.get(file)).document()
 );
 const started = Date.now();
 const suppressed = args.suppress();

package/src/oracle.js

@@ -14,7 +14,9 @@ const Answer = require('./answer');
  * The AI second opinion. Wraps the rules and a chat endpoint, builds one
  * prompt from a document, asks the endpoint, and parses the reply into
  * violations paired with the token usage the model reported. Mirrors a
- * rule, but consults a model instead of guessing.
+ * rule, but consults a model instead of guessing. Lets each rule veto an
+ * oracle flag it knows to be false, so a deterministic guard overrides
+ * the model.
  */
 class Oracle {
   constructor(rules, chat) {
@@ -24,7 +26,11 @@ class Oracle {
   async violations(document) {
     const reply = await this.chat.answer(new Prompt(this.rules, document).text());
     return {
-      found: new Answer(reply.content).violations(),
+      found: new Answer(reply.content).violations().filter(
+        (violation) => !this.rules.some(
+          (rule) => rule.suppress?.(violation, document)
+        )
+      ),
       usage: reply.usage
     };
   }

package/src/rules/command.js

@@ -15,6 +15,8 @@ const Region = require('../region');
  * checker can only guess: it flags lines that open with a pronoun or
  * end with a question mark, both signs of description, not order. Its
  * prompt hands the subtler imperative-mood judgement to the AI oracle.
+ * A deterministic guard then drops any oracle flag on a line that
+ * shows neither sign, so a base-form imperative is never flagged.
  */
 class Command {
   constructor() {
@@ -37,16 +39,7 @@ class Command {
     });
   }
   judge(text, line, uri) {
-    const clean = text.replace(/^\s*(?:[-*+]|\d+\.)\s+/u, '').trim();
-    if (clean === '') {
-      return [];
-    }
-    const first = clean
-      .split(/\s+/u)[0]
-      .toLowerCase()
-      .replace(/[^a-z]/gu, '');
-    const weak = /^(?:i|you|we|they|he|she|it|this|that|these|those|there|here)$/u;
-    if (!weak.test(first) && clean.slice(-1) !== '?') {
+    if (!this.describes(text)) {
       return [];
     }
     return [new Violation(
@@ -56,6 +49,25 @@ class Command {
       new Region(uri, line, 1)
     )];
   }
+  suppress(violation, document) {
+    if (violation.rule !== this.id) {
+      return false;
+    }
+    const lines = document.text().split('\n');
+    return !this.describes(lines[violation.spot.line() - 1] || '');
+  }
+  describes(text) {
+    const clean = text.replace(/^\s*(?:[-*+]|\d+\.)\s+/u, '').trim();
+    if (clean === '') {
+      return false;
+    }
+    const first = clean
+      .split(/\s+/u)[0]
+      .toLowerCase()
+      .replace(/[^a-z]/gu, '');
+    const weak = /^(?:i|you|we|they|he|she|it|this|that|these|those|there|here)$/u;
+    return weak.test(first) || clean.slice(-1) === '?';
+  }
 }
 
 module.exports = Command;

package/src/rules/description-triggers.js

@@ -16,6 +16,9 @@ const Region = require('../region');
  * short or that never names a trigger with the word "when". Its prompt
  * hands the deeper judgement to the AI oracle, which weighs whether the
  * description truly names the situations and phrases that activate it.
+ * A quoted example phrase is the strongest form of that naming, so a
+ * deterministic guard then vetoes any oracle flag on a description that
+ * holds both "when" and a quoted phrase, however the model rules.
  */
 class DescriptionTriggers {
   constructor() {
@@ -26,7 +29,7 @@ class DescriptionTriggers {
     return 'Name the concrete situations and user phrases that should activate the skill in its description, so the loader knows exactly when to invoke it.';
   }
   prompt() {
-    return `${this.id}: in a SKILL.md, flag a description that is too short or fails to name the concrete situations and user phrases that should activate the skill, even when it contains the word "when"`;
+    return `${this.id}: in a SKILL.md, flag a description that is too short or fails to name the concrete situations and user phrases that should activate the skill, even when it contains the word "when"; a description that quotes an example user phrase, such as "file this bug", already names a trigger in its strongest form and must never be flagged`;
   }
   violations(document) {
     const uri = document.uri();
@@ -56,6 +59,30 @@ class DescriptionTriggers {
     }
     return [];
   }
+  suppress(violation, document) {
+    if (violation.rule !== this.id) {
+      return false;
+    }
+    const value = this.description(document);
+    return /\bwhen\b/iu.test(value) && this.quoted(value);
+  }
+  description(document) {
+    const pairs = document.walk({
+      header: () => [],
+      prose: () => [],
+      snippet: () => [],
+      bullets: () => [],
+      frontmatter: (keys) => keys
+    });
+    const found = pairs.filter((pair) => pair.key === 'description');
+    if (found.length === 0) {
+      return '';
+    }
+    return found[0].value.trim();
+  }
+  quoted(value) {
+    return /["'‘’“”][^"'‘’“”]+["'‘’“”]/u.test(value);
+  }
   flag(message, row, uri) {
     return new Violation(this.id, 'warning', message, new Region(uri, row, 1));
   }

package/src/rules/no-articles.js

@@ -35,6 +35,21 @@ class NoArticles {
       frontmatter: () => []
     });
   }
+  suppress(violation, document) {
+    if (violation.rule !== this.id) {
+      return false;
+    }
+    return this.headers(document).has(violation.spot.line());
+  }
+  headers(document) {
+    return new Set(document.walk({
+      header: (text, line) => [line],
+      prose: () => [],
+      snippet: () => [],
+      bullets: () => [],
+      frontmatter: () => []
+    }));
+  }
   scan(text, line, uri) {
     const found = [];
     const masked = mask(text);

package/src/rules/positive.js

@@ -21,6 +21,10 @@ const mask = require('../mask');
  * oracle, which rewrites a prohibition with no keyword as a positive
  * command. The prompt demands an actual negation before flagging, so
  * an affirmative imperative that already states what to do stays clean.
+ * Because the model still misreads plain imperatives as bans, a
+ * deterministic guard then drops any oracle flag on a line that carries
+ * no negation token at all, so an affirmative imperative can never be
+ * reported regardless of what the model returns.
  */
 class Positive {
   constructor() {
@@ -42,6 +46,17 @@ class Positive {
       frontmatter: () => []
     });
   }
+  suppress(violation, document) {
+    if (violation.rule !== this.id) {
+      return false;
+    }
+    const lines = document.text().split('\n');
+    return !this.negated(lines[violation.spot.line() - 1] || '');
+  }
+  negated(text) {
+    const regex = /\b(?:do not|don't|never|avoid|refrain from|must not|no longer|no|not)\b/iu;
+    return regex.test(mask(text));
+  }
   scan(text, line, uri) {
     const regex = /^(?<marker>\s*(?:[-*+]|\d+\.)\s+)?(?:do not|don't|never|avoid|refrain from|must not|no longer)\b/iu;
     const hit = regex.exec(mask(text));

package/src/rules/untrusted.js

@@ -44,7 +44,7 @@ class Untrusted {
   }
   scan(text, line, uri) {
     const masked = mask(text);
-    const verb = /\b(?:read|fetch|open|follow|execute)\b/iu;
+    const verb = /(?<!-)\b(?:read|fetch|open|follow|execute)\b(?!-)/iu;
     const source = /\b(?:page|url|link|email|file|issue|output|comment)\b/iu;
     const guard = /\b(?:as data|do not follow|treat as untrusted|inside delimiters|untrusted)\b/iu;
     if (!verb.test(masked) || !source.test(masked) || guard.test(masked)) {

package/src/version.js

@@ -9,8 +9,8 @@
  * Version.
  *
  * The current release of dogent, replaced on every release by rultor.
- * The default `0.12.1` marks an unreleased build straight from source.
+ * The default `0.12.3` marks an unreleased build straight from source.
  */
-const version = '0.12.1';
+const version = '0.12.3';
 
 module.exports = version;