vigiles 32.1.0 → 33.0.0

package/dist/source-kinds.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * What a file in a vigiles-owned source directory IS — decided in ONE place.
+ *
+ * `.vigiles/hooks/` and `.vigiles/providers/` hold several kinds of file side by
+ * side: the programs `vigiles compile` turns into wiring, the tests that exercise
+ * them, type declarations, and the `.json` stamp `compile` writes next to each
+ * hook. Discovery used to ask "does it end in a runnable extension?" and treat
+ * every yes as a hook (#278): a `task-list-nudge.harness.mjs` beside its
+ * `task-list-nudge.hook.ts` was compiled as a hook and failed the build. The
+ * obvious patch — subtract the names that bit (`.harness.`, `.test.`) — is a list
+ * of what a hook is NOT, and a list of that kind is open: the next helper file
+ * somebody colocates is the next report.
+ *
+ * So a hook is defined by what it IS. A file's kind comes from ONE marker, the
+ * LAST dot-separated segment before the extension (`guard.hook.mjs` → `hook`),
+ * looked up in ONE table ({@link MARKERS}). Because exactly one segment decides,
+ * a name has exactly one kind; because the table is closed, every consumer can
+ * `switch` over {@link SourceKind} exhaustively and the compiler names the next
+ * one that forgets a case. A runnable file whose marker is not in the table is
+ * `unclaimed` — a kind of its own, not an absence — so a renamed-away hook is a
+ * reported fact rather than a silent hole.
+ *
+ * The patterns test discovery uses (`vigiles test`, `vigiles eval`, the coverage
+ * defaults, the browser twin) are DERIVED from the same table. They used to be
+ * five hand-kept copies of one fact: `*.harness.*` and `*.eval.*` are tests.
+ *
+ * Pure and import-free on purpose. `hook-install.ts` imports this and is reached
+ * from the hook runtime, where every module is a per-call cost, and the browser
+ * twin of coverage detection needs it too — nothing here may touch `node:*`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dirName = exports.baseName = exports.DEFAULT_TEST_GLOBS = exports.RUNNABLE_EXTS = void 0;
+exports.classifySource = classifySource;
+exports.isEvalScript = isEvalScript;
+exports.isVigilesTest = isVigilesTest;
+exports.testGlob = testGlob;
+exports.markedName = markedName;
+exports.preMarkerName = preMarkerName;
+/**
+ * Every extension Node executes directly. `.mts`/`.cts` are real (TS 4.7+) and
+ * Node 22 strips their types with no toolchain — measured, not assumed.
+ */
+exports.RUNNABLE_EXTS = ["mjs", "cjs", "js", "mts", "cts", "ts"];
+/**
+ * The marker table: the LAST dot-segment before the extension → its kind.
+ * Adding a kind of file means adding a row here and handling the new
+ * {@link SourceKind} member in each consumer's `switch`.
+ */
+const MARKERS = [
+    { infix: "hook", kind: { kind: "hook" } },
+    { infix: "provider", kind: { kind: "provider" } },
+    { infix: "harness", kind: { kind: "vigiles-test", test: "harness" } },
+    { infix: "eval", kind: { kind: "vigiles-test", test: "eval" } },
+];
+/**
+ * The tiers a vigiles test can belong to, read off {@link MARKERS}. A tier is
+ * also its own infix (`guard.eval.mjs` is tier `eval`): `source-kinds.test.ts`
+ * asserts that for every tier, so a row that broke it fails there.
+ */
+const TEST_TIERS = MARKERS.flatMap((m) => m.kind.kind === "vigiles-test" ? [m.kind.test] : []);
+const EXT_ALT = exports.RUNNABLE_EXTS.join("|");
+const DECLARATION = /\.d\.(?:ts|mts|cts)$/;
+const STAMP = new RegExp(`\\.(?:${EXT_ALT})\\.json$`);
+/**
+ * `<stem>.<infix>.<ext>`, the infix being the LAST segment before the extension.
+ * The stem may be empty (`.harness.mjs`): the runner's glob matches that, so the
+ * classifier must too; {@link classifySource} decides which kinds may go without
+ * one. `[\\s\\S]`, not `.`: `.` stops at a newline, and a name with one in it
+ * used to fall out of every kind and be dropped without a word.
+ */
+const MARKED = new RegExp(`^([\\s\\S]*)\\.([^.]+)\\.(?:${EXT_ALT})$`);
+const RUNNABLE = new RegExp(`^[\\s\\S]+\\.(?:${EXT_ALT})$`);
+const UNCLAIMED = { kind: "unclaimed" };
+/**
+ * The kind of a file, from its BASENAME. Total: every string has an answer, and
+ * the answer is one member of {@link SourceKind}.
+ *
+ * Order matters and is the whole algorithm: a declaration is a declaration even
+ * when its infix says `hook` (`x.hook.d.ts`); a `.json` beside a source is its
+ * stamp; then the last infix is looked up. Case-sensitive, like the file systems
+ * these names mostly live on.
+ */
+function classifySource(filename) {
+    if (DECLARATION.test(filename))
+        return { kind: "declaration" };
+    if (STAMP.test(filename))
+        return { kind: "stamp" };
+    if (!RUNNABLE.test(filename))
+        return { kind: "non-source" };
+    const parts = MARKED.exec(filename);
+    const row = MARKERS.find((m) => m.infix === parts?.[2]);
+    if (row === undefined)
+        return UNCLAIMED;
+    // A test needs no name to be run (`vigiles test` finds `.harness.mjs`); a hook
+    // or a provider must be nameable, so a stemless one is nobody's.
+    return parts?.[1] === "" && row.kind.kind !== "vigiles-test"
+        ? UNCLAIMED
+        : row.kind;
+}
+/**
+ * Is this basename an eval script — the PAID tier, the one that spends real
+ * model calls? It decides which of two runners owns a test file, and has been
+ * wrong in both directions:
+ *
+ * - As the full suffix `.eval.mjs`: `foo.eval.ts` fell into the free branch and
+ *   would have spent real model calls on every push.
+ * - As the bare INFIX `.eval.`: `parser.eval.test.ts`, an ordinary deterministic
+ *   test, was credited to the paid tier and dropped from the free one — though
+ *   `vigiles eval` cannot discover that name at all.
+ *
+ * The answer that is wrong in neither direction is the runner's own: `.eval.`
+ * followed by a runnable extension AT THE END of the name, which is exactly what
+ * the last-infix rule of {@link classifySource} says.
+ *
+ * @param filename a BASENAME — callers strip the directory with their own path
+ * helper (`node:path` on disk, `posix-path` in the browser twin).
+ */
+function isEvalScript(filename) {
+    const k = classifySource(filename);
+    return k.kind === "vigiles-test" && k.test === "eval";
+}
+/** Is this basename a vigiles test of either tier? */
+function isVigilesTest(filename) {
+    return classifySource(filename).kind === "vigiles-test";
+}
+/** The glob `vigiles test` / `vigiles eval` discover a tier's scripts with. */
+function testGlob(tier) {
+    return `**/*.${tier}.{${exports.RUNNABLE_EXTS.join(",")}}`;
+}
+/** The patterns coverage credits tests with by default — one per tier, from the table. */
+exports.DEFAULT_TEST_GLOBS = TEST_TIERS.map(testGlob);
+/** Split at the last directory separator — either one, so a Windows path works too. */
+const splitDir = (path) => {
+    const cut = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1;
+    return [path.slice(0, cut), path.slice(cut)];
+};
+/** The last path segment, whichever separator precedes it. */
+const baseName = (path) => splitDir(path)[1];
+exports.baseName = baseName;
+/** Everything up to and including the last separator, or "" when there is none. */
+const dirName = (path) => splitDir(path)[0];
+exports.dirName = dirName;
+/**
+ * `guard.mjs` → `guard.hook.mjs`: the name a file must carry to be claimed as
+ * `marker`. Keeps the directory. The inverse of {@link preMarkerName}.
+ */
+function markedName(path, marker) {
+    const [dir, base] = splitDir(path);
+    return dir + base.replace(/\.([^.]+)$/, `.${marker}.$1`);
+}
+/**
+ * `guard.hook.mjs` → `guard.mjs`: the name a file carried before the marker
+ * existed, or `undefined` when the name has no such marker. Used to recognise
+ * the wiring an older vigiles wrote for the same file.
+ */
+function preMarkerName(path, marker) {
+    const [dir, base] = splitDir(path);
+    const m = new RegExp(`^([\\s\\S]+)\\.${marker}\\.(${EXT_ALT})$`).exec(base);
+    return m === null ? undefined : `${dir}${m[1]}.${m[2]}`;
+}
+//# sourceMappingURL=source-kinds.js.map

package/dist/test-coverage-files.js

@@ -34,22 +34,7 @@ exports.findUntestedSurfacesInFiles = findUntestedSurfacesInFiles;
 const posix_path_js_1 = require("./posix-path.js");
 const layout_js_1 = require("./core/layout.js");
 const coverage_evidence_js_1 = require("./coverage-evidence.js");
-// Mirrors src/test-coverage.ts constants. VALUES are re-declared, never imported
-// — test-coverage.ts pulls in node:fs/glob, and this twin must stay browser-safe.
-const DEFAULT_TEST_SUFFIXES = [
-    ".harness.ts",
-    ".harness.mts",
-    ".harness.cts",
-    ".harness.js",
-    ".harness.mjs",
-    ".harness.cjs",
-    ".eval.ts",
-    ".eval.mts",
-    ".eval.cts",
-    ".eval.js",
-    ".eval.mjs",
-    ".eval.cjs",
-];
+const source_kinds_js_1 = require("./source-kinds.js");
 const IGNORE_MARKER = "vigiles:ignore-test";
 /** Mirror of the DEFAULT_IGNORE globs (root-anchored), as a key predicate. */
 function isIgnored(key) {
@@ -190,7 +175,7 @@ function discoverTests(files) {
     for (const path of Object.keys(files)) {
         if (isIgnored(path))
             continue;
-        if (DEFAULT_TEST_SUFFIXES.some((s) => path.endsWith(s))) {
+        if ((0, source_kinds_js_1.isVigilesTest)((0, posix_path_js_1.basename)(path))) {
             out.push((0, coverage_evidence_js_1.prepareTest)(path));
         }
     }

package/dist/test-coverage.js

@@ -78,6 +78,7 @@ const ts_runner_caps_js_1 = require("./ts-runner-caps.js");
 const glob_1 = require("glob");
 const glob_ignore_js_1 = require("./core/glob-ignore.js");
 const exclude_js_1 = require("./exclude.js");
+const source_kinds_js_1 = require("./source-kinds.js");
 const layout_js_1 = require("./core/layout.js");
 const coverage_evidence_js_1 = require("./coverage-evidence.js");
 const coverage_artifact_js_1 = require("./coverage-artifact.js");
@@ -98,9 +99,6 @@ function surfaceGlobs(dir, leaf, materializeRoot) {
 // ---------------------------------------------------------------------------
 // Internals
 // ---------------------------------------------------------------------------
-/** Every extension Node executes directly. `.mts`/`.cts` are real (TS 4.7+) and
- * Node 22 strips their types with no toolchain — measured, not assumed. */
-const RUNNABLE_EXTS = "{ts,mts,cts,js,mjs,cjs}";
 /**
  * 🔴 `*.test.*` USED TO BE HERE, AND REMOVING IT IS THE POINT.
  *
@@ -128,10 +126,11 @@ const RUNNABLE_EXTS = "{ts,mts,cts,js,mjs,cjs}";
  * for hooks/agents and dropping them for skills — because a rule with a per-kind
  * exception is what this file just spent a day removing.
  */
-const DEFAULT_TEST_GLOBS = [
-    `**/*.harness.${RUNNABLE_EXTS}`,
-    `**/*.eval.${RUNNABLE_EXTS}`,
-];
+// Read off the table in `source-kinds.ts` — the same one `vigiles test`,
+// `vigiles eval` and the hook/provider discovery classify by — so the patterns
+// that credit a test and the files a hook directory refuses to compile cannot
+// drift apart.
+const DEFAULT_TEST_GLOBS = source_kinds_js_1.DEFAULT_TEST_GLOBS;
 const DEFAULT_IGNORE = [
     "node_modules/**",
     "dist/**",
@@ -298,6 +297,10 @@ function discoverTests(basePath, globs, ignore) {
         cwd: basePath,
         ignore,
         dot: true,
+        // `glob` defaults this to TRUE on macOS and Windows, so `a.hook.HARNESS.mjs`
+        // was a test there and unclaimed on Linux — and the classifier is
+        // case-sensitive. One answer on every OS.
+        nocase: false,
     });
     // Prepared ONCE per file (comment-strip + declaration parse), not once per
     // (surface × file) pair — the matching below is quadratic by nature.
@@ -737,7 +740,7 @@ function staleRunNote(report) {
     ];
 }
 /** Names a default vitest/jest run collects — the suffixes vigiles will not use. */
-const FOREIGN_RUNNER_SUFFIX = /\.(test|spec)\.(ts|mts|cts|js|mjs|cjs)$/;
+const FOREIGN_RUNNER_SUFFIX = new RegExp(`\\.(test|spec)\\.(${source_kinds_js_1.RUNNABLE_EXTS.join("|")})$`);
 /**
  * The would-be colocated tests that only their NAME disqualifies.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "32.1.0",
+  "version": "33.0.0",
   "description": "Audit, test and measure the harness your AI agent runs on — grade your CLAUDE.md / AGENTS.md, skills, subagents and hooks, run them against a scripted model, and measure whether they actually fire.",
   "keywords": [
     "claude-code",