vigiles 2.5.0 → 3.0.0

package/dist/run-hook.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseHookOutput = parseHookOutput;
-exports.decideHook = decideHook;
-exports.runHook = runHook;
-/**
- * vigiles — the *unit* tier for Claude Code hooks.
- *
- * A hook is just a process: Claude Code pipes a JSON event to its stdin and
- * reads back an exit code (0 ok, 2 = block) and, optionally, a JSON decision on
- * stdout. `runHook` exercises exactly that contract directly — no `claude`
- * binary, no model, no sandbox — so a hook's logic can be unit-tested in
- * milliseconds:
- *
- *   const r = runHook('"$GUARD" ', {
- *     hook_event_name: "PreToolUse",
- *     tool_name: "Bash",
- *     tool_input: { command: "git commit --no-verify" },
- *   }, { env: { GUARD: guardPath } });
- *   assert.ok(r.blocked);            // exit 2 / decision:block / permission:deny
- *
- * Why this exists alongside `runHarnessTest`:
- *   - It is the cheap base of the pyramid — no CLI dependency, runs anywhere.
- *   - It reaches every event. The deterministic `runHarnessTest` mock can drive
- *     SessionStart/Stop/UserPromptSubmit/Bash PreToolUse|PostToolUse, but NOT
- *     Edit/Write tool events (headless-gated), PreCompact, Notification,
- *     SessionEnd, or SubagentStop. At this tier you hand the hook the event
- *     JSON yourself, so all of them are testable.
- *
- * It does NOT prove the hook is *wired* into the harness (that the settings
- * point at it, that `${CLAUDE_PLUGIN_ROOT}` resolves) — that is what the
- * `plugin:` loader + `runHarnessTest` cover. Use both: unit-test the hook's
- * logic here, then assert it fires in the assembled machine there.
- */
-const node_child_process_1 = require("node:child_process");
-/** Parse stdout as a hook JSON decision (pure, testable without a process). */
-function parseHookOutput(stdout) {
-    const s = stdout.trim();
-    if (!s.startsWith("{"))
-        return null;
-    try {
-        return JSON.parse(s);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Decide whether a hook result blocked, and the normalized decision. Pure, so
- * the policy is unit-testable independent of spawning anything.
- */
-function decideHook(exitCode, json) {
-    const permission = json?.hookSpecificOutput?.permissionDecision;
-    const decision = permission ?? json?.decision;
-    const blocked = exitCode === 2 || decision === "block" || decision === "deny";
-    return { blocked, decision };
-}
-/**
- * Run a hook command, piping `input` as JSON to its stdin, and report the exit
- * code + parsed decision. Synchronous (so it can be used inside an eval's
- * `measure` too). `command` is run through a shell, so the same command string a
- * plugin ships (with args / env refs) works verbatim.
- */
-function runHook(command, input, opts = {}) {
-    const res = (0, node_child_process_1.spawnSync)(command, {
-        shell: true,
-        cwd: opts.cwd,
-        env: { ...process.env, ...opts.env },
-        input: JSON.stringify(input),
-        encoding: "utf-8",
-        timeout: opts.timeoutMs ?? 10000,
-    });
-    const exitCode = res.status ?? (res.signal ? 1 : 0);
-    const stdout = res.stdout ?? "";
-    const stderr = res.stderr ?? "";
-    const json = parseHookOutput(stdout);
-    const { blocked, decision } = decideHook(exitCode, json);
-    return { exitCode, stdout, stderr, json, blocked, decision };
-}
-//# sourceMappingURL=run-hook.js.map

package/dist/run-scripts.d.ts

@@ -1,20 +0,0 @@
-export interface ScriptRunResult {
-    readonly file: string;
-    readonly code: number;
-}
-/**
- * Expand the given path/glob patterns into concrete script files. A pattern
- * that is an existing file passes through unchanged; anything else is treated
- * as a glob. Falls back to `defaultGlob` when no patterns are given. Results
- * are deduped and sorted; `node_modules` and `dist` are always ignored.
- */
-export declare function discoverScripts(patterns: readonly string[], defaultGlob: string, cwd: string): string[];
-/**
- * Run each script as `node <file>`, inheriting stdio so the script's own report
- * streams to the console. `env` is merged over `process.env` for every child
- * (e.g. `VIGILES_TRIALS`). Returns the per-file exit codes.
- */
-export declare function runScripts(files: readonly string[], cwd: string, env?: NodeJS.ProcessEnv): ScriptRunResult[];
-/** Format a one-line-per-file run summary with a pass/fail tally. */
-export declare function formatScriptSummary(results: readonly ScriptRunResult[]): string;
-//# sourceMappingURL=run-scripts.d.ts.map

package/dist/run-scripts.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.discoverScripts = discoverScripts;
-exports.runScripts = runScripts;
-exports.formatScriptSummary = formatScriptSummary;
-/**
- * vigiles — run harness-test / eval script files via the CLI.
- *
- * `vigiles test` and `vigiles eval` discover `*.harness.mjs` / `*.eval.mjs`
- * scripts and run each as a child `node` process, so the two-tier
- * harness-testing API (`src/harness-test.ts`, `src/eval.ts`) works as a CI
- * command, not just `node x.mjs`. The scripts stay plain Node modules (they
- * import from the built `dist/`), so they also run standalone — the CLI just
- * discovers, runs, and aggregates exit codes.
- */
-const node_child_process_1 = require("node:child_process");
-const node_path_1 = require("node:path");
-const node_fs_1 = require("node:fs");
-const glob_1 = require("glob");
-/**
- * Expand the given path/glob patterns into concrete script files. A pattern
- * that is an existing file passes through unchanged; anything else is treated
- * as a glob. Falls back to `defaultGlob` when no patterns are given. Results
- * are deduped and sorted; `node_modules` and `dist` are always ignored.
- */
-function discoverScripts(patterns, defaultGlob, cwd) {
-    const globs = patterns.length > 0 ? patterns : [defaultGlob];
-    const found = new Set();
-    for (const p of globs) {
-        if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, p))) {
-            found.add(p);
-            continue;
-        }
-        for (const m of (0, glob_1.globSync)(p, {
-            cwd,
-            ignore: ["node_modules/**", "dist/**"],
-        })) {
-            found.add(m);
-        }
-    }
-    return [...found].sort();
-}
-/**
- * Run each script as `node <file>`, inheriting stdio so the script's own report
- * streams to the console. `env` is merged over `process.env` for every child
- * (e.g. `VIGILES_TRIALS`). Returns the per-file exit codes.
- */
-function runScripts(files, cwd, env = {}) {
-    const results = [];
-    for (const file of files) {
-        const res = (0, node_child_process_1.spawnSync)("node", [file], {
-            cwd,
-            stdio: "inherit",
-            env: { ...process.env, ...env },
-        });
-        results.push({ file, code: res.status ?? 1 });
-    }
-    return results;
-}
-/** Format a one-line-per-file run summary with a pass/fail tally. */
-function formatScriptSummary(results) {
-    const lines = results.map((r) => `  ${r.code === 0 ? "✓" : "✗"} ${r.file}` +
-        (r.code === 0 ? "" : ` (exit ${String(r.code)})`));
-    const failed = results.filter((r) => r.code !== 0).length;
-    lines.push(failed === 0
-        ? `\n${String(results.length)} passed.`
-        : `\n${String(failed)}/${String(results.length)} failed.`);
-    return lines.join("\n");
-}
-//# sourceMappingURL=run-scripts.js.map