@webpresso/agent-kit 0.21.0

package/dist/esm/hooks/sessionstart/index.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+/**
+ * SessionStart hook: injects WP_ROUTING_BLOCK and optionally `.agent/routing.md`
+ * into Claude Code sessions.
+ *
+ * Wired in `plugin.json` as `SessionStart` with matcher `startup|resume|compact`.
+ * The `compact` source is included so the routing block is re-injected after
+ * context compaction (F3 from fact-check: block is silently dropped without it).
+ * Cannot block (decision-control unsupported for SessionStart) — this is
+ * observability + context injection only. Latency budget: <50ms cold.
+ *
+ * Output contract (per Claude Code hooks docs):
+ *   {"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":"<contents>"}}
+ *
+ * Always emits — never returns null. WP_ROUTING_BLOCK is always prepended.
+ * If `.agent/routing.md` exists and is non-empty, it is appended after the block.
+ */
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { WP_ROUTING_BLOCK } from '#hooks/shared/routing-block';
+import { readUpdateBanner } from './update-banner.js';
+export { WP_ROUTING_BLOCK };
+export const MAX_BYTES = 200 * 1024;
+export const TRUNCATION_NOTICE = '\n\n[truncated: file exceeded 200KB limit]';
+/**
+ * Pure function: given a parsed input payload, a working directory, and
+ * environment variables, produce the JSON string that the hook should write
+ * to stdout. Always emits — never returns null. WP_ROUTING_BLOCK is always
+ * prepended; `.agent/routing.md` content is appended when present and non-empty.
+ */
+export function buildOutput(_input, cwd, env) {
+    const projectDir = env.CLAUDE_PROJECT_DIR && env.CLAUDE_PROJECT_DIR.length > 0 ? env.CLAUDE_PROJECT_DIR : cwd;
+    const target = join(projectDir, '.agent', 'routing.md');
+    let routingMd = null;
+    try {
+        const stat = statSync(target);
+        if (stat.isFile() && stat.size > 0) {
+            const raw = readFileSync(target, 'utf-8');
+            if (raw.length > 0) {
+                let content = raw;
+                if (Buffer.byteLength(raw, 'utf-8') > MAX_BYTES) {
+                    // Slice on UTF-16 code units; routing.md is ASCII-dominant in practice.
+                    content = raw.slice(0, MAX_BYTES) + TRUNCATION_NOTICE;
+                }
+                routingMd = content;
+            }
+        }
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+            // Permission or other read errors: surface to stderr but continue.
+            process.stderr.write(`wp-sessionstart-routing: failed to read ${target}: ${err.message}\n`);
+        }
+        // ENOENT / ENOTDIR: no routing.md, that's fine — emit routing block alone.
+    }
+    let gstackBlock = null;
+    if (env.WP_GSTACK_ROUTING === '1') {
+        const gstackDir = join(homedir(), '.claude', 'skills', 'gstack');
+        if (existsSync(gstackDir)) {
+            gstackBlock =
+                '\n\n## Interactive skills (gstack)\nSkills like /browse, /qa, /ship, /investigate, /review available. Use /browse for all web browsing.';
+        }
+    }
+    let additionalContext = routingMd !== null ? WP_ROUTING_BLOCK + '\n\n' + routingMd : WP_ROUTING_BLOCK;
+    if (gstackBlock !== null) {
+        additionalContext += gstackBlock;
+    }
+    const updateBanner = readUpdateBanner(env);
+    if (updateBanner !== null) {
+        additionalContext += '\n\n' + updateBanner;
+    }
+    return JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: 'SessionStart',
+            additionalContext,
+        },
+    });
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return {};
+    return new Promise((resolve) => {
+        const chunks = [];
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            const text = Buffer.concat(chunks).toString('utf-8').trim();
+            if (text.length === 0)
+                return resolve({});
+            try {
+                resolve(JSON.parse(text));
+            }
+            catch {
+                resolve({});
+            }
+        };
+        process.stdin.on('data', (c) => chunks.push(c));
+        process.stdin.on('end', finish);
+        process.stdin.on('error', finish);
+    });
+}
+export async function main() {
+    try {
+        const input = await readStdin();
+        const out = buildOutput(input, process.cwd(), process.env);
+        process.stdout.write(out);
+    }
+    catch (err) {
+        process.stderr.write(`wp-sessionstart-routing: ${err.message}\n`);
+    }
+    process.exit(0);
+}
+if (process.argv[1] &&
+    realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1])) {
+    void main();
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/hooks/sessionstart/update-banner.d.ts

@@ -0,0 +1,2 @@
+export declare function readUpdateBanner(env: NodeJS.ProcessEnv): string | null;
+//# sourceMappingURL=update-banner.d.ts.map

package/dist/esm/hooks/sessionstart/update-banner.js

@@ -0,0 +1,66 @@
+import { readFileSync } from 'node:fs';
+import { getSurfacePath } from '#paths/state-root.js';
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+export function readUpdateBanner(env) {
+    void env;
+    let configPath;
+    try {
+        configPath = getSurfacePath('update-notifier-cache.json', 'user');
+    }
+    catch {
+        return null;
+    }
+    let raw;
+    try {
+        raw = readFileSync(configPath, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return null;
+        return null;
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const { latest, current, lastUpdateCheck } = data;
+    if (typeof latest !== 'string' || typeof current !== 'string')
+        return null;
+    if (latest === current)
+        return null;
+    if (typeof lastUpdateCheck === 'number') {
+        const age = Date.now() - lastUpdateCheck;
+        if (age > SEVEN_DAYS_MS)
+            return null;
+    }
+    else if (typeof lastUpdateCheck === 'string') {
+        const ts = Date.parse(lastUpdateCheck);
+        if (!Number.isNaN(ts) && Date.now() - ts > SEVEN_DAYS_MS)
+            return null;
+    }
+    // Basic semver-style comparison: check that latest > current
+    if (!isNewerVersion(latest, current))
+        return null;
+    return `<wp_update>webpresso ${latest} available (current ${current}). Auto-install runs on the next \`wp\` invocation, or set WP_SKIP_AUTO_INSTALL=1 to opt out.</wp_update>`;
+}
+function isNewerVersion(latest, current) {
+    const latestParts = latest.split('.').map((p) => parseInt(p, 10));
+    const currentParts = current.split('.').map((p) => parseInt(p, 10));
+    const len = Math.max(latestParts.length, currentParts.length);
+    for (let i = 0; i < len; i++) {
+        const l = latestParts[i] ?? 0;
+        const c = currentParts[i] ?? 0;
+        if (Number.isNaN(l) || Number.isNaN(c))
+            return latest !== current;
+        if (l > c)
+            return true;
+        if (l < c)
+            return false;
+    }
+    return false;
+}
+//# sourceMappingURL=update-banner.js.map

package/dist/esm/hooks/shared/hook-bootstrap.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Suppress stderr at the file-descriptor level.
+ * This handles native C++ module stderr (e.g. better-sqlite3) that bypasses
+ * Node.js process.stderr. Must be called before any imports that trigger
+ * native module loading.
+ *
+ * Cross-platform: no-ops on Windows (fd redirect not portable there).
+ */
+export declare function suppressStderr(): void;
+/**
+ * Read all stdin bytes and return as UTF-8 string.
+ */
+export declare function readStdinJson(): Promise<string>;
+/**
+ * Shared hook entry-point bootstrap.
+ *
+ * Handles:
+ * 1. Stderr suppression (keeps Claude Code UI clean)
+ * 2. Stdin reading + JSON parsing
+ * 3. Handler invocation
+ * 4. JSON output writing
+ * 5. Clean process exit
+ *
+ * When `handler` returns `null`, writes `{}` (passthrough — Claude proceeds normally).
+ * When `handler` returns a value, `formatter` converts it to a JSON string for stdout.
+ */
+export declare function runHook<T>(handler: (input: unknown) => T | null, formatter: (result: T) => string): Promise<void>;
+//# sourceMappingURL=hook-bootstrap.d.ts.map

package/dist/esm/hooks/shared/hook-bootstrap.js

@@ -0,0 +1,62 @@
+import { closeSync, openSync } from 'node:fs';
+/**
+ * Suppress stderr at the file-descriptor level.
+ * This handles native C++ module stderr (e.g. better-sqlite3) that bypasses
+ * Node.js process.stderr. Must be called before any imports that trigger
+ * native module loading.
+ *
+ * Cross-platform: no-ops on Windows (fd redirect not portable there).
+ */
+export function suppressStderr() {
+    if (process.platform === 'win32')
+        return;
+    try {
+        closeSync(2);
+        openSync('/dev/null', 'w');
+    }
+    catch {
+        // If stderr is already closed or /dev/null unavailable, ignore silently
+    }
+}
+/**
+ * Read all stdin bytes and return as UTF-8 string.
+ */
+export async function readStdinJson() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf-8');
+}
+/**
+ * Shared hook entry-point bootstrap.
+ *
+ * Handles:
+ * 1. Stderr suppression (keeps Claude Code UI clean)
+ * 2. Stdin reading + JSON parsing
+ * 3. Handler invocation
+ * 4. JSON output writing
+ * 5. Clean process exit
+ *
+ * When `handler` returns `null`, writes `{}` (passthrough — Claude proceeds normally).
+ * When `handler` returns a value, `formatter` converts it to a JSON string for stdout.
+ */
+export async function runHook(handler, formatter) {
+    suppressStderr();
+    const raw = await readStdinJson();
+    if (!raw.trim()) {
+        process.stdout.write('{}');
+        process.exit(0);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        process.stdout.write('{}');
+        process.exit(0);
+    }
+    const result = handler(parsed);
+    process.stdout.write(result !== null ? formatter(result) : '{}');
+    process.exit(0);
+}
+//# sourceMappingURL=hook-bootstrap.js.map

package/dist/esm/hooks/shared/mcp-sentinel.d.ts

@@ -0,0 +1,10 @@
+export declare function sentinelPath(): string;
+export declare function isMcpReady(): boolean;
+export declare function writeSentinel(): void;
+export declare function deleteSentinel(): void;
+/**
+ * Test-only — kept as a no-op for forward compatibility so callers that
+ * adopted the cache-reset pattern don't need a follow-up edit.
+ */
+export declare function _resetProjectKeyCache(): void;
+//# sourceMappingURL=mcp-sentinel.d.ts.map

package/dist/esm/hooks/shared/mcp-sentinel.js

@@ -0,0 +1,106 @@
+/**
+ * MCP readiness sentinel.
+ *
+ * Background. The pretool-guard hook routes dev-workflow commands
+ * (`pnpm test`, `just lint`, `wp ...`) to the webpresso MCP tool surface
+ * when MCP is alive, and falls back to a `just <task>` recipe otherwise.
+ * The hook needs a way to discover whether an webpresso MCP server is
+ * currently running.
+ *
+ * Why a scan-based reader. Earlier versions keyed the sentinel filename
+ * to a value derived from `process.ppid` or `process.cwd()`, so the
+ * reader (hook) and writer (MCP) had to compute the same key. Both
+ * approaches break on real IDE topologies:
+ *
+ *   - PPID-keyed fails when the IDE host is not the direct parent of
+ *     both processes (Codex CLI routes hooks through workers).
+ *   - cwd-keyed fails when the IDE spawns the MCP server with a cwd
+ *     that diverges from the session cwd (Codex spawns the MCP server
+ *     with the script's directory, not the project root).
+ *
+ * The fix decouples the two halves. The writer claims a unique
+ * filename (defaulting to `wp-mcp-ready-${process.pid}`); the reader
+ * scans `tmpdir` for ALL files matching `wp-mcp-ready-*` and returns
+ * true if any of them contains a live PID. Reader and writer no longer
+ * need to agree on a key, only on a stable filename pattern.
+ *
+ * The webpresso MCP server's tool surface is functionally global — it
+ * serves whichever cwd the request comes from — so "any MCP is alive"
+ * is sufficient to enable MCP-tool routing on the hook side.
+ *
+ * Liveness check. The sentinel content is the MCP server PID. Hook
+ * verifies the PID is alive via `process.kill(pid, 0)`. Stale
+ * sentinels (MCP crashed without cleanup) are skipped.
+ *
+ * Override. Set `WP_MCP_SENTINEL_KEY` to pin the writer's filename
+ * suffix (useful for tests that need a deterministic file path).
+ */
+import { readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const SENTINEL_PREFIX = 'wp-mcp-ready-';
+function writerKey() {
+    const override = process.env.WP_MCP_SENTINEL_KEY;
+    if (override && override.trim().length > 0)
+        return override.trim();
+    return String(process.pid);
+}
+export function sentinelPath() {
+    return join(tmpdir(), `${SENTINEL_PREFIX}${writerKey()}`);
+}
+function readPid(filePath) {
+    try {
+        const pid = parseInt(readFileSync(filePath, 'utf-8'), 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isMcpReady() {
+    if (process.platform === 'win32')
+        return false;
+    let entries;
+    try {
+        entries = readdirSync(tmpdir());
+    }
+    catch {
+        return false;
+    }
+    for (const name of entries) {
+        if (!name.startsWith(SENTINEL_PREFIX))
+            continue;
+        const pid = readPid(join(tmpdir(), name));
+        if (pid !== null && isPidAlive(pid))
+            return true;
+    }
+    return false;
+}
+export function writeSentinel() {
+    writeFileSync(sentinelPath(), String(process.pid), 'utf-8');
+}
+export function deleteSentinel() {
+    try {
+        unlinkSync(sentinelPath());
+    }
+    catch {
+        // ignore — sentinel may not exist
+    }
+}
+/**
+ * Test-only — kept as a no-op for forward compatibility so callers that
+ * adopted the cache-reset pattern don't need a follow-up edit.
+ */
+export function _resetProjectKeyCache() {
+    // intentional no-op
+}
+//# sourceMappingURL=mcp-sentinel.js.map

package/dist/esm/hooks/shared/routing-block.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WP_ROUTING_BLOCK — XML routing instruction injected into every session
+ * via SessionStart `additionalContext`. Tells Claude to prefer wp_* MCP tools
+ * over raw shell commands for dev-workflow operations. Context-mode owns ctx_*
+ * nudging when that plugin is installed.
+ */
+export declare const WP_ROUTING_BLOCK: string;
+//# sourceMappingURL=routing-block.d.ts.map

package/dist/esm/hooks/shared/routing-block.js

@@ -0,0 +1,140 @@
+/**
+ * WP_ROUTING_BLOCK — XML routing instruction injected into every session
+ * via SessionStart `additionalContext`. Tells Claude to prefer wp_* MCP tools
+ * over raw shell commands for dev-workflow operations. Context-mode owns ctx_*
+ * nudging when that plugin is installed.
+ */
+export const WP_ROUTING_BLOCK = `<wp_routing>
+  <description>
+    Use the wp_* MCP tools for all test, lint, typecheck, qa, audit, local CI act,
+    and Cloudflare Worker tail operations.
+    If context-mode plugin routing is present, let it own ctx_* data-processing nudges.
+    These tools return structured, summary-first results and keep output concise.
+  </description>
+
+  <decision_table>
+    <row>
+      <trigger>running tests, verifying test suite, check if tests pass</trigger>
+      <tool>wp_test</tool>
+    </row>
+    <row>
+      <trigger>running e2e test files or package-scoped e2e execution</trigger>
+      <tool>wp_e2e</tool>
+    </row>
+    <row>
+      <trigger>linting, code style checks, lint errors</trigger>
+      <tool>wp_lint</tool>
+    </row>
+    <row>
+      <trigger>type checking, TypeScript errors, type errors</trigger>
+      <tool>wp_typecheck</tool>
+    </row>
+    <row>
+      <trigger>quality assurance, full QA pass, qa check, markdown lint, lint-md, markdownlint</trigger>
+      <tool>wp_qa</tool>
+    </row>
+    <row>
+      <trigger>auditing blueprints, catalog drift, bundle budget, docs frontmatter</trigger>
+      <tool>wp_audit</tool>
+    </row>
+    <row>
+      <trigger>running act, local GitHub Actions, with-secrets -- act, vp exec act, pnpm exec act</trigger>
+      <tool>wp_ci_act</tool>
+    </row>
+    <row>
+      <trigger>wrangler tail, with-secrets -- wrangler tail, Cloudflare Worker logs</trigger>
+      <tool>wp_worker_tail</tool>
+    </row>
+    <row>
+      <trigger>e2e testing philosophy audit, tph-e2e</trigger>
+      <tool>wp_audit(kind="tph-e2e")</tool>
+    </row>
+  </decision_table>
+
+  <tools>
+    <tool name="wp_test">
+      <category>dev-workflow</category>
+      <trigger>running tests, verifying test suite, check if tests pass</trigger>
+      <forbidden>just test, pnpm test, vitest</forbidden>
+    </tool>
+    <tool name="wp_e2e">
+      <category>dev-workflow</category>
+      <trigger>running e2e test files, suite-aware e2e execution, host-adapter e2e flows</trigger>
+      <usage>Use for E2E execution. Supports suite-aware and host-adapter-backed planning.</usage>
+    </tool>
+    <tool name="wp_lint">
+      <category>dev-workflow</category>
+      <trigger>linting, code style checks, lint errors</trigger>
+      <forbidden>just lint, oxlint</forbidden>
+    </tool>
+    <tool name="wp_typecheck">
+      <category>dev-workflow</category>
+      <trigger>type checking, TypeScript errors, type errors</trigger>
+      <forbidden>tsc</forbidden>
+    </tool>
+    <tool name="wp_qa">
+      <category>dev-workflow</category>
+      <trigger>quality assurance, full QA pass, qa check, markdown lint, lint-md, markdownlint</trigger>
+      <forbidden>just qa, just lint-md, markdownlint-cli2</forbidden>
+    </tool>
+    <tool name="wp_audit">
+      <category>dev-workflow</category>
+      <trigger>auditing blueprints, catalog drift, bundle budget, docs frontmatter</trigger>
+      <forbidden>just audit</forbidden>
+      <usage>Use kind="tph-e2e" for the E2E testing-philosophy audit. This audits E2E quality rules; it does not execute the E2E suite itself.</usage>
+    </tool>
+    <tool name="wp_ci_act">
+      <category>dev-workflow</category>
+      <trigger>running act, local GitHub Actions, with-secrets -- act, vp exec act, pnpm exec act</trigger>
+      <forbidden>act, vp exec act, pnpm exec act</forbidden>
+      <usage>Use the wp_ci_act MCP tool for local GitHub Actions execution. The tool uses the public secret contract: configure with wp config secrets ... and execute through with-secrets -- act ... internally.</usage>
+    </tool>
+    <tool name="wp_worker_tail">
+      <category>dev-workflow</category>
+      <trigger>wrangler tail, with-secrets -- wrangler tail, Cloudflare Worker logs</trigger>
+      <forbidden>wrangler tail, with-secrets -- wrangler tail</forbidden>
+      <usage>Use the wp_worker_tail MCP tool for Cloudflare Worker tail logs. The tool routes through the canonical with-secrets -- wrangler tail ... contract and returns bounded redacted output.</usage>
+    </tool>
+  </tools>
+
+  <ownership_boundary>
+    <rule>Agent-kit owns wp_* dev-workflow routing here.</rule>
+    <rule>Context-mode owns ctx_* routing when that plugin is installed.</rule>
+  </ownership_boundary>
+
+  <package_guidance>
+    <rule>Consumers add @webpresso/agent-kit and import config helpers through @webpresso/agent-kit/* subpath exports such as @webpresso/agent-kit/oxlint, @webpresso/agent-kit/vitest/node, @webpresso/agent-kit/test-preset, @webpresso/agent-kit/e2e-preset, @webpresso/agent-kit/tsconfig/base.json, @webpresso/agent-kit/docs-lint, @webpresso/agent-kit/stryker, @webpresso/agent-kit/launch, and @webpresso/agent-kit/workers-test.</rule>
+    <rule>Do not recommend adding retired split agent config packages for consumer projects; keep wp_* MCP tool names and wp-* hook bin names unchanged.</rule>
+  </package_guidance>
+
+  <forbidden_alternatives>
+    <command>just test</command>
+    <command>pnpm test</command>
+    <command>just lint</command>
+    <command>just qa</command>
+    <command>just lint-md</command>
+    <command>vitest</command>
+    <command>oxlint</command>
+    <command>markdownlint-cli2</command>
+    <command>tsc</command>
+    <command>act</command>
+    <command>vp exec act</command>
+    <command>pnpm exec act</command>
+    <command>wrangler tail</command>
+    <command>with-secrets -- act</command>
+    <command>with-secrets -- wrangler tail</command>
+  </forbidden_alternatives>
+
+  <output_format>
+    <rule>Return structured, summary-first results — not raw shell output.</rule>
+    <rule>Keep summaries under 200 words.</rule>
+    <rule>Cite file paths, not log lines; raw output is clipped and secondary.</rule>
+    <rule>Keep the style short, direct, and context-friendly.</rule>
+  </output_format>
+
+  <fallback>
+    When MCP tools are unavailable, use just recipes directly and keep output brief.
+    .omx is runtime/state only; it is not a direct hook surface.
+  </fallback>
+</wp_routing>`;
+//# sourceMappingURL=routing-block.js.map

package/dist/esm/hooks/shared/types.d.ts

@@ -0,0 +1,24 @@
+export interface ToolInput {
+    session_id?: string;
+    transcript_path?: string;
+    cwd?: string;
+    hook_event_name?: string;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+}
+export interface ValidationResult {
+    validator: string;
+    passed: boolean;
+    message?: string;
+    skipped?: boolean;
+    skipReason?: string;
+}
+export declare function parseToolInput(json: string): ToolInput;
+export declare function isBashInput(input: ToolInput): boolean;
+export declare function isFileEditInput(input: ToolInput): boolean;
+export declare function isFileWriteInput(input: ToolInput): boolean;
+export declare function isFileReadInput(input: ToolInput): boolean;
+export declare function getFilePath(input: ToolInput): string | undefined;
+export declare function getCommand(input: ToolInput): string | undefined;
+export declare function getContent(input: ToolInput): string | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/hooks/shared/types.js

@@ -0,0 +1,48 @@
+export function parseToolInput(json) {
+    return JSON.parse(json);
+}
+export function isBashInput(input) {
+    return 'command' in (input.tool_input || {});
+}
+export function isFileEditInput(input) {
+    const toolInput = input.tool_input || {};
+    return 'file_path' in toolInput && 'old_string' in toolInput && 'new_string' in toolInput;
+}
+export function isFileWriteInput(input) {
+    const toolInput = input.tool_input || {};
+    return 'file_path' in toolInput && 'content' in toolInput;
+}
+export function isFileReadInput(input) {
+    const toolInput = input.tool_input || {};
+    return 'file_path' in toolInput && !('content' in toolInput) && !('old_string' in toolInput);
+}
+export function getFilePath(input) {
+    const toolInput = input.tool_input;
+    if (!toolInput || typeof toolInput !== 'object')
+        return undefined;
+    const filePath = toolInput.file_path;
+    return typeof filePath === 'string' ? filePath : undefined;
+}
+export function getCommand(input) {
+    if (isBashInput(input)) {
+        const toolInput = input.tool_input;
+        if (!toolInput || typeof toolInput !== 'object')
+            return undefined;
+        const command = toolInput.command;
+        return typeof command === 'string' ? command : undefined;
+    }
+    return undefined;
+}
+export function getContent(input) {
+    const toolInput = input.tool_input;
+    if (!toolInput || typeof toolInput !== 'object')
+        return undefined;
+    const content = toolInput.content;
+    const newString = toolInput.new_string;
+    if (typeof content === 'string')
+        return content;
+    if (typeof newString === 'string')
+        return newString;
+    return undefined;
+}
+//# sourceMappingURL=types.js.map

package/dist/esm/hooks/shared/validators/blueprint.d.ts

@@ -0,0 +1,17 @@
+export interface BlueprintValidationResult {
+    valid: boolean;
+    reason?: string;
+    details?: {
+        hasPlan?: boolean;
+        planPath?: string;
+        skipReason?: string;
+    };
+}
+export declare function shouldSkipFile(filePath: string): boolean;
+export declare function getSkipReason(filePath: string): string;
+export declare function validateBlueprint(filePath: string | undefined, options?: {
+    bypassEnabled?: boolean;
+}): BlueprintValidationResult;
+export declare function parseFrontmatter(content: string): Record<string, unknown> | null;
+export declare function isActivePlan(frontmatter: Record<string, unknown> | null): boolean;
+//# sourceMappingURL=blueprint.d.ts.map