vigiles 38.2.0 → 39.1.0

package/dist/audit-score.d.ts

@@ -39,6 +39,7 @@
  */
 import { type PluginScore } from "./score-core.js";
 import type { ScanReport } from "./scan.js";
+import type { GradedView } from "./core/apply-rules.js";
 export type CategoryKey = "Truthfulness" | "Triggering" | "Structure" | "Safety" | "Tested" | "Evaluated";
 export interface CategoryScore {
     readonly key: CategoryKey;
@@ -106,7 +107,9 @@ export interface AuditScoreOptions {
  * any n/a ring are shown but excluded from the headline — the grade weighting is
  * UNCHANGED by the Tested/Evaluated split.
  */
-export declare function auditScore(report: ScanReport, opts?: AuditScoreOptions): AuditScore;
+export declare function auditScore(
+/** The graded view: an ungraded group's findings never reach a ring. */
+report: GradedView<ScanReport>, opts?: AuditScoreOptions): AuditScore;
 /**
  * The ring's number as the reader sees it — THREE distinct labels, never two.
  * A measured `0` and an unasked question are different facts and must not render

package/dist/audit-score.js

@@ -497,7 +497,9 @@ function isEmptyAudit(r) {
  * any n/a ring are shown but excluded from the headline — the grade weighting is
  * UNCHANGED by the Tested/Evaluated split.
  */
-function auditScore(report, opts = {}) {
+function auditScore(
+/** The graded view: an ungraded group's findings never reach a ring. */
+report, opts = {}) {
     if (isEmptyAudit(report)) {
         const categories = [
             "Truthfulness",

package/dist/audit-verdict.d.ts

@@ -42,6 +42,7 @@ import { type AuditScore } from "./audit-score.js";
 import type { Recommendation } from "./optimize.js";
 import { type PluginScore } from "./score-core.js";
 import type { ScanReport } from "./scan.js";
+import type { GradedView } from "./core/apply-rules.js";
 /**
  * The inputs the verdict needs — exactly the pieces {@link buildAuditReport}
  * already holds. `score` is the authoritative base (`overall` + `grade`) the
@@ -49,7 +50,8 @@ import type { ScanReport } from "./scan.js";
  * it; `recommendations` is the array whose indices `perRecommendation` aligns to.
  */
 export interface VerdictInput {
-    readonly report: ScanReport;
+    /** The graded view: an ungraded group's findings never reach the verdict. */
+    readonly report: GradedView<ScanReport>;
     readonly score: AuditScore;
     readonly recommendations: readonly Recommendation[];
 }

package/dist/cli-flag-check.d.ts

@@ -70,4 +70,40 @@ export declare function unknownFlags(command: string, argv: readonly string[]):
 export declare function nearestFlag(unknown: string, known: readonly FlagSpec[]): string | undefined;
 /** The message printed to stderr for one unrecognised flag. */
 export declare function formatUnknownFlag(command: string, flag: string): string;
+/**
+ * Which of a verb's arguments name a PATH. The CLI runs every command from the
+ * project root it resolves once (`findProjectRoot`), but a path the user types
+ * means "from where I typed it"; these are the arguments re-expressed from the
+ * root before the command runs. One table beside the flag table, so a new
+ * path-valued flag is declared where flags are.
+ */
+interface PathArguments {
+    /**
+     * Which directory the verb runs from. `project`: the resolved project root.
+     * `invocation`: where it was typed — `init` makes THAT directory a project
+     * (a workspace member it sets up must not become its monorepo's root), and
+     * `hook-runtime` takes its root from the harness event, not from a directory.
+     */
+    readonly root: "project" | "invocation";
+    /** Positionals that are paths: all of them, all after the first (a kind), or none. */
+    readonly positionals: "all" | "after-first" | "none";
+    /** `--flag=` specs whose value is a path. */
+    readonly flags: readonly FlagSpec[];
+}
+export declare const PATH_ARGUMENTS: Readonly<Record<Verb, PathArguments>>;
+/**
+ * Whether `command` runs from the resolved project root. A word that is not a
+ * verb (`--version`, a typo) runs nowhere in particular: it is answered where
+ * it was typed.
+ */
+export declare function runsFromProjectRoot(command: string): boolean;
+/**
+ * The verb's arguments (everything after the verb) with each path argument
+ * passed through `rebase`. Flags that do not take a path, words, and `--`
+ * itself are returned unchanged. After `--` every word is an operand: a path
+ * among them is rebased like any other positional, and a dash-led one is never
+ * mistaken for a path-valued flag.
+ */
+export declare function rebasePathArgs(command: string, argv: readonly string[], rebase: (path: string) => string): readonly string[];
+export {};
 //# sourceMappingURL=cli-flag-check.d.ts.map

package/dist/cli-flag-check.js

@@ -39,11 +39,13 @@
  * rejection in a user's face.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMAND_FLAGS = exports.SHARED_FLAGS = void 0;
+exports.PATH_ARGUMENTS = exports.COMMAND_FLAGS = exports.SHARED_FLAGS = void 0;
 exports.knownFlagsFor = knownFlagsFor;
 exports.unknownFlags = unknownFlags;
 exports.nearestFlag = nearestFlag;
 exports.formatUnknownFlag = formatUnknownFlag;
+exports.runsFromProjectRoot = runsFromProjectRoot;
+exports.rebasePathArgs = rebasePathArgs;
 /**
  * Flags every verb accepts: the config overrides applied in `main()` before
  * dispatch (see `applyConfigFlags`) plus the harness override, which the shared
@@ -80,6 +82,9 @@ exports.COMMAND_FLAGS = {
     compile: [],
     eject: ["--keep-spec"],
     lint: [
+        // A preset applied on top of the repo's own config for this run (the same
+        // names `extends` takes) — see parsePresetFlags.
+        "--preset=",
         "--bundles=",
         "--summary",
         "--json",
@@ -100,6 +105,7 @@ exports.COMMAND_FLAGS = {
         "--update",
     ],
     audit: [
+        "--preset=",
         "--json",
         "--md",
         "--single",
@@ -203,4 +209,73 @@ function formatUnknownFlag(command, flag) {
     lines.push(`  Flags for \`${command}\`: ${[...known].sort().join(" ")}`, `  \`vigiles ${command} --help\` lists them with descriptions.`);
     return lines.join("\n");
 }
+exports.PATH_ARGUMENTS = {
+    init: { root: "invocation", positionals: "none", flags: ["--target="] },
+    compile: { root: "project", positionals: "all", flags: [] },
+    eject: { root: "project", positionals: "all", flags: [] },
+    lint: { root: "project", positionals: "all", flags: ["--json-out="] },
+    test: { root: "project", positionals: "all", flags: [] },
+    eval: { root: "project", positionals: "all", flags: [] },
+    audit: {
+        root: "project",
+        positionals: "all",
+        flags: ["--out=", "--capability-diff=", "--prompts="],
+    },
+    // `generate <kind> [out]`: the kind is a word, the rest are paths.
+    generate: { root: "project", positionals: "after-first", flags: [] },
+    // The harness supplies its argv; its paths are already what it means.
+    "hook-runtime": { root: "invocation", positionals: "none", flags: [] },
+};
+/** The verb's row, or undefined for a word that is not a verb. */
+function pathArgumentsOf(command) {
+    return Object.entries(exports.PATH_ARGUMENTS).find(([verb]) => verb === command)?.[1];
+}
+/**
+ * Whether `command` runs from the resolved project root. A word that is not a
+ * verb (`--version`, a typo) runs nowhere in particular: it is answered where
+ * it was typed.
+ */
+function runsFromProjectRoot(command) {
+    return pathArgumentsOf(command)?.root === "project";
+}
+/** Which of the positional argument indexes are paths, per the verb's spec. */
+function pathPositionalIndexes(positionals, indexes) {
+    switch (positionals) {
+        case "all":
+            return indexes;
+        case "after-first":
+            return indexes.slice(1);
+        case "none":
+            return [];
+    }
+}
+/** A positional word: before `--`, one not led by a dash; after it, every word. */
+function isOperand(arg, index, end) {
+    if (index < end)
+        return !arg.startsWith("-");
+    return index > end;
+}
+/**
+ * The verb's arguments (everything after the verb) with each path argument
+ * passed through `rebase`. Flags that do not take a path, words, and `--`
+ * itself are returned unchanged. After `--` every word is an operand: a path
+ * among them is rebased like any other positional, and a dash-led one is never
+ * mistaken for a path-valued flag.
+ */
+function rebasePathArgs(command, argv, rebase) {
+    const spec = pathArgumentsOf(command);
+    if (!spec)
+        return [...argv];
+    const end = argv.includes("--") ? argv.indexOf("--") : argv.length;
+    const positionalIndexes = argv.flatMap((a, i) => isOperand(a, i, end) ? [i] : []);
+    const pathPositionals = new Set(pathPositionalIndexes(spec.positionals, positionalIndexes));
+    return argv.map((arg, i) => {
+        if (pathPositionals.has(i))
+            return rebase(arg);
+        if (i >= end)
+            return arg;
+        const flag = spec.flags.find((f) => arg.startsWith(f));
+        return flag ? `${flag}${rebase(arg.slice(flag.length))}` : arg;
+    });
+}
 //# sourceMappingURL=cli-flag-check.js.map

package/dist/cli-flags.d.ts

@@ -18,5 +18,5 @@ import type { VigilesConfig } from "./core/types.js";
  * Unknown flags are left untouched (each command parses its own besides
  * these). Returns a new object; the input is not mutated.
  */
-export declare function applyConfigFlags(config: VigilesConfig, args: readonly string[]): VigilesConfig;
+export declare function applyConfigFlags<C extends VigilesConfig>(config: C, args: readonly string[]): C;
 //# sourceMappingURL=cli-flags.d.ts.map

package/dist/cli-main.d.ts

@@ -58,6 +58,8 @@ interface LintReport {
     mcpToolErrors: number;
     hookScriptIssues: number;
     hookScriptErrors: number;
+    handWrittenHookIssues: number;
+    handWrittenHookErrors: number;
     disallowedToolIssues: number;
     disallowedToolErrors: number;
     descriptionOverlapIssues: number;
@@ -68,8 +70,6 @@ interface LintReport {
     frontmatterValidErrors: number;
     mcpHookIssues: number;
     mcpHookErrors: number;
-    preferCompiledHookIssues: number;
-    preferCompiledHookErrors: number;
     lethalTrifectaIssues: number;
     lethalTrifectaErrors: number;
     skillResourceIssues: number;