@yegor256/dogent 0.9.0 → 0.10.0

package/src/rules/terms.js

@@ -0,0 +1,77 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+ * SPDX-License-Identifier: MIT
+ */
+
+'use strict';
+
+const Violation = require('../violation');
+const Region = require('../region');
+const mask = require('../mask');
+
+/**
+ * Terms.
+ *
+ * Flags synonym drift: one concept named several ways across a file.
+ * Where consistent hunts word-for-word duplicates and contradictions,
+ * this rule catches the same idea wearing different labels, which makes
+ * the agent guess whether two names mean two things. A small built-in
+ * map of synonym groups seeds the deterministic check; the broader,
+ * fuzzier judgement is handed to the AI oracle through prompt().
+ */
+class Terms {
+  constructor() {
+    this.id = 'terms';
+    this.groups = [
+      ['agent', 'assistant', 'bot'],
+      ['directory', 'folder'],
+      ['parameter', 'argument', 'param', 'arg'],
+      ['function', 'method', 'routine']
+    ];
+  }
+  prompt() {
+    return `${this.id}: flag any pair of words used interchangeably for one concept, and demand a single canonical term across the whole file`;
+  }
+  violations(document) {
+    const uri = document.uri();
+    const seen = this.groups.map(() => new Map());
+    document.walk({
+      header: () => [],
+      prose: (text, line) => this.collect(text, line, seen),
+      snippet: () => [],
+      bullets: () => [],
+      frontmatter: () => []
+    });
+    return this.report(seen, uri);
+  }
+  collect(text, line, seen) {
+    const masked = mask(text);
+    this.groups.forEach((group, index) => {
+      group.forEach((word) => {
+        const regex = new RegExp(`\\b${word}\\b`, 'iu');
+        if (regex.test(masked) && !seen[index].has(word)) {
+          seen[index].set(word, line);
+        }
+      });
+    });
+    return [];
+  }
+  report(seen, uri) {
+    const found = [];
+    seen.forEach((members) => {
+      if (members.size >= 2) {
+        const names = Array.from(members.keys());
+        const lines = Array.from(members.values());
+        found.push(new Violation(
+          this.id,
+          'warning',
+          `concept named two ways ("${names[0]}"/"${names[1]}"), pick one term`,
+          new Region(uri, lines[1], 1)
+        ));
+      }
+    });
+    return found;
+  }
+}
+
+module.exports = Terms;

package/src/rules/tool-clarity.js

@@ -0,0 +1,61 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+ * SPDX-License-Identifier: MIT
+ */
+
+'use strict';
+
+const Violation = require('../violation');
+const Region = require('../region');
+const mask = require('../mask');
+
+/**
+ * ToolClarity.
+ *
+ * Demands the exact name of a tool or command, never a bare generic
+ * noun. An action verb such as "run", "use", or "invoke" pointed at
+ * "the script" or "a command" leaves the agent guessing which one. The
+ * mask blanks backticked spans first, so "run `npm test`" passes while
+ * "run the script" gets flagged. Its prompt defers subtler vague
+ * references to the AI oracle.
+ */
+class ToolClarity {
+  constructor() {
+    this.id = 'tool-clarity';
+  }
+  prompt() {
+    return `${this.id}: flag any vague reference to a tool or command beyond the fixed list, and demand the exact name, path, or invocation instead`;
+  }
+  violations(document) {
+    const uri = document.uri();
+    return document.walk({
+      header: () => [],
+      prose: (text, line) => this.scan(text, line, uri),
+      snippet: () => [],
+      bullets: () => [],
+      frontmatter: () => []
+    });
+  }
+  scan(text, line, uri) {
+    const found = [];
+    const regex = new RegExp(
+      '\\b(?:run|use|call|invoke|execute|open)\\s+(?:the|a|an)\\s+' +
+      '(?:script|tool|command|api|file|function)\\b',
+      'giu'
+    );
+    const masked = mask(text);
+    let hit = regex.exec(masked);
+    while (hit !== null) {
+      found.push(new Violation(
+        this.id,
+        'warning',
+        `name the exact tool or command, not "${hit[0]}"`,
+        new Region(uri, line, hit.index + 1)
+      ));
+      hit = regex.exec(masked);
+    }
+    return found;
+  }
+}
+
+module.exports = ToolClarity;

package/src/rules/untrusted.js

@@ -0,0 +1,59 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+ * SPDX-License-Identifier: MIT
+ */
+
+'use strict';
+
+const Violation = require('../violation');
+const Region = require('../region');
+const mask = require('../mask');
+
+/**
+ * Untrusted.
+ *
+ * Guards against indirect prompt injection. When a line tells the agent
+ * to act on external content — a verb like "read", "fetch", "open",
+ * "follow", or "execute" applied to a "page", "url", "link", "email",
+ * "file", "issue", "output", or "comment" — that content can carry
+ * hidden instructions the agent then obeys. A standalone checker flags
+ * such a line when it lacks a data-only guard ("as data", "do not
+ * follow", "treat as untrusted", "inside delimiters"). Its prompt hands
+ * the deeper judgement of source trust and guard sufficiency to the AI
+ * oracle.
+ */
+class Untrusted {
+  constructor() {
+    this.id = 'untrusted';
+  }
+  prompt() {
+    return `${this.id}: judge whether a consumed source is genuinely untrusted external input and whether its data-only guard is sufficient against prompt injection`;
+  }
+  violations(document) {
+    const uri = document.uri();
+    return document.walk({
+      header: () => [],
+      prose: (text, line) => this.scan(text, line, uri),
+      snippet: () => [],
+      bullets: () => [],
+      frontmatter: () => []
+    });
+  }
+  scan(text, line, uri) {
+    const masked = mask(text);
+    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)) {
+      return [];
+    }
+    return [new Violation(
+      this.id,
+      'warning',
+      'untrusted input consumed without a data-only guard',
+      new Region(uri, line, 1)
+    )];
+  }
+}
+
+module.exports = Untrusted;

package/src/rules/vague.js

@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+ * SPDX-License-Identifier: MIT
+ */
+
+'use strict';
+
+const Violation = require('../violation');
+const Region = require('../region');
+const mask = require('../mask');
+
+/**
+ * Vague.
+ *
+ * Flags subjective, unmeasurable qualifiers that pretend to be precise:
+ * "properly", "good", "clean", "fast", "robust", and the like. Each
+ * leaves the agent to guess a criterion that varies run to run, so a
+ * vague qualifier is a non-instruction in disguise. The list is kept
+ * apart from the hedging words so the two rules never double-report. Its
+ * prompt hands subjective adjectives outside the fixed list to the AI
+ * oracle, asking it to suggest a concrete, checkable threshold.
+ */
+class Vague {
+  constructor() {
+    this.id = 'vague';
+  }
+  prompt() {
+    return `${this.id}: flag any subjective or unmeasurable qualifier beyond the fixed list, and propose a concrete, checkable threshold to replace it`;
+  }
+  violations(document) {
+    const uri = document.uri();
+    return document.walk({
+      header: () => [],
+      prose: (text, line) => this.scan(text, line, uri),
+      snippet: () => [],
+      bullets: () => [],
+      frontmatter: () => []
+    });
+  }
+  scan(text, line, uri) {
+    const found = [];
+    const regex = new RegExp(
+      '\\b(?:properly|correctly|appropriately|good|clean|fast|slow|' +
+      'large|small|robust|reasonable|efficient|as much as possible|' +
+      'if needed)\\b',
+      'giu'
+    );
+    const masked = mask(text);
+    let hit = regex.exec(masked);
+    while (hit !== null) {
+      found.push(new Violation(
+        this.id,
+        'warning',
+        `vague qualifier "${hit[0]}" carries no measurable criterion`,
+        new Region(uri, line, hit.index + 1)
+      ));
+      hit = regex.exec(masked);
+    }
+    return found;
+  }
+}
+
+module.exports = Vague;

package/src/version.js

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