@yegor256/dogent 0.7.1 → 0.7.3

package/README.md

@@ -29,13 +29,7 @@ In short: `agnix` lints the harness, `dogent` lints the prompt.
 Run it on any manifesto file, no installation required:
 
 ```bash
-npx @yegor256/dogent@0.6.0 CLAUDE.md
-```
-
-Lint several files at once:
-
-```bash
-npx @yegor256/dogent SKILL.md CLAUDE.md AGENTS.md
+npx @yegor256/dogent@0.7.2 SKILL.md
 ```
 
 Point it at a directory to lint the default manifestos it holds
@@ -135,7 +129,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-      - run: npx @yegor256/dogent CLAUDE.md SKILL.md
+      - run: npx @yegor256/dogent .
 ```
 
 The job fails when `dogent` finds problems,
@@ -164,7 +158,7 @@ Reference `dogent` as a remote hook in `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/yegor256/dogent
-    rev: 0.6.0
+    rev: 0.7.2
     hooks:
       - id: dogent
 ```

package/package.json

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

package/src/markdown.js

@@ -20,9 +20,9 @@ const Yaml = require('./yaml');
  * the context of the moment (inside a fence, inside a list), and emits
  * a Document of fragments. This is a line scanner, not a grammar.
  *
- * @todo #1:45min Attach wrapped continuation lines to the bullet they
- *  belong to, instead of silently dropping their nested indentation
- *  context on the floor.
+ * A wrapped continuation line, indented under an open bullet and
+ * carrying no marker of its own, folds into the bullet it belongs to
+ * rather than breaking the list and floating off as a stray paragraph.
  */
 class Markdown {
   constructor(uri, content) {
@@ -92,6 +92,11 @@ class Markdown {
         flush();
         return;
       }
+      if (items.length > 0 && /^\s+\S/u.test(line)) {
+        const last = items[items.length - 1];
+        items[items.length - 1] = new Prose(`${last.content} ${line.trim()}`, last.row);
+        return;
+      }
       flush();
       pieces.push(new Prose(line, row));
     });

package/src/rules/atomic.js

@@ -15,19 +15,15 @@ const Region = require('../region');
  * 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.
- *
- * @todo #21:45min Upgrade to a real clause-count check through an AI
- *  oracle so that subtle multi-instruction lines, which the conservative
- *  heuristic cannot see today, are reliably caught, as requested in
- *  issue #21.
+ * subtler clause-counting to the AI oracle, which catches the
+ * multi-instruction lines that carry no such welding token.
  */
 class Atomic {
   constructor() {
     this.id = 'atomic';
   }
   prompt() {
-    return `${this.id}: flag any line that carries more than one instruction`;
+    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`;
   }
   violations(document) {
     const uri = document.uri();

package/src/rules/dead-import.js

@@ -10,6 +10,7 @@ const path = require('path');
 
 const Violation = require('../violation');
 const Region = require('../region');
+const Markdown = require('../markdown');
 
 const imports = (line) => {
   const found = [];
@@ -25,42 +26,97 @@ const imports = (line) => {
   return found;
 };
 
+const targets = (file) => {
+  const base = path.dirname(file);
+  try {
+    return new Markdown(file, fs.readFileSync(file, 'utf8'))
+      .document()
+      .walk({
+        header: () => [],
+        snippet: () => [],
+        bullets: () => [],
+        frontmatter: () => [],
+        prose: (line) => imports(line).map((item) => path.resolve(base, item.file))
+      })
+      .filter((target) => fs.existsSync(target));
+  } catch {
+    return [];
+  }
+};
+
 /**
  * DeadImport.
  *
- * Flags `@path/to/file` imports that point to no file on disk.
- *
- * @todo #18:45min Detect circular import chains and depth above five
- *  levels so deeply nested manifesto imports fail with a clear violation,
- *  as requested in issue #18.
+ * Flags `@path/to/file` imports that point to no file on disk, and
+ * walks the chain of imports that do resolve: a chain that loops back
+ * on itself, or that nests deeper than five levels, fails with a clear
+ * violation rather than looping or loading forever in the host tool.
  */
 class DeadImport {
   constructor() {
     this.id = 'dead-import';
+    this.depth = 5;
   }
   prompt() {
     return `${this.id}: flag any @path/to/file import that points to no file on disk`;
   }
   violations(document) {
-    return document.walk({
+    const uri = document.uri();
+    const base = path.dirname(uri);
+    const links = document.walk({
       header: () => [],
       snippet: () => [],
       bullets: () => [],
       frontmatter: () => [],
-      prose: (line, row) => this.missing(document.uri(), line, row)
+      prose: (line, row) => imports(line).map(
+        (item) => ({...item, target: path.resolve(base, item.file), row})
+      )
     });
+    return this.missing(uri, links).concat(this.chains(uri, links));
   }
-  missing(uri, line, row) {
-    const base = path.dirname(uri);
-    return imports(line)
-      .filter((item) => !fs.existsSync(path.resolve(base, item.file)))
-      .map((item) => new Violation(
+  missing(uri, links) {
+    return links
+      .filter((link) => !fs.existsSync(link.target))
+      .map((link) => new Violation(
         this.id,
         'error',
-        `@-import target not found: ${item.file}`,
-        new Region(uri, row, item.column)
+        `@-import target not found: ${link.file}`,
+        new Region(uri, link.row, link.column)
       ));
   }
+  chains(uri, links) {
+    const root = path.resolve(uri);
+    const found = [];
+    links
+      .filter((link) => fs.existsSync(link.target))
+      .forEach((link) => {
+        const flags = {cycle: false, deep: false};
+        this.explore([root, link.target], 1, flags);
+        if (flags.cycle) {
+          found.push(this.flag(uri, link, `@-import chain is circular via ${link.file}`));
+        }
+        if (flags.deep) {
+          found.push(this.flag(uri, link, `@-import chain nests deeper than ${this.depth} levels via ${link.file}`));
+        }
+      });
+    return found;
+  }
+  explore(stack, depth, flags) {
+    if (depth > this.depth) {
+      flags.deep = true;
+      return;
+    }
+    targets(stack[stack.length - 1]).forEach((target) => {
+      if (stack.includes(target)) {
+        flags.cycle = true;
+        return;
+      }
+      this.explore(stack.concat(target), depth + 1, flags);
+    });
+  }
+  flag(uri, link, message) {
+    return new Violation(this.id, 'error', message, new Region(uri, link.row, link.column));
+  }
 }
 
 module.exports = DeadImport;

package/src/rules/description-triggers.js

@@ -14,11 +14,8 @@ const Region = require('../region');
  * Demands that a SKILL.md description say when to use the skill. A
  * standalone checker can only approximate: it flags a value that is too
  * short or that never names a trigger with the word "when". Its prompt
- * hands the deeper judgement to the AI oracle.
- *
- * @todo #19:30min Upgrade the trigger check to an AI oracle that judges
- *  whether the description truly names the situations and user phrases
- *  that should activate the skill, as requested in issue #19.
+ * hands the deeper judgement to the AI oracle, which weighs whether the
+ * description truly names the situations and phrases that activate it.
  */
 class DescriptionTriggers {
   constructor() {
@@ -26,7 +23,7 @@ class DescriptionTriggers {
     this.minimum = 20;
   }
   prompt() {
-    return `${this.id}: in a SKILL.md, flag a description that is too short or never says when to use the skill`;
+    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"`;
   }
   violations(document) {
     const uri = document.uri();

package/src/rules/hedging.js

@@ -13,19 +13,16 @@ const Region = require('../region');
  *
  * Flags soft, non-committal, or hedging wording that weakens an order.
  * Catches words like "should", "just", "usually", and phrases like
- * "try to" or "if possible", each a sign of timid instruction.
- *
- * @todo #22:30min Upgrade to an AI oracle that catches subtler hedging,
- *  such as conditional escape hatches and vague scope, which the fixed
- *  blacklist of hedge words cannot detect today, as requested in
- *  issue #22.
+ * "try to" or "if possible", each a sign of timid instruction. Its
+ * prompt hands subtler hedging to the AI oracle, which catches the
+ * conditional escape hatches and vague scope no fixed list can.
  */
 class Hedging {
   constructor() {
     this.id = 'hedging';
   }
   prompt() {
-    return `${this.id}: flag soft, non-committal, or hedging wording`;
+    return `${this.id}: flag soft, non-committal, or hedging wording, including conditional escape hatches and vague scope that carry no fixed hedge word`;
   }
   violations(document) {
     const uri = document.uri();

package/src/rules/passive.js

@@ -13,19 +13,16 @@ const Region = require('../region');
  *
  * Demands active imperative voice. A standalone checker can only guess:
  * it flags a "be" verb followed, perhaps through an adverb, by a past
- * participle, the surest mark of passive voice.
- *
- * @todo #24:45min Upgrade to an AI oracle for accurate passive-voice
- *  detection, since the regular-expression heuristic both misses many
- *  irregular participles and cannot judge true grammatical voice, as
- *  requested in issue #24.
+ * participle, the surest mark of passive voice. Its prompt hands true
+ * grammatical-voice judgement to the AI oracle, which catches the
+ * irregular participles the regular expression misses.
  */
 class Passive {
   constructor() {
     this.id = 'passive';
   }
   prompt() {
-    return `${this.id}: flag any instruction written in passive voice`;
+    return `${this.id}: flag any instruction written in passive voice, judging true grammatical voice including irregular past participles a fixed pattern misses`;
   }
   violations(document) {
     const uri = document.uri();

package/src/rules/redundant.js

@@ -44,14 +44,10 @@ const PHRASES = [
  * Flags a line that restates default model behavior, like
  * "Be helpful and accurate" or "Write clean code". Such filler
  * burns the context budget and drowns the project-specific
- * guidance the manifesto exists to carry.
- *
- * @todo #15:60min Promote the standalone heuristic into a
- *  proper AI-oracle check when `OPENAI_API_KEY` is present, so
- *  redundancy detection covers paraphrases beyond the curated
- *  blacklist below. The hybrid pattern from `src/rules/command.js`
- *  is the model: keep the deterministic check as the default,
- *  let the oracle catch the rest.
+ * guidance the manifesto exists to carry. Following the hybrid
+ * pattern of `command.js`, the curated blacklist below stays the
+ * deterministic default and the prompt hands paraphrases beyond
+ * that list to the AI oracle.
  */
 class Redundant {
   constructor(phrases = PHRASES) {
@@ -59,7 +55,7 @@ class Redundant {
     this.phrases = phrases;
   }
   prompt() {
-    return `${this.id}: flag any line that restates default agent behavior already known to the model, not a project-specific instruction`;
+    return `${this.id}: flag any line that restates default agent behavior already known to the model, not a project-specific instruction, including reworded paraphrases that match no fixed phrase list`;
   }
   violations(document) {
     const uri = document.uri();

package/src/rules/simple.js

@@ -13,19 +13,15 @@ const Region = require('../region');
  *
  * 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.
- *
- * @todo #29:45min Upgrade to true clause-depth analysis through an AI
- *  oracle so that subtle tangled instructions, which the comma and
- *  conjunction heuristic cannot measure today, are reliably caught, as
- *  requested in issue #29.
+ * clauses. Its prompt hands the subtler tangle judgement to the oracle,
+ * which weighs true clause depth rather than counting punctuation.
  */
 class Simple {
   constructor() {
     this.id = 'simple';
   }
   prompt() {
-    return `${this.id}: flag any grammatically tangled, multi-clause instruction`;
+    return `${this.id}: flag any grammatically tangled, multi-clause instruction, judging true clause depth even when the line carries few commas or conjunctions`;
   }
   violations(document) {
     const uri = document.uri();

package/src/rules/unique.js

@@ -23,18 +23,16 @@ const normalize = (text) => {
  *
  * Flags any instruction that repeats another instruction in the file.
  * It normalizes each prose line, then remembers the first line where
- * each normal form appeared, so a later twin earns one violation.
- *
- * @todo #25:45min Upgrade to semantic near-duplicate detection through
- *  embeddings or an AI oracle, to catch same-meaning different-words
- *  pairs the normalizer misses, as requested in issue #25.
+ * each normal form appeared, so a later twin earns one violation. Its
+ * prompt hands semantic near-duplicates to the AI oracle, catching
+ * same-meaning different-words pairs the normalizer misses.
  */
 class Unique {
   constructor() {
     this.id = 'unique';
   }
   prompt() {
-    return `${this.id}: flag any instruction that repeats another instruction in the file`;
+    return `${this.id}: flag any instruction that repeats another instruction in the file, including two lines that carry the same meaning in different words, not only lines matching after normalized case, punctuation, and word order`;
   }
   violations(document) {
     const uri = document.uri();

package/src/yaml.js

@@ -10,8 +10,9 @@
  *
  * A frontmatter block read as a flat YAML mapping. Splits itself line by
  * line and emits one pair per top-level "key: value", carrying the key,
- * the value, and the absolute line the key sits on. Nested mappings,
- * blank lines, and comments hold no keys and yield nothing.
+ * the value, and the absolute line the key sits on. Folds a block scalar
+ * value ("|" or ">") from its indented continuation lines into one value.
+ * Nested mappings, blank lines, and comments hold no keys and yield nothing.
  */
 class Yaml {
   constructor(text, base) {
@@ -19,18 +20,30 @@ class Yaml {
     this.base = base;
   }
   pairs() {
-    return this.text
-      .split('\n')
-      .map((line, index) => ({line, row: this.base + index}))
-      .filter((spot) => /^[^\s#][^:]*:/u.test(spot.line))
-      .map((spot) => {
-        const colon = spot.line.indexOf(':');
-        return {
-          key: spot.line.slice(0, colon).trim(),
-          value: spot.line.slice(colon + 1).trim(),
-          row: spot.row
-        };
-      });
+    const lines = this.text.split('\n');
+    return lines
+      .map((line, index) => index)
+      .filter((index) => /^[^\s#][^:]*:/u.test(lines[index]))
+      .map((index) => this.pair(lines, index));
+  }
+  pair(lines, index) {
+    const colon = lines[index].indexOf(':');
+    const value = lines[index].slice(colon + 1).trim();
+    return {
+      key: lines[index].slice(0, colon).trim(),
+      value: /^[|>][+-]?\d*$/u.test(value) ? Yaml.fold(lines, index) : value,
+      row: this.base + index
+    };
+  }
+  static fold(lines, index) {
+    const rest = lines.slice(index + 1);
+    const stop = rest.findIndex((line) => line.trim() !== '' && !/^\s/u.test(line));
+    const end = stop === -1 ? rest.length : stop;
+    return rest
+      .slice(0, end)
+      .map((line) => line.trim())
+      .join(' ')
+      .trim();
   }
 }