@webpresso/agent-kit 0.21.0

package/dist/esm/hooks/pretool-guard/validators/forbidden-commands.js

@@ -0,0 +1,439 @@
+import { readConfig } from '#cli/commands/init/config';
+import { getCommand, isBashInput } from '#hooks/shared/types';
+import { createSkipResult } from './skip-result.js';
+import { buildRedirectMessage } from './mcp-redirect.js';
+export const VALIDATOR_NAME = 'forbidden-commands';
+export const SKIP_ENV_VAR = 'FORBIDDEN_COMMANDS_SKIP';
+export const AUDIT_MODE_ENV = 'FORBIDDEN_COMMANDS_AUDIT';
+export const DOCS_REF = 'AGENTS.md "Forbidden Commands (CRITICAL)" section';
+const DB_HINT = 'Use the database MCP/tooling entrypoint instead of direct CLI execution';
+const BLUEPRINT_HINT = 'wp blueprint new|list|audit — use wp_blueprint MCP tool for lifecycle transitions';
+const BLUEPRINT_LIFECYCLE_DIRS = '(draft|planned|in-progress|completed|archived)';
+const LINT_BASE = 'wp_lint MCP tool with package/file scope';
+const LINT_HINT = `${LINT_BASE} [--fix] [--fix-unsafe]`;
+const FORMAT_HINT = 'wp_format MCP tool';
+const QA_HINT = 'wp_qa MCP tool';
+const TEST_HINT = 'wp_test MCP tool with package/file scope';
+const MUTATION_HINT = 'wp_test mutation workflow';
+const TYPECHECK_HINT = 'wp_typecheck MCP tool with package/file scope';
+const E2E_HINT = 'wp_e2e MCP tool';
+const ENV_HINT = 'Use the repo-approved environment wrapper for secret-bearing commands';
+const TASK_TARGET_HINT = 'Use the repo-approved vp facade or MCP tool instead of raw execution';
+const EXEC_RUNNERS = ['vp exec'];
+const DIRECT_RUNNERS = ['vp'];
+const SCRIPT_RUNNERS = ['vp run', 'vp', 'pnpm', 'pnpm run', 'just'];
+export const BLOCKED_TOOLS = [
+    {
+        tool: 'drizzle-kit',
+        category: 'unknown',
+        suggestion: DB_HINT,
+        runners: ['exec', 'direct', 'bare'],
+    },
+    { tool: 'vitest', category: 'test', suggestion: TEST_HINT, runners: ['exec', 'direct', 'bare'] },
+    { tool: 'oxlint', category: 'lint', suggestion: LINT_HINT, runners: ['exec', 'direct', 'bare'] },
+    { tool: 'oxfmt', category: 'lint', suggestion: FORMAT_HINT, runners: ['exec', 'direct', 'bare'] },
+    {
+        tool: 'prettier',
+        category: 'format',
+        suggestion: FORMAT_HINT,
+        runners: ['exec', 'direct', 'bare'],
+    },
+    { tool: 'stryker', category: 'test', suggestion: MUTATION_HINT, runners: ['exec', 'bare'] },
+    {
+        tool: 'tsc',
+        category: 'typecheck',
+        suggestion: TYPECHECK_HINT,
+        runners: ['exec', 'direct', 'bare'],
+    },
+    {
+        tool: 'tsgo',
+        category: 'typecheck',
+        suggestion: TYPECHECK_HINT,
+        runners: ['exec', 'direct', 'bare'],
+    },
+];
+export const BLOCKED_SCRIPTS = [
+    { script: 'test', category: 'test', suggestion: TEST_HINT },
+    { script: 'lint', category: 'lint', suggestion: LINT_HINT },
+    { script: 'typecheck', category: 'typecheck', suggestion: TYPECHECK_HINT },
+    { script: 'e2e', category: 'e2e', suggestion: E2E_HINT },
+    { script: 'qa', category: 'unknown', suggestion: QA_HINT },
+];
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildToolPattern(prefix, tool) {
+    const escaped = prefix ? `${escapeRegex(prefix)} ${escapeRegex(tool)}` : escapeRegex(tool);
+    return new RegExp(`^${escaped}(\\s|$)`);
+}
+export function generateRules() {
+    const rules = [];
+    for (const spec of BLOCKED_TOOLS) {
+        if (spec.runners.includes('exec')) {
+            for (const runner of EXEC_RUNNERS) {
+                rules.push({
+                    pattern: buildToolPattern(runner, spec.tool),
+                    category: spec.category,
+                    suggestion: spec.suggestion,
+                });
+            }
+        }
+        if (spec.runners.includes('direct')) {
+            for (const runner of DIRECT_RUNNERS) {
+                rules.push({
+                    pattern: buildToolPattern(runner, spec.tool),
+                    category: spec.category,
+                    suggestion: spec.suggestion,
+                });
+            }
+        }
+        if (spec.runners.includes('bare')) {
+            rules.push({
+                pattern: buildToolPattern('', spec.tool),
+                category: spec.category,
+                suggestion: spec.suggestion,
+            });
+        }
+    }
+    for (const spec of BLOCKED_SCRIPTS) {
+        for (const runner of SCRIPT_RUNNERS) {
+            rules.push({
+                pattern: buildToolPattern(runner, spec.script),
+                category: spec.category,
+                suggestion: spec.suggestion,
+            });
+        }
+    }
+    rules.push({
+        pattern: /^vp exec markdownlint-cli2\b/,
+        category: 'unknown',
+        suggestion: QA_HINT,
+    }, { pattern: /^markdownlint-cli2\b/, category: 'unknown', suggestion: QA_HINT }, {
+        pattern: new RegExp(`^mv\\b.*blueprints\\/${BLUEPRINT_LIFECYCLE_DIRS}`),
+        category: 'blueprint',
+        suggestion: BLUEPRINT_HINT,
+    }, {
+        pattern: new RegExp(`^mkdir\\b.*blueprints\\/${BLUEPRINT_LIFECYCLE_DIRS}`),
+        category: 'blueprint',
+        suggestion: BLUEPRINT_HINT,
+    }, {
+        // git mv is an alternative to bare mv for tracked files — same bypass vector.
+        pattern: new RegExp(`^git\\s+mv\\b.*blueprints\\/${BLUEPRINT_LIFECYCLE_DIRS}`),
+        category: 'blueprint',
+        suggestion: BLUEPRINT_HINT,
+    }, { pattern: /^doppler run/, category: 'unknown', suggestion: ENV_HINT }, { pattern: /^DATABASE_URL=/, category: 'unknown', suggestion: ENV_HINT }, { pattern: /^vp exec\b/, category: 'unknown', suggestion: TASK_TARGET_HINT }, { pattern: /^vp run\b/, category: 'unknown', suggestion: TASK_TARGET_HINT });
+    return rules;
+}
+export const COMMAND_RULES = generateRules();
+export const SUGGESTION_MODIFIERS = [
+    {
+        pattern: /--fix-dangerous|--write.*--unsafe|--unsafe.*--write/,
+        category: 'lint',
+        suggestion: `${LINT_BASE} --fix-unsafe`,
+    },
+    { pattern: /--fix|--write/, category: 'lint', suggestion: `${LINT_BASE} --fix` },
+];
+const LOGICAL_OPERATOR_REGEX = /(?:&&|\|\||;)/;
+const VP_SCOPE_FLAG_REGEX = /\s+(?:(?:--filter|-F|--dir|-C)\s+(?:"[^"]+"|'[^']+'|\S+)|(?:--workspace-root|-w))/;
+const PNPM_SCOPE_FLAG_REGEX = /(?:\s+(?:(?:--filter|-F|--dir|-C)\s+(?:"[^"]+"|'[^']+'|\S+)|(?:--workspace-root|-w|--recursive|-r|--workspace))(?=\s|$))/;
+function stripVpScopeFlags(command) {
+    if (!command.startsWith('vp ')) {
+        return command;
+    }
+    let next = command;
+    while (VP_SCOPE_FLAG_REGEX.test(next)) {
+        const updated = next.replace(VP_SCOPE_FLAG_REGEX, '');
+        if (updated === next) {
+            break;
+        }
+        next = updated;
+    }
+    return next.replace(/\s+/g, ' ').trim();
+}
+function stripPnPmScopeFlags(command) {
+    if (!command.startsWith('pnpm ')) {
+        return command;
+    }
+    let next = command;
+    while (PNPM_SCOPE_FLAG_REGEX.test(next)) {
+        const updated = next.replace(PNPM_SCOPE_FLAG_REGEX, '');
+        if (updated === next)
+            break;
+        next = updated.replace(/\s+/g, ' ').trim();
+    }
+    return next;
+}
+function stripKnownScopeFlags(command) {
+    let normalized = command;
+    if (normalized.startsWith('vp ')) {
+        normalized = stripVpScopeFlags(normalized);
+    }
+    else if (normalized.startsWith('pnpm ')) {
+        normalized = stripPnPmScopeFlags(normalized);
+    }
+    return normalized;
+}
+/**
+ * Split a shell command string on top-level operators (&&, ||, |, ;) while
+ * correctly skipping operators that appear inside:
+ *   - single-quoted strings:  '...'
+ *   - double-quoted strings:  "..."
+ *   - $(...) command substitutions (handles nesting)
+ *   - backtick subshells: `...`
+ *
+ * This prevents heredoc or subshell content from being mistaken for real
+ * command segments (e.g. git commit -m "$(cat <<'EOF'\n...&&...\nEOF\n)").
+ */
+export function splitTopLevelCommands(command) {
+    const segments = [];
+    let current = '';
+    let depth = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let inBacktick = false;
+    let i = 0;
+    while (i < command.length) {
+        const ch = command[i];
+        const next = i + 1 < command.length ? command[i + 1] : '';
+        if (inSingleQuote) {
+            current += ch;
+            if (ch === "'")
+                inSingleQuote = false;
+            i++;
+            continue;
+        }
+        if (inBacktick) {
+            current += ch;
+            if (ch === '`')
+                inBacktick = false;
+            i++;
+            continue;
+        }
+        if (depth > 0) {
+            if (ch === '$' && next === '(') {
+                depth++;
+                current += ch + next;
+                i += 2;
+            }
+            else if (ch === ')') {
+                depth--;
+                current += ch;
+                i++;
+            }
+            else if (ch === "'") {
+                inSingleQuote = true;
+                current += ch;
+                i++;
+            }
+            else if (ch === '`') {
+                inBacktick = true;
+                current += ch;
+                i++;
+            }
+            else {
+                current += ch;
+                i++;
+            }
+            continue;
+        }
+        if (inDoubleQuote) {
+            if (ch === '"') {
+                inDoubleQuote = false;
+                current += ch;
+                i++;
+            }
+            else if (ch === '$' && next === '(') {
+                depth++;
+                current += ch + next;
+                i += 2;
+            }
+            else if (ch === '\\') {
+                current += ch + next;
+                i += 2;
+            }
+            else {
+                current += ch;
+                i++;
+            }
+            continue;
+        }
+        // Top-level context — check for operators before recording the character.
+        if (ch === "'") {
+            inSingleQuote = true;
+            current += ch;
+            i++;
+        }
+        else if (ch === '"') {
+            inDoubleQuote = true;
+            current += ch;
+            i++;
+        }
+        else if (ch === '`') {
+            inBacktick = true;
+            current += ch;
+            i++;
+        }
+        else if (ch === '$' && next === '(') {
+            depth++;
+            current += ch + next;
+            i += 2;
+        }
+        else if (ch === '&' && next === '&') {
+            const seg = current.trim();
+            if (seg)
+                segments.push(seg);
+            current = '';
+            i += 2;
+        }
+        else if (ch === '|' && next === '|') {
+            const seg = current.trim();
+            if (seg)
+                segments.push(seg);
+            current = '';
+            i += 2;
+        }
+        else if (ch === '|') {
+            const seg = current.trim();
+            if (seg)
+                segments.push(seg);
+            current = '';
+            i++;
+        }
+        else if (ch === ';') {
+            const seg = current.trim();
+            if (seg)
+                segments.push(seg);
+            current = '';
+            i++;
+        }
+        else {
+            current += ch;
+            i++;
+        }
+    }
+    const last = current.trim();
+    if (last)
+        segments.push(last);
+    return segments;
+}
+export function findMatchingRule(command) {
+    for (const variant of getCommandVariants(command)) {
+        const rule = COMMAND_RULES.find((r) => r.pattern.test(variant));
+        if (rule)
+            return rule;
+    }
+    return undefined;
+}
+export function applySuggestionModifiers(command, rule) {
+    for (const modifier of SUGGESTION_MODIFIERS) {
+        if (modifier.category === rule.category && modifier.pattern.test(command))
+            return modifier.suggestion;
+    }
+    return rule.suggestion;
+}
+export function getApprovedEquivalent(command) {
+    const rule = findMatchingRule(command);
+    if (!rule)
+        return 'repo-approved MCP/tooling entrypoint';
+    return applySuggestionModifiers(command, rule);
+}
+export function getCommandVariants(command) {
+    const normalized = command.trim();
+    const variants = normalized ? [normalized] : [];
+    if (normalized.startsWith('vp ')) {
+        const logicalSegments = normalized
+            .split(LOGICAL_OPERATOR_REGEX)
+            .map((s) => s.trim())
+            .filter(Boolean);
+        for (const segment of logicalSegments) {
+            const beforePipe = segment.split(/\s*\|\s*/)[0]?.trim();
+            if (beforePipe && beforePipe !== segment && !variants.includes(beforePipe))
+                variants.push(beforePipe);
+            if (segment !== normalized && !variants.includes(segment))
+                variants.push(segment);
+        }
+    }
+    else {
+        for (const segment of splitTopLevelCommands(normalized)) {
+            if (!variants.includes(segment))
+                variants.push(segment);
+        }
+    }
+    const initialVariantCount = variants.length;
+    for (let index = 0; index < initialVariantCount; index += 1) {
+        const variant = variants[index];
+        if (!variant)
+            continue;
+        const strippedVpVariant = stripVpScopeFlags(variant);
+        if (strippedVpVariant !== variant && !variants.includes(strippedVpVariant)) {
+            variants.push(strippedVpVariant);
+        }
+        const strippedCommandVariant = stripKnownScopeFlags(variant);
+        if (strippedCommandVariant !== variant && !variants.includes(strippedCommandVariant)) {
+            variants.push(strippedCommandVariant);
+        }
+    }
+    return variants;
+}
+export function getCommandCategory(command) {
+    return findMatchingRule(command)?.category ?? 'unknown';
+}
+function loadRedirectConfig() {
+    const repoRoot = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+    return readConfig(repoRoot)?.mcp;
+}
+export function createBlockedResult(command, rule, options = {}) {
+    const suggestion = applySuggestionModifiers(command, rule);
+    return {
+        validator: VALIDATOR_NAME,
+        passed: false,
+        message: buildRedirectMessage({
+            category: rule.category,
+            command,
+            fallbackHint: suggestion,
+            ...(options.mcpReady !== undefined ? { mcpReady: options.mcpReady } : {}),
+            mcp: options.mcp ?? loadRedirectConfig(),
+        }),
+        command,
+        suggestion,
+        category: rule.category,
+        docsRef: DOCS_REF,
+        matchedPattern: rule.pattern.source,
+    };
+}
+export function createAuditResult(command, rule, options = {}) {
+    const suggestion = applySuggestionModifiers(command, rule);
+    return {
+        validator: VALIDATOR_NAME,
+        passed: true,
+        message: `[AUDIT] Would block:\n${buildRedirectMessage({
+            category: rule.category,
+            command,
+            fallbackHint: suggestion,
+            ...(options.mcpReady !== undefined ? { mcpReady: options.mcpReady } : {}),
+            mcp: options.mcp ?? loadRedirectConfig(),
+        })}`,
+        command,
+        suggestion,
+        category: rule.category,
+        docsRef: DOCS_REF,
+        matchedPattern: rule.pattern.source,
+    };
+}
+export function validateForbiddenCommands(input) {
+    if (process.env[SKIP_ENV_VAR] === '1')
+        return createSkipResult(VALIDATOR_NAME);
+    if (!isBashInput(input))
+        return createSkipResult(VALIDATOR_NAME, 'Not a Bash command');
+    const command = getCommand(input);
+    if (!command)
+        return createSkipResult(VALIDATOR_NAME, 'No command found');
+    const rule = findMatchingRule(command);
+    if (rule) {
+        if (process.env[AUDIT_MODE_ENV] === '1')
+            return createAuditResult(command, rule);
+        return createBlockedResult(command, rule);
+    }
+    return { validator: VALIDATOR_NAME, passed: true };
+}
+//# sourceMappingURL=forbidden-commands.js.map

package/dist/esm/hooks/pretool-guard/validators/index.d.ts

@@ -0,0 +1,14 @@
+import { validateBlueprint } from './blueprint.js';
+import { validateCommandFile } from './command-file.js';
+import { validateComplexity } from './complexity.js';
+import { validateDangerousCommands } from './dangerous-commands.js';
+import { validateDocsGovernance } from './docs-governance.js';
+import { validateFileConventions } from './file-conventions.js';
+import { validateForbiddenCommands } from './forbidden-commands.js';
+import { validatePackageImports } from './package-imports.js';
+import { validatePlanFrontmatter } from './plan-frontmatter.js';
+import { validateTestQuality } from './test-quality.js';
+import { validateUxQuality } from './ux-quality.js';
+export declare const VALIDATORS: (typeof validateDocsGovernance | typeof validatePackageImports)[];
+export { validateBlueprint, validateCommandFile, validateComplexity, validateDangerousCommands, validateDocsGovernance, validateFileConventions, validateForbiddenCommands, validatePackageImports, validatePlanFrontmatter, validateTestQuality, validateUxQuality, };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/hooks/pretool-guard/validators/index.js

@@ -0,0 +1,26 @@
+import { validateBlueprint } from './blueprint.js';
+import { validateCommandFile } from './command-file.js';
+import { validateComplexity } from './complexity.js';
+import { validateDangerousCommands } from './dangerous-commands.js';
+import { validateDocsGovernance } from './docs-governance.js';
+import { validateFileConventions } from './file-conventions.js';
+import { validateForbiddenCommands } from './forbidden-commands.js';
+import { validatePackageImports } from './package-imports.js';
+import { validatePlanFrontmatter } from './plan-frontmatter.js';
+import { validateTestQuality } from './test-quality.js';
+import { validateUxQuality } from './ux-quality.js';
+export const VALIDATORS = [
+    validateForbiddenCommands,
+    validateDangerousCommands,
+    validateBlueprint,
+    validateDocsGovernance,
+    validatePlanFrontmatter,
+    validateComplexity,
+    validatePackageImports,
+    validateFileConventions,
+    validateCommandFile,
+    validateTestQuality,
+    validateUxQuality,
+];
+export { validateBlueprint, validateCommandFile, validateComplexity, validateDangerousCommands, validateDocsGovernance, validateFileConventions, validateForbiddenCommands, validatePackageImports, validatePlanFrontmatter, validateTestQuality, validateUxQuality, };
+//# sourceMappingURL=index.js.map

package/dist/esm/hooks/pretool-guard/validators/mcp-redirect.d.ts

@@ -0,0 +1,16 @@
+import type { CommandCategory } from './forbidden-commands.js';
+export interface MCPRedirectConfig {
+    serverName?: string;
+    toolPrefix?: string;
+}
+export interface MCPRedirectContext {
+    category: CommandCategory;
+    command: string;
+    mcpReady?: boolean | (() => boolean);
+    fallbackHint?: string;
+    mcp?: MCPRedirectConfig;
+}
+export declare function resolveMcpReady(value: MCPRedirectContext['mcpReady']): boolean;
+export declare function resolveMcpConfig(mcp: MCPRedirectContext['mcp']): Required<MCPRedirectConfig>;
+export declare function buildRedirectMessage(ctx: MCPRedirectContext): string;
+//# sourceMappingURL=mcp-redirect.d.ts.map

package/dist/esm/hooks/pretool-guard/validators/mcp-redirect.js

@@ -0,0 +1,50 @@
+import { isMcpReady } from '#hooks/shared/mcp-sentinel';
+const DEFAULT_SERVER_NAME = 'webpresso';
+const DEFAULT_TOOL_PREFIX = 'wp_';
+export function resolveMcpReady(value) {
+    if (typeof value === 'function')
+        return value();
+    if (typeof value === 'boolean')
+        return value;
+    return isMcpReady();
+}
+export function resolveMcpConfig(mcp) {
+    return {
+        serverName: mcp?.serverName?.trim() || DEFAULT_SERVER_NAME,
+        toolPrefix: mcp?.toolPrefix?.trim() || DEFAULT_TOOL_PREFIX,
+    };
+}
+function toolSuffixForCategory(category) {
+    switch (category) {
+        case 'test':
+            return 'test';
+        case 'lint':
+            return 'lint';
+        case 'typecheck':
+            return 'typecheck';
+        case 'format':
+            return 'format';
+        case 'e2e':
+            return 'e2e';
+        case 'blueprint':
+            return 'blueprint';
+        case 'unknown':
+        default:
+            return 'qa';
+    }
+}
+export function buildRedirectMessage(ctx) {
+    const fallbackHint = ctx.fallbackHint ?? 'repo-approved MCP/tooling entrypoint';
+    if (!resolveMcpReady(ctx.mcpReady)) {
+        return `"${ctx.command}" denied — MCP not ready. Use: ${fallbackHint}`;
+    }
+    const { serverName, toolPrefix } = resolveMcpConfig(ctx.mcp);
+    const toolMatcher = `mcp__${serverName}__${toolPrefix}${toolSuffixForCategory(ctx.category)}(...)`;
+    return [
+        `"${ctx.command}" denied — use wp MCP tool:`,
+        `  ${toolMatcher}`,
+        'Returns structured, summary-first results. Raw output is clipped; overflow may include a log path for deeper investigation.',
+        `Fallback if MCP unavailable: ${fallbackHint}`,
+    ].join('\n');
+}
+//# sourceMappingURL=mcp-redirect.js.map

package/dist/esm/hooks/pretool-guard/validators/package-imports.d.ts

@@ -0,0 +1,10 @@
+import type { ToolInput, ValidationResult } from '#hooks/shared/types';
+import type { DuplicateFunctionResult } from './package-imports.types.js';
+export type { DuplicateFunctionResult } from './package-imports.types.js';
+export interface ValidatePackageImportsOptions {
+    profile?: 'generic' | 'webpresso';
+}
+export declare const VALIDATOR_NAME = "package-imports";
+export declare const SKIP_ENV_VAR = "PACKAGE_IMPORTS_SKIP";
+export declare function validatePackageImports(input: ToolInput, options?: ValidatePackageImportsOptions): ValidationResult | DuplicateFunctionResult;
+//# sourceMappingURL=package-imports.d.ts.map

package/dist/esm/hooks/pretool-guard/validators/package-imports.js

@@ -0,0 +1,36 @@
+import { createBlockedResult, findDuplicateFunctions, getSharedFunctions, } from '#quality-engine/package-import-rules';
+import { getContent, getFilePath } from '#hooks/shared/types';
+import { createSkipResult } from './skip-result.js';
+export const VALIDATOR_NAME = 'package-imports';
+export const SKIP_ENV_VAR = 'PACKAGE_IMPORTS_SKIP';
+const IMPL_EXTENSIONS = /\.(ts|tsx|js|jsx)$/;
+export function validatePackageImports(input, options = {}) {
+    if (process.env[SKIP_ENV_VAR] === '1')
+        return createSkipResult(VALIDATOR_NAME);
+    const filePath = getFilePath(input);
+    const content = getContent(input);
+    const profile = options.profile ?? 'generic';
+    if (!content || !filePath)
+        return { validator: VALIDATOR_NAME, passed: true };
+    if (!IMPL_EXTENSIONS.test(filePath))
+        return { validator: VALIDATOR_NAME, passed: true };
+    const sharedFunctions = getSharedFunctions(profile);
+    if (sharedFunctions.some((fn) => filePath.includes(`/${fn.source}/`) ||
+        filePath.includes(`/${fn.package.replace('@', '').replace('/', '-')}/`))) {
+        return { validator: VALIDATOR_NAME, passed: true };
+    }
+    const duplicate = findDuplicateFunctions(content, { profile })[0];
+    if (!duplicate)
+        return { validator: VALIDATOR_NAME, passed: true };
+    const blocked = createBlockedResult(duplicate);
+    return {
+        validator: VALIDATOR_NAME,
+        passed: false,
+        message: `Local implementation of "${duplicate.name}" detected. ${blocked.message}`,
+        functionName: blocked.functionName,
+        suggestion: blocked.suggestion,
+        package: blocked.package,
+        source: blocked.source,
+    };
+}
+//# sourceMappingURL=package-imports.js.map

package/dist/esm/hooks/pretool-guard/validators/package-imports.types.d.ts

@@ -0,0 +1,8 @@
+import type { ValidationResult } from '#hooks/shared/types';
+export interface DuplicateFunctionResult extends ValidationResult {
+    functionName: string;
+    suggestion: string;
+    package: string;
+    source: string;
+}
+//# sourceMappingURL=package-imports.types.d.ts.map

package/dist/esm/hooks/pretool-guard/validators/package-imports.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=package-imports.types.js.map

package/dist/esm/hooks/pretool-guard/validators/path-contract.d.ts

@@ -0,0 +1,15 @@
+export declare const BLUEPRINTS_ROOT = "webpresso/blueprints";
+export declare const TECH_DEBT_ROOT = "webpresso/tech-debt";
+/**
+ * Returns true if the path is under any accepted blueprints root.
+ * Pass `blueprintsRoot` to restrict to a single configured root.
+ */
+export declare function isBlueprintPath(filePath: string, blueprintsRoot?: string): boolean;
+export declare function getNonCanonicalPlanningPathViolation(filePath: string, blueprintsRoot?: string, techDebtRoot?: string): string | null;
+/**
+ * Returns true if the path is the canonical `_overview.md` location for any
+ * accepted blueprints root layout (or the explicitly provided root).
+ */
+export declare function isCanonicalBlueprintOverviewPath(filePath: string, blueprintsRoot?: string): boolean;
+export declare function getBlueprintPathViolation(filePath: string, blueprintsRoot?: string): string | null;
+//# sourceMappingURL=path-contract.d.ts.map