vigiles 12.6.0 → 12.8.0

package/dist/segment.js

@@ -0,0 +1,454 @@
+"use strict";
+/**
+ * segment.ts — Tier-A deterministic (no-model) segmenter.
+ *
+ * Splits a CLAUDE.md / AGENTS.md into ATOMIC candidate rules with provenance.
+ * Pure, deterministic, strict TS, no external deps.
+ *
+ * Design bias: PRECISION over recall. A missed rule costs a row; a garbage
+ * atom costs credibility. When in doubt we UNDER-split and REJECT.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segmentInstructions = segmentInstructions;
+// --- Heuristic vocabulary --------------------------------------------------
+/** Imperative/prohibitive head the candidate must START with (form cue). */
+const FORM_HEAD = /^(?:use|avoid|prefer|never|always|don'?t|do not|no\s+\S|must|should|keep|run|write|add|remove|only)\b/i;
+/** Rule-ish heading gate for prose-under-heading candidacy. */
+const RULE_HEADING = /rules?|conventions?|style|guidelines?|standards?|do(?:n'?ts?)?s?|never|always|must|require/i;
+/** Declarative subjects — these signal a statement, not an instruction. */
+const DECLARATION = /^(?:this|these|those|it|we|our|there)\b/i;
+/** Line consisting only of a bare URL. */
+const URL_ONLY = /^<?https?:\/\/\S+>?$/;
+/** Line consisting only of a markdown link. */
+const LINK_ONLY = /^\[[^\]]*\]\([^)]*\)$/;
+/** Verb-ish lexicon (secondary shape signal). Kept curated for precision. */
+const VERBS = new Set([
+    "use",
+    "uses",
+    "using",
+    "used",
+    "avoid",
+    "avoids",
+    "prefer",
+    "prefers",
+    "run",
+    "runs",
+    "write",
+    "writes",
+    "writing",
+    "add",
+    "adds",
+    "remove",
+    "removes",
+    "keep",
+    "keeps",
+    "import",
+    "imports",
+    "importing",
+    "split",
+    "splits",
+    "push",
+    "pushes",
+    "commit",
+    "commits",
+    "test",
+    "tests",
+    "call",
+    "calls",
+    "set",
+    "sets",
+    "make",
+    "makes",
+    "create",
+    "creates",
+    "delete",
+    "deletes",
+    "update",
+    "updates",
+    "check",
+    "checks",
+    "ensure",
+    "ensures",
+    "document",
+    "documents",
+    "follow",
+    "follows",
+    "handle",
+    "handles",
+    "return",
+    "returns",
+    "throw",
+    "throws",
+    "catch",
+    "log",
+    "logs",
+    "prefix",
+    "name",
+    "names",
+    "store",
+    "stores",
+    "read",
+    "reads",
+    "save",
+    "saves",
+    "wrap",
+    "wraps",
+    "escape",
+    "escapes",
+    "match",
+    "matches",
+    "filter",
+    "filters",
+    "merge",
+    "merges",
+    "be",
+    "is",
+    "are",
+    "have",
+    "has",
+    "may",
+    "should",
+    "must",
+    "pin",
+    "pins",
+    "lint",
+    "format",
+    "formats",
+    "sort",
+    "group",
+    "groups",
+    "export",
+    "exports",
+    "mock",
+    "stub",
+    "assert",
+    "validate",
+    "validates",
+    "sanitize",
+    "encode",
+    "decode",
+    "hash",
+    "sign",
+    "verify",
+    "verifies",
+    "expose",
+    "hide",
+    "close",
+    "open",
+    "load",
+    "loads",
+    "fetch",
+    "fetches",
+    "render",
+    "renders",
+    "mount",
+    "bind",
+    "inject",
+    "register",
+    "resolve",
+    "reject",
+    "await",
+    "apply",
+    "applies",
+    "bump",
+    "tag",
+    "branch",
+    "rebase",
+    "squash",
+    "enforce",
+    "enforces",
+    "define",
+    "defines",
+    "declare",
+    "place",
+    "put",
+    "prefer",
+]);
+// --- Offset / line utilities ----------------------------------------------
+function computeLineOffsets(lines) {
+    const offsets = new Array(lines.length);
+    let acc = 0;
+    for (let i = 0; i < lines.length; i++) {
+        offsets[i] = acc;
+        acc += lines[i].length + 1; // +1 for the '\n' consumed by split
+    }
+    return offsets;
+}
+function offsetToLine(lineOffsets, off) {
+    // 1-based line number containing char offset `off`.
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    let ans = 0;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (lineOffsets[mid] <= off) {
+            ans = mid;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return ans + 1;
+}
+function normalize(s) {
+    return s.replace(/\s+/g, " ").trim();
+}
+function hasVerbish(text) {
+    const tokens = text
+        .toLowerCase()
+        .replace(/`[^`]*`/g, " ") // drop inline code spans
+        .split(/[^a-z']+/)
+        .filter(Boolean);
+    for (const t of tokens) {
+        if (VERBS.has(t))
+            return true;
+    }
+    return false;
+}
+function isLinkOnly(text) {
+    const t = text.trim();
+    return URL_ONLY.test(t) || LINK_ONLY.test(t);
+}
+/**
+ * Score the 3 cues. Returns confidence or null (reject).
+ * - form: starts with an imperative/prohibitive head (or "No X").
+ * - context: is a bullet OR sits under a rule-ish heading.
+ * - shape: 15–300 chars, has a verb-ish token, not link-only, not a declaration.
+ */
+function gate(text, isBullet, underRuleHeading) {
+    const t = text.trim();
+    const form = FORM_HEAD.test(t);
+    const context = isBullet || underRuleHeading;
+    const shape = t.length >= 15 &&
+        t.length <= 300 &&
+        hasVerbish(t) &&
+        !isLinkOnly(t) &&
+        !DECLARATION.test(t);
+    const cues = (form ? 1 : 0) + (context ? 1 : 0) + (shape ? 1 : 0);
+    if (cues >= 3)
+        return "high";
+    if (cues === 2)
+        return "medium";
+    return null;
+}
+// --- Atomicity split -------------------------------------------------------
+/** Never split when an exception clause carries polarity/meaning. */
+const HAS_EXCEPT = /\bexcept\b/i;
+function trimSpan(src, span) {
+    let { start, end } = span;
+    while (start < end && /\s/.test(src[start]))
+        start++;
+    while (end > start && /\s/.test(src[end - 1]))
+        end--;
+    return { start, end };
+}
+/**
+ * Try to split a single-line bullet's content span on ';' or sentence
+ * boundaries. Returns the resulting spans ONLY IF there is >1 and every
+ * piece independently passes the gate; otherwise returns [whole].
+ */
+function atomize(src, contentSpan, isBullet, underRuleHeading) {
+    const whole = trimSpan(src, contentSpan);
+    const wholeText = src.slice(whole.start, whole.end);
+    if (HAS_EXCEPT.test(wholeText))
+        return [whole];
+    // Candidate cut points: ';' and sentence terminators followed by a capital.
+    const cuts = [];
+    for (let i = whole.start; i < whole.end; i++) {
+        const c = src[i];
+        if (c === ";") {
+            cuts.push(i + 1);
+        }
+        else if (c === "." || c === "!" || c === "?") {
+            // sentence boundary: terminator + whitespace + capital letter
+            const rest = src.slice(i + 1, whole.end);
+            const m = /^\s+[A-Z]/.exec(rest);
+            if (m)
+                cuts.push(i + 1);
+        }
+    }
+    if (cuts.length === 0)
+        return [whole];
+    const bounds = [whole.start, ...cuts, whole.end];
+    const pieces = [];
+    for (let i = 0; i < bounds.length - 1; i++) {
+        const piece = trimSpan(src, { start: bounds[i], end: bounds[i + 1] });
+        // strip a leading semicolon left by the cut
+        while (piece.start < piece.end &&
+            (src[piece.start] === ";" || /\s/.test(src[piece.start]))) {
+            piece.start++;
+        }
+        if (piece.start >= piece.end)
+            return [whole];
+        pieces.push(piece);
+    }
+    // Both/all halves must independently pass the gate, else keep whole.
+    for (const p of pieces) {
+        const text = normalize(src.slice(p.start, p.end));
+        if (gate(text, isBullet, underRuleHeading) === null)
+            return [whole];
+    }
+    return pieces.length > 1 ? pieces : [whole];
+}
+// --- Emission --------------------------------------------------------------
+function emitFromSpan(src, lineOffsets, file, span, confidence) {
+    const exactQuote = src.slice(span.start, span.end);
+    return {
+        text: normalize(exactQuote),
+        file,
+        lineStart: offsetToLine(lineOffsets, span.start),
+        lineEnd: offsetToLine(lineOffsets, span.end - 1),
+        exactQuote,
+        confidence,
+    };
+}
+// --- Scanner ---------------------------------------------------------------
+const LIST_ITEM = /^(\s*)([-*+])(\s+)(.*)$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const FENCE = /^\s*(```|~~~)/;
+const TABLE_LINE = /^\s*\|/;
+/**
+ * Split a CLAUDE.md / AGENTS.md into atomic candidate rules with provenance.
+ *
+ * Deterministic Tier-A heuristic. Code fences and tables are excluded from
+ * candidacy. Candidate units are (a) list items with attached continuation
+ * lines and (b) sentences of paragraphs under a rule-ish heading.
+ */
+function segmentInstructions(markdown, file) {
+    const lines = markdown.split("\n");
+    const lineOffsets = computeLineOffsets(lines);
+    const out = [];
+    let inFence = false;
+    let currentHeadingIsRuleish = false;
+    let i = 0;
+    const lineSpan = (a, b) => ({
+        start: lineOffsets[a],
+        end: lineOffsets[b] + lines[b].length,
+    });
+    while (i < lines.length) {
+        const line = lines[i];
+        // Code fences: toggle and skip everything inside (incl. the fence lines).
+        if (FENCE.test(line)) {
+            inFence = !inFence;
+            i++;
+            continue;
+        }
+        if (inFence) {
+            i++;
+            continue;
+        }
+        // Headings: update rule-ish context, not a candidate.
+        const h = HEADING.exec(line);
+        if (h) {
+            currentHeadingIsRuleish = RULE_HEADING.test(h[2]);
+            i++;
+            continue;
+        }
+        // Tables: excluded from candidacy.
+        if (TABLE_LINE.test(line)) {
+            i++;
+            continue;
+        }
+        // List items (with attached continuation lines).
+        const li = LIST_ITEM.exec(line);
+        if (li) {
+            const markerIndent = li[1].length;
+            const contentCol = li[1].length + li[2].length + li[3].length;
+            const startLine = i;
+            // Gather continuation lines: deeper-indented, non-blank, not a new
+            // list marker, not a heading, not a fence.
+            let endLine = i;
+            let j = i + 1;
+            while (j < lines.length) {
+                const cand = lines[j];
+                if (cand.trim() === "")
+                    break;
+                if (FENCE.test(cand))
+                    break;
+                if (HEADING.test(cand))
+                    break;
+                const indent = cand.length - cand.trimStart().length;
+                if (indent <= markerIndent)
+                    break;
+                if (LIST_ITEM.test(cand))
+                    break; // nested/sibling bullet => separate candidate
+                endLine = j;
+                j++;
+            }
+            const multiLine = endLine > startLine;
+            const contentStart = lineOffsets[startLine] + contentCol;
+            const contentEnd = lineOffsets[endLine] + lines[endLine].length;
+            const contentSpan = { start: contentStart, end: contentEnd };
+            const wholeText = normalize(markdown.slice(contentStart, contentEnd));
+            const conf = gate(wholeText, true, currentHeadingIsRuleish);
+            if (conf !== null) {
+                // Only attempt splitting for single-line items (keeps offsets exact).
+                const spans = multiLine
+                    ? [trimSpan(markdown, contentSpan)]
+                    : atomize(markdown, contentSpan, true, currentHeadingIsRuleish);
+                if (spans.length === 1) {
+                    // Emit whole item; exactQuote is the full source span incl. marker.
+                    out.push(emitFromSpan(markdown, lineOffsets, file, lineSpan(startLine, endLine), conf));
+                }
+                else {
+                    for (const s of spans) {
+                        const text = normalize(markdown.slice(s.start, s.end));
+                        const c = gate(text, true, currentHeadingIsRuleish);
+                        if (c !== null)
+                            out.push(emitFromSpan(markdown, lineOffsets, file, s, c));
+                    }
+                }
+            }
+            i = endLine + 1;
+            continue;
+        }
+        // Paragraph block: accumulate until blank / heading / list / fence / table.
+        if (line.trim() !== "") {
+            const startLine = i;
+            let endLine = i;
+            let j = i + 1;
+            while (j < lines.length) {
+                const cand = lines[j];
+                if (cand.trim() === "")
+                    break;
+                if (FENCE.test(cand))
+                    break;
+                if (HEADING.test(cand))
+                    break;
+                if (LIST_ITEM.test(cand))
+                    break;
+                if (TABLE_LINE.test(cand))
+                    break;
+                endLine = j;
+                j++;
+            }
+            // Prose is only a candidate under a rule-ish heading.
+            if (currentHeadingIsRuleish) {
+                const paraStart = lineOffsets[startLine];
+                const paraEnd = lineOffsets[endLine] + lines[endLine].length;
+                const paraText = markdown.slice(paraStart, paraEnd);
+                // Sentence spans preserving absolute offsets.
+                const re = /[^.!?]+[.!?]+(\s|$)|[^.!?]+$/g;
+                let m;
+                while ((m = re.exec(paraText)) !== null) {
+                    const s = trimSpan(markdown, {
+                        start: paraStart + m.index,
+                        end: paraStart + m.index + m[0].length,
+                    });
+                    if (s.start >= s.end)
+                        continue;
+                    const text = normalize(markdown.slice(s.start, s.end));
+                    const c = gate(text, false, true);
+                    if (c !== null)
+                        out.push(emitFromSpan(markdown, lineOffsets, file, s, c));
+                }
+            }
+            i = endLine + 1;
+            continue;
+        }
+        i++;
+    }
+    return out;
+}
+//# sourceMappingURL=segment.js.map

package/dist/test-coverage.js

@@ -86,6 +86,22 @@ function discoverSkills(basePath, ignore, layout) {
             ignored: content.includes(IGNORE_MARKER),
         });
     }
+    // Single-skill-directory target: a bare `SKILL.md` AT the base (the dir you
+    // pointed lint/audit at). The globs above only match `<skillDir>/*/SKILL.md`
+    // NESTED under the base, so without this the untested-skill check would silently
+    // vanish for exactly the single-skill target that scoping now supports.
+    const rootSkill = (0, node_path_1.join)(basePath, "SKILL.md");
+    if ((0, node_fs_1.existsSync)(rootSkill)) {
+        const name = (0, node_path_1.basename)(basePath);
+        const content = read(rootSkill);
+        out.push({
+            kind: "skill",
+            path: "SKILL.md",
+            name,
+            tokens: [`${layout.skillDir}/${name}`, `:${name}`],
+            ignored: content.includes(IGNORE_MARKER),
+        });
+    }
     return out;
 }
 function discoverAgents(basePath, ignore, layout) {
@@ -171,7 +187,13 @@ function discoverTests(basePath, globs, ignore) {
 /** Colocated: a test inside a skill dir, or a name-prefixed sibling of an agent/hook. */
 function isColocated(surface, testPath) {
     if (surface.kind === "skill") {
-        return testPath.startsWith(`${(0, node_path_1.dirname)(surface.path)}/`);
+        const dir = (0, node_path_1.dirname)(surface.path);
+        // A root `SKILL.md` (single-skill-dir target) lives at ".", so any TOP-LEVEL
+        // test is colocated — globSync returns those without a "./" prefix, which a
+        // bare `startsWith("./")` would miss (false "untested").
+        return dir === "."
+            ? (0, node_path_1.dirname)(testPath) === "."
+            : testPath.startsWith(`${dir}/`);
     }
     return ((0, node_path_1.dirname)(testPath) === (0, node_path_1.dirname)(surface.path) &&
         (0, node_path_1.basename)(testPath).startsWith(`${surface.name}.`));
@@ -223,10 +245,14 @@ function findUntestedSurfaces(options = {}) {
 }
 /** Suggested colocated test path for an untested surface (shown in the warning). */
 function suggestedTestPath(surface) {
+    // A root skill lives at ".", so drop the "./" prefix — the suggested path then
+    // matches what globSync actually discovers at the top level.
+    const dir = (0, node_path_1.dirname)(surface.path);
+    const prefix = dir === "." ? "" : `${dir}/`;
     if (surface.kind === "skill") {
-        return `${(0, node_path_1.dirname)(surface.path)}/${surface.name}.eval.mjs`;
+        return `${prefix}${surface.name}.eval.mjs`;
     }
-    return `${(0, node_path_1.dirname)(surface.path)}/${surface.name}.harness.mjs`;
+    return `${prefix}${surface.name}.harness.mjs`;
 }
 /** Format an untested-surface report as human-readable text. */
 function formatUntestedReport(report) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "12.6.0",
+  "version": "12.8.0",
   "description": "Lint & test the harness your AI agent runs on — verify the references in your CLAUDE.md / AGENTS.md and test that your hooks and skills actually work.",
   "keywords": [
     "claude-code",