@webpieces/hook-runtime 0.0.1

package/src/core/file-evaluation.d.ts

@@ -0,0 +1,11 @@
+import { LoadedConfig } from '@webpieces/rules-config';
+import { ToolKind, NormalizedToolInput } from '../protocol';
+import { Rule, BlockedResult } from './types';
+export declare class HookRuleSet {
+    readonly rules: readonly Rule[];
+    readonly configuredRules: readonly Rule[];
+    constructor(rules: readonly Rule[], configuredRules: readonly Rule[]);
+}
+export declare class HookFileEvaluation {
+    evaluate(toolKind: ToolKind, input: NormalizedToolInput, loaded: LoadedConfig, contributions: HookRuleSet): BlockedResult | null;
+}

package/src/core/file-evaluation.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookFileEvaluation = exports.HookRuleSet = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const rules_config_1 = require("@webpieces/rules-config");
+const types_1 = require("./types");
+const target_tree_1 = require("./target-tree");
+const delete_scoped_rules_1 = require("./delete-scoped-rules");
+const excluded_paths_1 = require("./excluded-paths");
+const build_context_1 = require("./build-context");
+const rule_evaluation_1 = require("./rule-evaluation");
+const report_1 = require("./report");
+const root_manifest_1 = require("./root-manifest");
+class HookRuleSet {
+    rules;
+    configuredRules;
+    constructor(rules, configuredRules) {
+        this.rules = rules;
+        this.configuredRules = configuredRules;
+    }
+}
+exports.HookRuleSet = HookRuleSet;
+class HookFileEvaluation {
+    evaluate(toolKind, input, loaded, contributions) {
+        if (loaded.configPath === null)
+            return null;
+        if (path.resolve(input.filePath) === path.resolve(loaded.configPath)
+            || (0, root_manifest_1.isRootManifest)(input.filePath) || new rules_config_1.HomeConfigService().isHomeConfigPath(input.filePath))
+            return null;
+        const root = path.dirname(loaded.configPath);
+        const governed = new target_tree_1.TargetTreeResolver().governedPath(input.filePath, root);
+        const rules = new delete_scoped_rules_1.DeleteScopedRules().narrow(toolKind, (0, excluded_paths_1.filterByExcludedPaths)(contributions.rules, governed, loaded.excludePaths));
+        if (rules.length === 0)
+            return null;
+        const sync = (0, rule_evaluation_1.checkConfigSync)(rules.filter((rule) => contributions.configuredRules.includes(rule)), loaded.rulesConfig, loaded.ruleRegistry);
+        if (sync)
+            return sync;
+        const contexts = (0, build_context_1.buildContexts)(toolKind, input, root, governed);
+        const groups = [...(0, rule_evaluation_1.runEditRules)(rules, contexts.editContexts), ...(0, rule_evaluation_1.runFileRules)(rules, contexts.fileContext)];
+        return groups.length === 0 ? null : new types_1.BlockedResult((0, report_1.formatReport)(governed.relativePath, groups));
+    }
+}
+exports.HookFileEvaluation = HookFileEvaluation;
+//# sourceMappingURL=file-evaluation.js.map

package/src/core/file-evaluation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-evaluation.js","sourceRoot":"","sources":["../../../../../../packages/tooling/hook-runtime/src/core/file-evaluation.ts"],"names":[],"mappings":";;;;AAAA,mDAA6B;AAC7B,0DAA0E;AAE1E,mCAA8C;AAE9C,+CAAmD;AACnD,+DAA0D;AAC1D,qDAAyD;AACzD,mDAAgD;AAChD,uDAAgF;AAChF,qCAAwC;AACxC,mDAAiD;AAEjD,MAAa,WAAW;IACC;IAAiC;IAAtD,YAAqB,KAAsB,EAAW,eAAgC;QAAjE,UAAK,GAAL,KAAK,CAAiB;QAAW,oBAAe,GAAf,eAAe,CAAiB;IAAG,CAAC;CAC7F;AAFD,kCAEC;AAED,MAAa,kBAAkB;IAC3B,QAAQ,CAAC,QAAkB,EAAE,KAA0B,EAAE,MAAoB,EAAE,aAA0B;QACrG,IAAI,MAAM,CAAC,UAAU,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QAC5C,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC;eAC7D,IAAA,8BAAc,EAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,gCAAiB,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;QAC/G,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC7C,MAAM,QAAQ,GAAG,IAAI,gCAAkB,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC7E,MAAM,KAAK,GAAG,IAAI,uCAAiB,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAA,sCAAqB,EAAC,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;QAClI,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACpC,MAAM,IAAI,GAAG,IAAA,iCAAe,EAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAU,EAAW,EAAE,CAAC,aAAa,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC;QAC3J,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;QACtB,MAAM,QAAQ,GAAG,IAAA,6BAAa,EAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;QAChE,MAAM,MAAM,GAAG,CAAC,GAAG,IAAA,8BAAY,EAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,GAAG,IAAA,8BAAY,EAAC,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;QAC7G,OAAO,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,qBAAa,CAAC,IAAA,qBAAY,EAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IACvG,CAAC;CACJ;AAfD,gDAeC","sourcesContent":["import * as path from 'path';\nimport { LoadedConfig, HomeConfigService } from '@webpieces/rules-config';\nimport { ToolKind, NormalizedToolInput } from '../protocol';\nimport { Rule, BlockedResult } from './types';\n\nimport { TargetTreeResolver } from './target-tree';\nimport { DeleteScopedRules } from './delete-scoped-rules';\nimport { filterByExcludedPaths } from './excluded-paths';\nimport { buildContexts } from './build-context';\nimport { checkConfigSync, runEditRules, runFileRules } from './rule-evaluation';\nimport { formatReport } from './report';\nimport { isRootManifest } from './root-manifest';\n\nexport class HookRuleSet {\n    constructor(readonly rules: readonly Rule[], readonly configuredRules: readonly Rule[]) {}\n}\n\nexport class HookFileEvaluation {\n    evaluate(toolKind: ToolKind, input: NormalizedToolInput, loaded: LoadedConfig, contributions: HookRuleSet): BlockedResult | null {\n        if (loaded.configPath === null) return null;\n        if (path.resolve(input.filePath) === path.resolve(loaded.configPath)\n            || isRootManifest(input.filePath) || new HomeConfigService().isHomeConfigPath(input.filePath)) return null;\n        const root = path.dirname(loaded.configPath);\n        const governed = new TargetTreeResolver().governedPath(input.filePath, root);\n        const rules = new DeleteScopedRules().narrow(toolKind, filterByExcludedPaths(contributions.rules, governed, loaded.excludePaths));\n        if (rules.length === 0) return null;\n        const sync = checkConfigSync(rules.filter((rule: Rule): boolean => contributions.configuredRules.includes(rule)), loaded.rulesConfig, loaded.ruleRegistry);\n        if (sync) return sync;\n        const contexts = buildContexts(toolKind, input, root, governed);\n        const groups = [...runEditRules(rules, contexts.editContexts), ...runFileRules(rules, contexts.fileContext)];\n        return groups.length === 0 ? null : new BlockedResult(formatReport(governed.relativePath, groups));\n    }\n}\n"]}

package/src/core/fix-hint.d.ts

@@ -0,0 +1,40 @@
+import { Option } from '@webpieces/rules-config';
+/**
+ * Framework-owned `// webpieces-disable` escape hatch for a rule, gated by the team's
+ * `disableAllowed` config (default true). `comment` is the exact suppress syntax to show
+ * (usually `// webpieces-disable <rule> -- <reason>`; max-file-lines uses the eslint form).
+ * When `allowed` is false the framework prints a "must be followed" line instead of the escape.
+ */
+export declare class DisableEscape {
+    readonly allowed: boolean;
+    readonly comment: string;
+    constructor(allowed: boolean, comment: string);
+}
+/**
+ * Structured fix guidance shown under a violation in a blocked-write / blocked-bash report.
+ *
+ * A rule authors its user-facing text once here: a required `violation` (the "what's wrong"
+ * line — the rule-level default for the `→` line; a dynamic per-occurrence `Violation.message`
+ * overrides it), a `mainMessage` (fix prose, or a lead-in to the options), an optional list of
+ * genuinely distinct `fixOptions`, and — for the disable-able code-style rules — a framework-
+ * owned `escape`.
+ *
+ * The framework (report.ts / `formatFixOptions`) — not the rule author — owns the "Fix Option N:"
+ * numbering, the "(preferred)" tag, and the escape/`disableAllowed` rendering. So a multi-line
+ * message can never be mis-split into fake options, and authors never hand-write those labels.
+ *
+ * `Option` is NOT defined here: it lives in `@webpieces/rules-config` (`fix-option.ts`) because
+ * `RuleFailError` — thrown by BOTH engines — carries the same class. One cure shape, one definition,
+ * one import path. Import it from `@webpieces/rules-config`, never from this module.
+ */
+export declare class FixHint {
+    /** Required: the "what's wrong" line (rule-level default for the `→` line). */
+    readonly violation: string;
+    /** Required (may be ''): fix prose, or a lead-in to the options. Multi-line ok. */
+    readonly mainMessage: string;
+    /** Real fixes only — NEVER the disable escape (that is `escape`). */
+    readonly fixOptions: readonly Option[];
+    /** Present only for disable-able rules; absent for guards. */
+    readonly escape?: DisableEscape;
+    constructor(violation: string, mainMessage: string, fixOptions?: readonly Option[], escape?: DisableEscape);
+}

package/src/core/fix-hint.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixHint = exports.DisableEscape = void 0;
+/**
+ * Framework-owned `// webpieces-disable` escape hatch for a rule, gated by the team's
+ * `disableAllowed` config (default true). `comment` is the exact suppress syntax to show
+ * (usually `// webpieces-disable <rule> -- <reason>`; max-file-lines uses the eslint form).
+ * When `allowed` is false the framework prints a "must be followed" line instead of the escape.
+ */
+class DisableEscape {
+    allowed;
+    comment;
+    constructor(allowed, comment) {
+        this.allowed = allowed;
+        this.comment = comment;
+    }
+}
+exports.DisableEscape = DisableEscape;
+/**
+ * Structured fix guidance shown under a violation in a blocked-write / blocked-bash report.
+ *
+ * A rule authors its user-facing text once here: a required `violation` (the "what's wrong"
+ * line — the rule-level default for the `→` line; a dynamic per-occurrence `Violation.message`
+ * overrides it), a `mainMessage` (fix prose, or a lead-in to the options), an optional list of
+ * genuinely distinct `fixOptions`, and — for the disable-able code-style rules — a framework-
+ * owned `escape`.
+ *
+ * The framework (report.ts / `formatFixOptions`) — not the rule author — owns the "Fix Option N:"
+ * numbering, the "(preferred)" tag, and the escape/`disableAllowed` rendering. So a multi-line
+ * message can never be mis-split into fake options, and authors never hand-write those labels.
+ *
+ * `Option` is NOT defined here: it lives in `@webpieces/rules-config` (`fix-option.ts`) because
+ * `RuleFailError` — thrown by BOTH engines — carries the same class. One cure shape, one definition,
+ * one import path. Import it from `@webpieces/rules-config`, never from this module.
+ */
+class FixHint {
+    /** Required: the "what's wrong" line (rule-level default for the `→` line). */
+    violation;
+    /** Required (may be ''): fix prose, or a lead-in to the options. Multi-line ok. */
+    mainMessage;
+    /** Real fixes only — NEVER the disable escape (that is `escape`). */
+    fixOptions;
+    /** Present only for disable-able rules; absent for guards. */
+    escape;
+    constructor(violation, mainMessage, fixOptions = [], escape) {
+        this.violation = violation;
+        this.mainMessage = mainMessage;
+        this.fixOptions = fixOptions;
+        this.escape = escape;
+    }
+}
+exports.FixHint = FixHint;
+//# sourceMappingURL=fix-hint.js.map

package/src/core/fix-hint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-hint.js","sourceRoot":"","sources":["../../../../../../packages/tooling/hook-runtime/src/core/fix-hint.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACH,MAAa,aAAa;IACb,OAAO,CAAU;IACjB,OAAO,CAAS;IAEzB,YAAY,OAAgB,EAAE,OAAe;QACzC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAC3B,CAAC;CACJ;AARD,sCAQC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,OAAO;IAChB,+EAA+E;IACtE,SAAS,CAAS;IAC3B,mFAAmF;IAC1E,WAAW,CAAS;IAC7B,qEAAqE;IAC5D,UAAU,CAAoB;IACvC,8DAA8D;IACrD,MAAM,CAAiB;IAEhC,YACI,SAAiB,EACjB,WAAmB,EACnB,aAAgC,EAAE,EAClC,MAAsB;QAEtB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;CACJ;AArBD,0BAqBC","sourcesContent":["import { Option } from '@webpieces/rules-config';\n\n/**\n * Framework-owned `// webpieces-disable` escape hatch for a rule, gated by the team's\n * `disableAllowed` config (default true). `comment` is the exact suppress syntax to show\n * (usually `// webpieces-disable <rule> -- <reason>`; max-file-lines uses the eslint form).\n * When `allowed` is false the framework prints a \"must be followed\" line instead of the escape.\n */\nexport class DisableEscape {\n    readonly allowed: boolean;\n    readonly comment: string;\n\n    constructor(allowed: boolean, comment: string) {\n        this.allowed = allowed;\n        this.comment = comment;\n    }\n}\n\n/**\n * Structured fix guidance shown under a violation in a blocked-write / blocked-bash report.\n *\n * A rule authors its user-facing text once here: a required `violation` (the \"what's wrong\"\n * line — the rule-level default for the `→` line; a dynamic per-occurrence `Violation.message`\n * overrides it), a `mainMessage` (fix prose, or a lead-in to the options), an optional list of\n * genuinely distinct `fixOptions`, and — for the disable-able code-style rules — a framework-\n * owned `escape`.\n *\n * The framework (report.ts / `formatFixOptions`) — not the rule author — owns the \"Fix Option N:\"\n * numbering, the \"(preferred)\" tag, and the escape/`disableAllowed` rendering. So a multi-line\n * message can never be mis-split into fake options, and authors never hand-write those labels.\n *\n * `Option` is NOT defined here: it lives in `@webpieces/rules-config` (`fix-option.ts`) because\n * `RuleFailError` — thrown by BOTH engines — carries the same class. One cure shape, one definition,\n * one import path. Import it from `@webpieces/rules-config`, never from this module.\n */\nexport class FixHint {\n    /** Required: the \"what's wrong\" line (rule-level default for the `→` line). */\n    readonly violation: string;\n    /** Required (may be ''): fix prose, or a lead-in to the options. Multi-line ok. */\n    readonly mainMessage: string;\n    /** Real fixes only — NEVER the disable escape (that is `escape`). */\n    readonly fixOptions: readonly Option[];\n    /** Present only for disable-able rules; absent for guards. */\n    readonly escape?: DisableEscape;\n\n    constructor(\n        violation: string,\n        mainMessage: string,\n        fixOptions: readonly Option[] = [],\n        escape?: DisableEscape,\n    ) {\n        this.violation = violation;\n        this.mainMessage = mainMessage;\n        this.fixOptions = fixOptions;\n        this.escape = escape;\n    }\n}\n"]}

package/src/core/glob.d.ts

@@ -0,0 +1 @@
+export declare function globMatches(pattern: string, filePath: string): boolean;

package/src/core/glob.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globMatches = globMatches;
+// webpieces-disable no-function-outside-class -- existing stateless module helper moved intact with its callers; ownership extraction preserves its functional API
+function globMatches(pattern, filePath) {
+    const regex = globToRegex(pattern);
+    return regex.test(filePath);
+}
+// webpieces-disable no-function-outside-class -- existing stateless module helper moved intact with its callers; ownership extraction preserves its functional API
+function globToRegex(pattern) {
+    let re = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                re += '.*';
+                i += 2;
+                if (pattern[i] === '/')
+                    i += 1;
+                continue;
+            }
+            re += '[^/]*';
+            i += 1;
+            continue;
+        }
+        if (ch === '?') {
+            re += '[^/]';
+            i += 1;
+            continue;
+        }
+        if ('.+^$(){}|[]\\'.includes(ch)) {
+            re += '\\' + ch;
+            i += 1;
+            continue;
+        }
+        re += ch;
+        i += 1;
+    }
+    return new RegExp('^' + re + '$');
+}
+//# sourceMappingURL=glob.js.map

package/src/core/glob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.js","sourceRoot":"","sources":["../../../../../../packages/tooling/hook-runtime/src/core/glob.ts"],"names":[],"mappings":";;AACA,kCAGC;AAJD,mKAAmK;AACnK,SAAgB,WAAW,CAAC,OAAe,EAAE,QAAgB;IACzD,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC;AAED,mKAAmK;AACnK,SAAS,WAAW,CAAC,OAAe;IAChC,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;QACxB,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YACb,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;gBACzB,EAAE,IAAI,IAAI,CAAC;gBACX,CAAC,IAAI,CAAC,CAAC;gBACP,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG;oBAAE,CAAC,IAAI,CAAC,CAAC;gBAC/B,SAAS;YACb,CAAC;YACD,EAAE,IAAI,OAAO,CAAC;YACd,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACb,CAAC;QACD,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YACb,EAAE,IAAI,MAAM,CAAC;YACb,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACb,CAAC;QACD,IAAI,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;YAC/B,EAAE,IAAI,IAAI,GAAG,EAAE,CAAC;YAChB,CAAC,IAAI,CAAC,CAAC;YACP,SAAS;QACb,CAAC;QACD,EAAE,IAAI,EAAE,CAAC;QACT,CAAC,IAAI,CAAC,CAAC;IACX,CAAC;IACD,OAAO,IAAI,MAAM,CAAC,GAAG,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;AACtC,CAAC","sourcesContent":["// webpieces-disable no-function-outside-class -- existing stateless module helper moved intact with its callers; ownership extraction preserves its functional API\nexport function globMatches(pattern: string, filePath: string): boolean {\n    const regex = globToRegex(pattern);\n    return regex.test(filePath);\n}\n\n// webpieces-disable no-function-outside-class -- existing stateless module helper moved intact with its callers; ownership extraction preserves its functional API\nfunction globToRegex(pattern: string): RegExp {\n    let re = '';\n    let i = 0;\n    while (i < pattern.length) {\n        const ch = pattern[i];\n        if (ch === '*') {\n            if (pattern[i + 1] === '*') {\n                re += '.*';\n                i += 2;\n                if (pattern[i] === '/') i += 1;\n                continue;\n            }\n            re += '[^/]*';\n            i += 1;\n            continue;\n        }\n        if (ch === '?') {\n            re += '[^/]';\n            i += 1;\n            continue;\n        }\n        if ('.+^$(){}|[]\\\\'.includes(ch)) {\n            re += '\\\\' + ch;\n            i += 1;\n            continue;\n        }\n        re += ch;\n        i += 1;\n    }\n    return new RegExp('^' + re + '$');\n}\n"]}

package/src/core/report.d.ts

@@ -0,0 +1,21 @@
+import type { RuleGroup } from './types';
+/**
+ * How the report names the tool it just blocked. Data-only, so a class (per CLAUDE.md).
+ *
+ * WHY it is a parameter: the header and footer used to be hard-coded to "write". A blocked READ
+ * therefore printed "\u274c webpieces ai-hooks blocked this write:" and closed with "This is a pre-write
+ * check. Fix and retry the Write/Edit." \u2014 observed live, and actively misleading, because the agent is
+ * told to fix and retry the one tool it did not use. A blocked Bash command printed the same thing
+ * against the path `<bash>`.
+ */
+export declare class ReportSubject {
+    /** Fills "blocked this ___". */
+    noun: string;
+    /** The closing line: what kind of check this was and which tool to retry. */
+    footer: string;
+    constructor(noun: string, footer: string);
+}
+export declare const WRITE_SUBJECT: ReportSubject;
+export declare const READ_SUBJECT: ReportSubject;
+export declare const BASH_SUBJECT: ReportSubject;
+export declare function formatReport(relativePath: string, ruleGroups: readonly RuleGroup[], subject?: ReportSubject): string;

package/src/core/report.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASH_SUBJECT = exports.READ_SUBJECT = exports.WRITE_SUBJECT = exports.ReportSubject = void 0;
+exports.formatReport = formatReport;
+const rules_config_1 = require("@webpieces/rules-config");
+/**
+ * How the report names the tool it just blocked. Data-only, so a class (per CLAUDE.md).
+ *
+ * WHY it is a parameter: the header and footer used to be hard-coded to "write". A blocked READ
+ * therefore printed "\u274c webpieces ai-hooks blocked this write:" and closed with "This is a pre-write
+ * check. Fix and retry the Write/Edit." \u2014 observed live, and actively misleading, because the agent is
+ * told to fix and retry the one tool it did not use. A blocked Bash command printed the same thing
+ * against the path `<bash>`.
+ */
+class ReportSubject {
+    /** Fills "blocked this ___". */
+    noun;
+    /** The closing line: what kind of check this was and which tool to retry. */
+    footer;
+    constructor(noun, footer) {
+        this.noun = noun;
+        this.footer = footer;
+    }
+}
+exports.ReportSubject = ReportSubject;
+exports.WRITE_SUBJECT = new ReportSubject('write', 'This is a pre-write check. Fix and retry the Write/Edit.');
+exports.READ_SUBJECT = new ReportSubject('read', 'This is a pre-read check. Follow the fix above, then retry the Read.');
+exports.BASH_SUBJECT = new ReportSubject('command', 'This is a pre-run check. Follow the fix above, then retry the command.');
+// webpieces-disable no-function-outside-class -- pre-existing shape: this whole module is the report formatter as module-scope functions, and a lone class here would break it
+function formatReport(relativePath, ruleGroups, subject = exports.WRITE_SUBJECT) {
+    const lines = [];
+    lines.push(`\u274c webpieces ai-hooks blocked this ${subject.noun}: ${relativePath}`);
+    lines.push('');
+    for (const group of ruleGroups) {
+        const count = group.violations.length;
+        const label = count === 1 ? '1 violation' : `${count} violations`;
+        lines.push(`[${group.ruleName}] (${label})`);
+        const fh = group.fixHint;
+        for (const v of group.violations) {
+            const editPrefix = formatEditPrefix(v);
+            lines.push(`  ${editPrefix}L${String(v.line)}:  ${v.snippet}`);
+            // Per-occurrence override (dynamic rules), else the rule-level FixHint.violation.
+            lines.push(`    \u2192 ${v.message ?? fh.violation}`);
+        }
+        // mainMessage may be '' (guidance already on the violation line) \u2014 skip when empty.
+        if (fh.mainMessage)
+            for (const l of fh.mainMessage.split('\n'))
+                lines.push(`  ${l}`);
+        // "Fix Option N:" numbering + "(preferred)" are framework-owned so a multi-line message
+        // can never become fake options and authors never hand-write those labels. ONE renderer
+        // (`formatFixOptions`, in rules-config) serves this report, the thrown-rule path in
+        // runner.ts and the build-time console in code-rules.
+        for (const l of (0, rules_config_1.formatFixOptions)(fh.fixOptions))
+            lines.push(l);
+        // Framework-owned disable escape (only the 9 disable-able code-style rules set this).
+        if (fh.escape) {
+            lines.push(fh.escape.allowed
+                ? `  Escape (if truly needed): ${fh.escape.comment}`
+                : '  \u{1F512} The team disabled escaping via webpieces-disable for this rule (disableAllowed:false) — it must be followed.');
+        }
+        lines.push('');
+    }
+    lines.push(subject.footer);
+    lines.push('');
+    return lines.join('\n');
+}
+// webpieces-disable no-function-outside-class -- existing stateless module helper moved intact with its callers; ownership extraction preserves its functional API
+function formatEditPrefix(v) {
+    if (v.editIndex !== undefined && v.editCount !== undefined && v.editCount > 1) {
+        return `edit ${String(v.editIndex + 1)}/${String(v.editCount)} `;
+    }
+    return '';
+}
+//# sourceMappingURL=report.js.map

package/src/core/report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../../../../../../packages/tooling/hook-runtime/src/core/report.ts"],"names":[],"mappings":"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","sourcesContent":["import type { RuleGroup, Violation } from './types';\nimport { formatFixOptions } from '@webpieces/rules-config';\n\n/**\n * How the report names the tool it just blocked. Data-only, so a class (per CLAUDE.md).\n *\n * WHY it is a parameter: the header and footer used to be hard-coded to \"write\". A blocked READ\n * therefore printed \"\\u274c webpieces ai-hooks blocked this write:\" and closed with \"This is a pre-write\n * check. Fix and retry the Write/Edit.\" \\u2014 observed live, and actively misleading, because the agent is\n * told to fix and retry the one tool it did not use. A blocked Bash command printed the same thing\n * against the path `<bash>`.\n */\nexport class ReportSubject {\n    /** Fills \"blocked this ___\". */\n    noun: string;\n    /** The closing line: what kind of check this was and which tool to retry. */\n    footer: string;\n\n    constructor(noun: string, footer: string) {\n        this.noun = noun;\n        this.footer = footer;\n    }\n}\n\nexport const WRITE_SUBJECT = new ReportSubject(\n    'write', 'This is a pre-write check. Fix and retry the Write/Edit.');\nexport const READ_SUBJECT = new ReportSubject(\n    'read', 'This is a pre-read check. Follow the fix above, then retry the Read.');\nexport const BASH_SUBJECT = new ReportSubject(\n    'command', 'This is a pre-run check. Follow the fix above, then retry the command.');\n\n// webpieces-disable no-function-outside-class -- pre-existing shape: this whole module is the report formatter as module-scope functions, and a lone class here would break it\nexport function formatReport(\n    relativePath: string,\n    ruleGroups: readonly RuleGroup[],\n    subject: ReportSubject = WRITE_SUBJECT,\n): string {\n    const lines: string[] = [];\n    lines.push(`\\u274c webpieces ai-hooks blocked this ${subject.noun}: ${relativePath}`);\n    lines.push('');\n\n    for (const group of ruleGroups) {\n        const count = group.violations.length;\n        const label = count === 1 ? '1 violation' : `${count} violations`;\n        lines.push(`[${group.ruleName}] (${label})`);\n        const fh = group.fixHint;\n        for (const v of group.violations) {\n            const editPrefix = formatEditPrefix(v);\n            lines.push(`  ${editPrefix}L${String(v.line)}:  ${v.snippet}`);\n            // Per-occurrence override (dynamic rules), else the rule-level FixHint.violation.\n            lines.push(`    \\u2192 ${v.message ?? fh.violation}`);\n        }\n        // mainMessage may be '' (guidance already on the violation line) \\u2014 skip when empty.\n        if (fh.mainMessage) for (const l of fh.mainMessage.split('\\n')) lines.push(`  ${l}`);\n        // \"Fix Option N:\" numbering + \"(preferred)\" are framework-owned so a multi-line message\n        // can never become fake options and authors never hand-write those labels. ONE renderer\n        // (`formatFixOptions`, in rules-config) serves this report, the thrown-rule path in\n        // runner.ts and the build-time console in code-rules.\n        for (const l of formatFixOptions(fh.fixOptions)) lines.push(l);\n        // Framework-owned disable escape (only the 9 disable-able code-style rules set this).\n        if (fh.escape) {\n            lines.push(fh.escape.allowed\n                ? `  Escape (if truly needed): ${fh.escape.comment}`\n                : '  \\u{1F512} The team disabled escaping via webpieces-disable for this rule (disableAllowed:false) — it must be followed.');\n        }\n        lines.push('');\n    }\n\n    lines.push(subject.footer);\n    lines.push('');\n    return lines.join('\\n');\n}\n\n// webpieces-disable no-function-outside-class -- existing stateless module helper moved intact with its callers; ownership extraction preserves its functional API\nfunction formatEditPrefix(v: Violation): string {\n    if (v.editIndex !== undefined && v.editCount !== undefined && v.editCount > 1) {\n        return `edit ${String(v.editIndex + 1)}/${String(v.editCount)} `;\n    }\n    return '';\n}\n"]}

package/src/core/root-manifest.d.ts

@@ -0,0 +1 @@
+export declare function isRootManifest(filePath: string): boolean;

package/src/core/root-manifest.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRootManifest = isRootManifest;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const rules_config_1 = require("@webpieces/rules-config");
+// webpieces-disable no-function-outside-class -- existing stateless filesystem predicate shared by both hook products
+function isRootManifest(filePath) {
+    if (!rules_config_1.MANIFEST_FILENAMES.has(path.basename(filePath)))
+        return false;
+    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+    try {
+        return fs.existsSync(path.join(path.dirname(filePath), rules_config_1.CONFIG_FILENAME));
+    }
+    catch (err) {
+        //const error = toError(err); best-effort on a blocking path: unreadable is NOT a root manifest
+        return false;
+    }
+}
+//# sourceMappingURL=root-manifest.js.map

package/src/core/root-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-manifest.js","sourceRoot":"","sources":["../../../../../../packages/tooling/hook-runtime/src/core/root-manifest.ts"],"names":[],"mappings":";;AAKA,wCASC;;AAdD,+CAAyB;AACzB,mDAA6B;AAC7B,0DAA8E;AAE9E,sHAAsH;AACtH,SAAgB,cAAc,CAAC,QAAgB;IAC3C,IAAI,CAAC,iCAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IACnE,8DAA8D;IAC9D,IAAI,CAAC;QACD,OAAO,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,8BAAe,CAAC,CAAC,CAAC;IAC7E,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACpB,+FAA+F;QAC/F,OAAO,KAAK,CAAC;IACjB,CAAC;AACL,CAAC","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { MANIFEST_FILENAMES, CONFIG_FILENAME } from '@webpieces/rules-config';\n\n// webpieces-disable no-function-outside-class -- existing stateless filesystem predicate shared by both hook products\nexport function isRootManifest(filePath: string): boolean {\n    if (!MANIFEST_FILENAMES.has(path.basename(filePath))) return false;\n    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions\n    try {\n        return fs.existsSync(path.join(path.dirname(filePath), CONFIG_FILENAME));\n    } catch (err: unknown) {\n        //const error = toError(err); best-effort on a blocking path: unreadable is NOT a root manifest\n        return false;\n    }\n}\n"]}

package/src/core/rule-base.d.ts

@@ -0,0 +1,40 @@
+import { BaseRuleConfig } from '@webpieces/rules-sdk';
+import { AbstractRule, RuleOptions } from '@webpieces/rules-config';
+import type { EditContext, BashContext, FileContext, Violation, Rule } from './types';
+import type { FixHint } from './fix-hint';
+/**
+ * A concrete, instantiable BaseRuleConfig used as a fallback when a built-in rule has no
+ * entry in webpieces.config.json yet. It carries no values, so the rule's `description`,
+ * `fixHint`, and `defaultOptions` (which are config-independent) are still readable for the
+ * out-of-sync report — the rule never actually runs in that state (the sync check blocks first).
+ */
+export declare class EmptyRuleConfig extends BaseRuleConfig {
+}
+/**
+ * Scope-specific base for edit rules. Extends the shared AbstractRule (which owns `name`,
+ * the typed `config`, and `shouldRun()`), and adds the ai-hook execution surface.
+ */
+export declare abstract class EditRuleBase<C extends BaseRuleConfig> extends AbstractRule<C> implements Rule {
+    readonly scope: "edit";
+    readonly files: readonly string[];
+    readonly defaultOptions: RuleOptions;
+    abstract readonly description: string;
+    abstract readonly fixHint: FixHint;
+    abstract check(ctx: EditContext): readonly Violation[];
+}
+export declare abstract class FileRuleBase<C extends BaseRuleConfig> extends AbstractRule<C> implements Rule {
+    readonly scope: "file";
+    readonly files: readonly string[];
+    readonly defaultOptions: RuleOptions;
+    abstract readonly description: string;
+    abstract readonly fixHint: FixHint;
+    abstract check(ctx: FileContext): readonly Violation[];
+}
+export declare abstract class BashRuleBase<C extends BaseRuleConfig> extends AbstractRule<C> implements Rule {
+    readonly scope: "bash";
+    readonly files: readonly string[];
+    readonly defaultOptions: RuleOptions;
+    abstract readonly description: string;
+    abstract readonly fixHint: FixHint;
+    abstract check(ctx: BashContext): readonly Violation[];
+}

package/src/core/rule-base.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BashRuleBase = exports.FileRuleBase = exports.EditRuleBase = exports.EmptyRuleConfig = void 0;
+const rules_sdk_1 = require("@webpieces/rules-sdk");
+const rules_config_1 = require("@webpieces/rules-config");
+/**
+ * A concrete, instantiable BaseRuleConfig used as a fallback when a built-in rule has no
+ * entry in webpieces.config.json yet. It carries no values, so the rule's `description`,
+ * `fixHint`, and `defaultOptions` (which are config-independent) are still readable for the
+ * out-of-sync report — the rule never actually runs in that state (the sync check blocks first).
+ */
+class EmptyRuleConfig extends rules_sdk_1.BaseRuleConfig {
+}
+exports.EmptyRuleConfig = EmptyRuleConfig;
+/**
+ * Scope-specific base for edit rules. Extends the shared AbstractRule (which owns `name`,
+ * the typed `config`, and `shouldRun()`), and adds the ai-hook execution surface.
+ */
+class EditRuleBase extends rules_config_1.AbstractRule {
+    scope = 'edit';
+    files = [];
+    defaultOptions = {};
+}
+exports.EditRuleBase = EditRuleBase;
+class FileRuleBase extends rules_config_1.AbstractRule {
+    scope = 'file';
+    files = [];
+    defaultOptions = {};
+}
+exports.FileRuleBase = FileRuleBase;
+class BashRuleBase extends rules_config_1.AbstractRule {
+    scope = 'bash';
+    files = [];
+    defaultOptions = {};
+}
+exports.BashRuleBase = BashRuleBase;
+//# sourceMappingURL=rule-base.js.map

package/src/core/rule-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-base.js","sourceRoot":"","sources":["../../../../../../packages/tooling/hook-runtime/src/core/rule-base.ts"],"names":[],"mappings":";;;AAAA,oDAAsD;AACtD,0DAAoE;AAKpE;;;;;GAKG;AACH,MAAa,eAAgB,SAAQ,0BAAc;CAAG;AAAtD,0CAAsD;AAEtD;;;GAGG;AACH,MAAsB,YAAuC,SAAQ,2BAAe;IACvE,KAAK,GAAG,MAAe,CAAC;IACxB,KAAK,GAAsB,EAAE,CAAC;IAC9B,cAAc,GAAgB,EAAE,CAAC;CAK7C;AARD,oCAQC;AAED,MAAsB,YAAuC,SAAQ,2BAAe;IACvE,KAAK,GAAG,MAAe,CAAC;IACxB,KAAK,GAAsB,EAAE,CAAC;IAC9B,cAAc,GAAgB,EAAE,CAAC;CAK7C;AARD,oCAQC;AAED,MAAsB,YAAuC,SAAQ,2BAAe;IACvE,KAAK,GAAG,MAAe,CAAC;IACxB,KAAK,GAAsB,EAAE,CAAC;IAC9B,cAAc,GAAgB,EAAE,CAAC;CAK7C;AARD,oCAQC","sourcesContent":["import { BaseRuleConfig } from '@webpieces/rules-sdk';\nimport { AbstractRule, RuleOptions } from '@webpieces/rules-config';\n\nimport type { EditContext, BashContext, FileContext, Violation, Rule } from './types';\nimport type { FixHint } from './fix-hint';\n\n/**\n * A concrete, instantiable BaseRuleConfig used as a fallback when a built-in rule has no\n * entry in webpieces.config.json yet. It carries no values, so the rule's `description`,\n * `fixHint`, and `defaultOptions` (which are config-independent) are still readable for the\n * out-of-sync report — the rule never actually runs in that state (the sync check blocks first).\n */\nexport class EmptyRuleConfig extends BaseRuleConfig {}\n\n/**\n * Scope-specific base for edit rules. Extends the shared AbstractRule (which owns `name`,\n * the typed `config`, and `shouldRun()`), and adds the ai-hook execution surface.\n */\nexport abstract class EditRuleBase<C extends BaseRuleConfig> extends AbstractRule<C> implements Rule {\n    readonly scope = 'edit' as const;\n    readonly files: readonly string[] = [];\n    readonly defaultOptions: RuleOptions = {};\n    abstract readonly description: string;\n    abstract readonly fixHint: FixHint;\n\n    abstract check(ctx: EditContext): readonly Violation[];\n}\n\nexport abstract class FileRuleBase<C extends BaseRuleConfig> extends AbstractRule<C> implements Rule {\n    readonly scope = 'file' as const;\n    readonly files: readonly string[] = [];\n    readonly defaultOptions: RuleOptions = {};\n    abstract readonly description: string;\n    abstract readonly fixHint: FixHint;\n\n    abstract check(ctx: FileContext): readonly Violation[];\n}\n\nexport abstract class BashRuleBase<C extends BaseRuleConfig> extends AbstractRule<C> implements Rule {\n    readonly scope = 'bash' as const;\n    readonly files: readonly string[] = [];\n    readonly defaultOptions: RuleOptions = {};\n    abstract readonly description: string;\n    abstract readonly fixHint: FixHint;\n\n    abstract check(ctx: BashContext): readonly Violation[];\n}\n"]}

package/src/core/rule-evaluation.d.ts

@@ -0,0 +1,18 @@
+import { RulePackRegistry, WebpiecesRulesConfig } from '@webpieces/rules-config';
+import { Rule, EditContext, FileContext, BashContext, Violation, RuleGroup, BlockedResult } from './types';
+/**
+ * Fault Y — a loaded rule whose CONFIG KEY has no entry.
+ *
+ * Compared on `configKey`, not `name`. Eight of the loaded rules are classes behind two policy keys, so
+ * comparing names here would demand entries named `feature-branch-guard`, `pr-merge-guard` and six
+ * others — keys the validator then REJECTS as retired. That is the two-enforcement-paths deadlock this
+ * repo has already hit once (see the narration in guards.spec.ts), and it blocks every Bash/Write/Edit.
+ *
+ * De-duplicated on the key too, so one missing policy entry reports ONE paste-ready snippet rather than
+ * four copies of the same one under four different headings.
+ */
+export declare function checkConfigSync(rules: readonly Rule[], config: WebpiecesRulesConfig, registry: RulePackRegistry): BlockedResult | null;
+export declare function runRuleCheck(rule: Rule, ctx: EditContext | FileContext | BashContext): readonly Violation[];
+export declare function runBashRules(rules: readonly Rule[], bashContext: BashContext): readonly RuleGroup[];
+export declare function runEditRules(rules: readonly Rule[], editContexts: readonly EditContext[]): readonly RuleGroup[];
+export declare function runFileRules(rules: readonly Rule[], fileContext: FileContext): readonly RuleGroup[];