@gobing-ai/ts-rule-engine 0.3.20 → 0.3.21

package/dist/config/loader.d.ts

@@ -1,3 +1,4 @@
+import { type FileSystem } from '@gobing-ai/ts-runtime';
 import { type ConstraintRule } from '../types';
 import { type ExtensionRef } from './extensions';
 /** Options for loading rule presets. */
@@ -14,6 +15,8 @@ export interface RuleLoaderOptions {
     validateSchema?: boolean;
     /** Optional fetch implementation for remote HTTP(S) schema refs. */
     fetch?: (input: string) => Promise<Response>;
+    /** Filesystem for reading roots. Defaults to `createNodeFileSystem()`; inject to test without disk. */
+    fileSystem?: FileSystem;
 }
 /** Options for loading a single rule file directly from disk. */
 export interface RuleFileLoadOptions {

package/dist/config/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAUA,OAAO,EACH,KAAK,cAAc,EAOtB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAEpE,wCAAwC;AACxC,MAAM,WAAW,iBAAiB;IAC9B;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,4FAA4F;IAC5F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oEAAoE;IACpE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChD;AAED,iEAAiE;AACjE,MAAM,WAAW,mBAAmB;IAChC,mEAAmE;IACnE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oEAAoE;IACpE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChD;AAED,mFAAmF;AACnF,MAAM,WAAW,YAAY;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC;IACjC,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC;CACvC;AAUD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAahG;AAyCD;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAEzG;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,YAAY,CAAC,CAS7G"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,UAAU,EAMlB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACH,KAAK,cAAc,EAOtB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAEpE,wCAAwC;AACxC,MAAM,WAAW,iBAAiB;IAC9B;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,4FAA4F;IAC5F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oEAAoE;IACpE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7C,uGAAuG;IACvG,UAAU,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED,iEAAiE;AACjE,MAAM,WAAW,mBAAmB;IAChC,mEAAmE;IACnE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oEAAoE;IACpE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChD;AAED,mFAAmF;AACnF,MAAM,WAAW,YAAY;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC;IACjC,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC;CACvC;AAUD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAgBhG;AAyCD;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAEzG;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,YAAY,CAAC,CAS7G"}

package/dist/config/loader.js

@@ -1,4 +1,4 @@
-import { basenamePath, dirnamePath, joinPath, loadStructuredConfig, NodeFileSystem, relativePath, resolvePath, SEP, } from '@gobing-ai/ts-runtime';
+import { basenamePath, createNodeFileSystem, dirnamePath, joinPath, loadStructuredConfig, relativePath, resolvePath, SEP, } from '@gobing-ai/ts-runtime';
 import { ConstraintRuleFileSchema, ConstraintRuleSchema, PresetDefinitionSchema, } from '../types.js';
 import { collectExtensions } from './extensions.js';
 /**
@@ -9,7 +9,7 @@ import { collectExtensions } from './extensions.js';
  * the rest of a preset's categories from the lower-priority roots.
  */
 export async function loadPreset(name, options) {
-    const merged = await buildMergedRoots(options.roots.map((root) => resolvePath(root)));
+    const merged = await buildMergedRoots(options.roots.map((root) => resolvePath(root)), options.fileSystem);
     const presetPath = findMergedPreset(merged, name);
     if (presetPath === null)
         return { rules: [], extensions: [] };
@@ -126,8 +126,7 @@ async function loadPresetEntry(merged, entry, seen, options) {
  * Roots are processed in the order supplied (highest priority first). The first
  * root to provide a given relative path owns that file; later roots are shadowed.
  */
-async function buildMergedRoots(roots) {
-    const fs = new NodeFileSystem();
+async function buildMergedRoots(roots, fs = createNodeFileSystem()) {
     const files = new Map();
     const categories = new Set();
     for (const root of roots) {

package/dist/engine.d.ts

@@ -1,5 +1,5 @@
 import type { EventBus, Logger } from '@gobing-ai/ts-infra';
-import type { ProcessExecutor } from '@gobing-ai/ts-runtime';
+import { type FileSystem, type ProcessExecutor } from '@gobing-ai/ts-runtime';
 import type { RuleEngineEvents } from './events';
 import { type FixApplicationResult } from './fixers/fixers';
 import { RuleEngineHost } from './host/rule-engine-host';
@@ -9,6 +9,12 @@ import type { ConstraintRule, Fix, FixMode, RuleEngineResult, RuleEvaluator } fr
 export interface RuleEngineOptions {
     /** Optional executor supplied to process-backed evaluators. */
     processExecutor?: ProcessExecutor;
+    /**
+     * Filesystem port (ADR-011 union-return {@link FileSystem}); defaults to
+     * `createNodeFileSystem()`. Threaded through {@link RuleContext} to every
+     * evaluator and fixer provider so hosts can inject a virtual fs in tests.
+     */
+    fileSystem?: FileSystem;
     /** Optional preconfigured host. */
     host?: RuleEngineHost;
     /** Optional event bus for structured run observability (R-A4). */
@@ -31,6 +37,7 @@ export declare class RuleEngine {
     private readonly persistence;
     private readonly runId;
     private readonly runMeta;
+    private readonly fileSystem;
     constructor(options?: RuleEngineOptions);
     /** Register or replace an evaluator. */
     registerEvaluator(type: string, evaluator: RuleEvaluator): void;

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAIH,KAAK,oBAAoB,EAE5B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAqB,cAAc,EAAE,GAAG,EAAE,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGhH,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAC9B,+DAA+D;IAC/D,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,mCAAmC;IACnC,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,kEAAkE;IAClE,MAAM,CAAC,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IACpC,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,4EAA4E;AAC5E,qBAAa,UAAU;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAE9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAChE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqC;IACjE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;gBAElD,OAAO,GAAE,iBAAsB;IAW3C,wCAAwC;IACxC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI;IAI/D;;;;;;;OAOG;IACG,QAAQ,CACV,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAC3C,OAAO,CAAC,gBAAgB,CAAC;IAI5B;;;;;;;;;;;;;;;;;;OAkBG;IACG,iBAAiB,CACnB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,OAAgB,EAC5B,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAC3C,OAAO,CAAC,gBAAgB,CAAC;IAmK5B;;;;;;;OAOG;IACG,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,EAAE,EAAE,MAAM,UAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAG1G"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAwB,KAAK,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACpG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAIH,KAAK,oBAAoB,EAE5B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,EAAqB,cAAc,EAAE,GAAG,EAAE,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGhH,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAC9B,+DAA+D;IAC/D,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,mCAAmC;IACnC,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,kEAAkE;IAClE,MAAM,CAAC,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IACpC,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED,4EAA4E;AAC5E,qBAAa,UAAU;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAE9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAChE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqC;IACjE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAC9D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;gBAE5B,OAAO,GAAE,iBAAsB;IAY3C,wCAAwC;IACxC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI;IAI/D;;;;;;;OAOG;IACG,QAAQ,CACV,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAC3C,OAAO,CAAC,gBAAgB,CAAC;IAI5B;;;;;;;;;;;;;;;;;;OAkBG;IACG,iBAAiB,CACnB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,OAAgB,EAC5B,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAC3C,OAAO,CAAC,gBAAgB,CAAC;IAmK5B;;;;;;;OAOG;IACG,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,EAAE,EAAE,MAAM,UAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAG1G"}

package/dist/engine.js

@@ -1,4 +1,5 @@
 import { addSpanEvent, getLogger, traceAsync } from '@gobing-ai/ts-infra';
+import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { applyFixes as applyFixesImpl, FIX_MODE_RANK, registerBuiltinFixers, } from './fixers/fixers.js';
 import { registerBuiltins } from './host/builtins.js';
 import { RuleEngineHost } from './host/rule-engine-host.js';
@@ -12,6 +13,7 @@ export class RuleEngine {
     persistence;
     runId;
     runMeta;
+    fileSystem;
     constructor(options = {}) {
         this.host = options.host ?? new RuleEngineHost();
         registerBuiltins(this.host, options.processExecutor);
@@ -21,6 +23,7 @@ export class RuleEngine {
         this.persistence = options.persistence;
         this.runId = options.runId ?? crypto.randomUUID();
         this.runMeta = options.runMeta;
+        this.fileSystem = options.fileSystem ?? createNodeFileSystem();
     }
     /** Register or replace an evaluator. */
     registerEvaluator(type, evaluator) {
@@ -103,7 +106,7 @@ export class RuleEngine {
                 try {
                     const result = await this.host.evaluators
                         .get(rule.evaluator.type)
-                        .evaluate(rule, { rule, workdir });
+                        .evaluate(rule, { rule, workdir, fileSystem: this.fileSystem });
                     ruleFindings = result.findings;
                     ruleEvalFixes = result.fixes;
                 }
@@ -154,7 +157,7 @@ export class RuleEngine {
                         };
                         const providerFixes = await provider.createFixes({
                             rule,
-                            context: { rule, workdir },
+                            context: { rule, workdir, fileSystem: this.fileSystem },
                             findings: ruleFindings,
                             fix: effectiveFix,
                         });
@@ -201,7 +204,7 @@ export class RuleEngine {
      * @returns Application details and optional diff.
      */
     async applyFixes(workdir, fixes, dryRun = false) {
-        return applyFixesImpl(workdir, fixes, dryRun);
+        return applyFixesImpl(workdir, fixes, dryRun, this.fileSystem);
     }
 }
 /** Return the lower-authority mode between what the rule requests and what the caller allows. */

package/dist/evaluators/config-access.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Typed accessors for a rule's `evaluator.config` bag and inline-flag parsing.
+ *
+ * Required keys fail loudly (throw, naming the evaluator) so misconfigured rules
+ * surface at evaluation time rather than silently scanning the wrong set.
+ */
+/** Return the value as a `string[]` when every item is a string, otherwise undefined. */
+export declare function stringArray(value: unknown): string[] | undefined;
+/** Optional accessor context — names the evaluator in "required config" errors for rule authors. */
+export interface ConfigAccessorOptions {
+    /** Evaluator name surfaced in the error, e.g. `"regex evaluator requires string config \"pattern\""`. */
+    evaluator?: string;
+}
+/**
+ * Read a string entry from a rule's evaluator config. Returns the value when it is a string,
+ * the `fallback` when one is supplied, otherwise throws — so required keys fail loudly.
+ */
+export declare function configString(config: Record<string, unknown>, key: string, fallback?: string, options?: ConfigAccessorOptions): string;
+/**
+ * Read a string-array entry from a rule's evaluator config. A bare string is coerced to a
+ * single-element array. Returns the `fallback` when one is supplied and the value is absent;
+ * otherwise throws — so required keys fail loudly.
+ */
+export declare function configArray(config: Record<string, unknown>, key: string, fallback?: string[], options?: ConfigAccessorOptions): string[];
+/** Read a finite-number entry from a rule's evaluator config, falling back when absent or invalid. */
+export declare function configNumber(config: Record<string, unknown>, key: string, fallback: number): number;
+/**
+ * Split a leading ripgrep/PCRE-style `(?flags)` inline group off a regex source.
+ *
+ * Returns the JS-relevant flags found in the group (filtered to `imsu`) and the
+ * remaining source with the group removed. When no leading group is present, returns
+ * empty flags and the source unchanged. Shared by evaluators that accept inline flags.
+ */
+export declare function parseInlineFlags(source: string): {
+    flags: string;
+    rest: string;
+};
+//# sourceMappingURL=config-access.d.ts.map

package/dist/evaluators/config-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-access.d.ts","sourceRoot":"","sources":["../../src/evaluators/config-access.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,yFAAyF;AACzF,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAEhE;AAED,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IAClC,yGAAyG;IACzG,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAOD;;;GAGG;AACH,wBAAgB,YAAY,CACxB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,GAAE,qBAA0B,GACpC,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,EAAE,EACnB,OAAO,GAAE,qBAA0B,GACpC,MAAM,EAAE,CAMV;AAED,sGAAsG;AACtG,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGnG;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAKhF"}

package/dist/evaluators/config-access.js

@@ -0,0 +1,60 @@
+/**
+ * Typed accessors for a rule's `evaluator.config` bag and inline-flag parsing.
+ *
+ * Required keys fail loudly (throw, naming the evaluator) so misconfigured rules
+ * surface at evaluation time rather than silently scanning the wrong set.
+ */
+/** Return the value as a `string[]` when every item is a string, otherwise undefined. */
+export function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string') ? value : undefined;
+}
+function requiredConfigError(kind, key, evaluator) {
+    const who = evaluator !== undefined ? `${evaluator} evaluator` : 'evaluator';
+    return new Error(`${who} requires ${kind} config "${key}"`);
+}
+/**
+ * Read a string entry from a rule's evaluator config. Returns the value when it is a string,
+ * the `fallback` when one is supplied, otherwise throws — so required keys fail loudly.
+ */
+export function configString(config, key, fallback, options = {}) {
+    const value = config[key];
+    if (typeof value === 'string')
+        return value;
+    if (fallback !== undefined)
+        return fallback;
+    throw requiredConfigError('string', key, options.evaluator);
+}
+/**
+ * Read a string-array entry from a rule's evaluator config. A bare string is coerced to a
+ * single-element array. Returns the `fallback` when one is supplied and the value is absent;
+ * otherwise throws — so required keys fail loudly.
+ */
+export function configArray(config, key, fallback, options = {}) {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    if (typeof value === 'string')
+        return [value];
+    if (fallback !== undefined)
+        return fallback;
+    throw requiredConfigError('string[]', key, options.evaluator);
+}
+/** Read a finite-number entry from a rule's evaluator config, falling back when absent or invalid. */
+export function configNumber(config, key, fallback) {
+    const value = config[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+/**
+ * Split a leading ripgrep/PCRE-style `(?flags)` inline group off a regex source.
+ *
+ * Returns the JS-relevant flags found in the group (filtered to `imsu`) and the
+ * remaining source with the group removed. When no leading group is present, returns
+ * empty flags and the source unchanged. Shared by evaluators that accept inline flags.
+ */
+export function parseInlineFlags(source) {
+    const match = /^\(\?([a-z]+)\)/.exec(source);
+    if (!match)
+        return { flags: '', rest: source };
+    const flags = [...(match[1] ?? '')].filter((flag) => 'imsu'.includes(flag)).join('');
+    return { flags, rest: source.slice(match[0].length) };
+}

package/dist/evaluators/coverage-gate-evaluator.d.ts

@@ -13,9 +13,8 @@ import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type
  * error, so the gate degrades gracefully when coverage was not generated.
  */
 export declare class CoverageGateEvaluator implements RuleEvaluator {
-    private readonly fs;
-    constructor();
     /** Evaluate per-file coverage against the configured threshold. */
+    constructor();
     evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
 }
 //# sourceMappingURL=coverage-gate-evaluator.d.ts.map

package/dist/evaluators/coverage-gate-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage-gate-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/coverage-gate-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAyBlB;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACvD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAiB;;IAMpC,mEAAmE;IAC7D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA0C5F"}
+{"version":3,"file":"coverage-gate-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/coverage-gate-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAyBlB;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACvD,mEAAmE;;IAM7D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA0C5F"}

package/dist/evaluators/coverage-gate-evaluator.js

@@ -1,4 +1,4 @@
-import { isAbsolutePath, NodeFileSystem, relativePath, resolvePath } from '@gobing-ai/ts-runtime';
+import { createNodeFileSystem, isAbsolutePath, relativePath, resolvePath } from '@gobing-ai/ts-runtime';
 import { createFinding, } from '../types.js';
 import { matchesGlob } from './file-utils.js';
 /**
@@ -15,17 +15,18 @@ import { matchesGlob } from './file-utils.js';
  * error, so the gate degrades gracefully when coverage was not generated.
  */
 export class CoverageGateEvaluator {
-    fs;
+    /** Evaluate per-file coverage against the configured threshold. */
+    // Explicit constructor avoids a V8 function-coverage phantom (synthesized default ctor).
     constructor() {
-        this.fs = new NodeFileSystem();
+        // no-op; all state comes from evaluate() context
     }
-    /** Evaluate per-file coverage against the configured threshold. */
     async evaluate(rule, context) {
+        const fs = context.fileSystem ?? createNodeFileSystem();
         const config = (rule.evaluator.config ?? {});
         const lcovPath = config.lcovPath
             ? resolvePath(context.workdir, config.lcovPath)
             : resolvePath(context.workdir, 'coverage', 'lcov.info');
-        if (!(await this.fs.exists(lcovPath))) {
+        if (!(await fs.exists(lcovPath))) {
             return {
                 findings: [
                     createFinding(rule, 'No lcov file found — coverage not generated. Skipping gate.', lcovPath, {
@@ -35,7 +36,7 @@ export class CoverageGateEvaluator {
                 fixes: [],
             };
         }
-        const coverage = parseLcov(await this.fs.readFile(lcovPath));
+        const coverage = parseLcov(await fs.readFile(lcovPath));
         const threshold = config.threshold ?? 90;
         const exemptions = new Map((config.exemptions ?? []).map((entry) => [entry.path, entry]));
         const findings = [];

package/dist/evaluators/file-discovery.d.ts

@@ -0,0 +1,72 @@
+/**
+ * File discovery and reading for evaluators — the shared scaffolding behind the
+ * line-scanning rules. Owns directory walks, scope filtering, and per-file reads
+ * so each evaluator is left with only its own matcher.
+ */
+import { type FileSystem } from '@gobing-ai/ts-runtime';
+/** Options for source-file discovery. */
+export interface SourceDiscoveryOptions {
+    /** Working directory. */
+    workdir: string;
+    /** Include path fragments or suffixes. */
+    include?: string[];
+    /** Exclude path fragments. */
+    exclude?: string[];
+    /** Filesystem adapter. */
+    fs?: FileSystem;
+}
+/**
+ * Directory names pruned from every file walk — heavy or generated trees that no rule
+ * should scan. Shared so subprocess-backed evaluators (e.g. `sg`) can forward the same
+ * skip-list to the external tool instead of relying on each rule to remember it.
+ */
+export declare const DEFAULT_EXCLUDES: Set<string>;
+/** Resolve source files for evaluators using conservative path-fragment matching. */
+export declare function discoverFiles(options: SourceDiscoveryOptions): Promise<string[]>;
+/** Read a file from a workdir-relative path. */
+export declare function readWorkdirFile(workdir: string, filePath: string, fs?: FileSystem): Promise<string>;
+/** A discovered in-scope file paired with its contents. */
+export interface ScannedFile {
+    /** Workdir-relative path. */
+    readonly file: string;
+    /** Full file contents. */
+    readonly content: string;
+}
+/** How `scanFiles` matches `include` / `exclude` against discovered paths. */
+export type ScanMatchMode = 'loose' | 'glob';
+/** Options for {@link scanFiles}. */
+export interface ScanFilesOptions {
+    /** Working directory to walk. */
+    workdir: string;
+    /** Include patterns; semantics depend on `matchMode`. Undefined/empty = all files. */
+    include?: string[];
+    /** Exclude patterns; semantics depend on `matchMode`. */
+    exclude?: string[];
+    /**
+     * Scope matching policy:
+     * - `loose` — substring/suffix fragments via {@link matchesAny} (back-compat for
+     *   evaluators that historically accepted bare fragments like `.ts` or `src/`).
+     * - `glob` — anchored `**`/`*` globs via {@link matchesGlob}.
+     *
+     * The two are NOT interchangeable: a bare `src/` matches different sets under each.
+     * Each evaluator declares the mode that preserves its existing behavior.
+     */
+    matchMode: ScanMatchMode;
+    /** Filesystem adapter. */
+    fs?: FileSystem;
+}
+/**
+ * Discover in-scope files and read each once — the shared scaffolding behind the
+ * line-scanning evaluators. Owns discovery, scope filtering (per `matchMode`), and
+ * reads, so each evaluator is left with only its own matcher.
+ *
+ * Scope is a parameter, not assumed one-per-rule: callers that scan under several
+ * scopes (e.g. import boundaries) pass no `include` here and apply their own globs to
+ * the returned paths.
+ */
+export declare function scanFiles(options: ScanFilesOptions): Promise<ScannedFile[]>;
+/** Ensure a path is workdir-relative for findings. */
+export declare function relativeToWorkdir(workdir: string, path: string): string;
+/** Return parent directory for a workdir-relative path. */
+export declare function relativeParent(path: string): string;
+//# sourceMappingURL=file-discovery.d.ts.map

package/dist/evaluators/file-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-discovery.d.ts","sourceRoot":"","sources":["../../src/evaluators/file-discovery.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAGH,KAAK,UAAU,EAIlB,MAAM,uBAAuB,CAAC;AAG/B,yCAAyC;AACzC,MAAM,WAAW,sBAAsB;IACnC,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,0BAA0B;IAC1B,EAAE,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,aAAgF,CAAC;AAE9G,qFAAqF;AACrF,wBAAsB,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWtF;AAED,gDAAgD;AAChD,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,aAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAErH;AAED,2DAA2D;AAC3D,MAAM,WAAW,WAAW;IACxB,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0BAA0B;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B;AAED,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;AAE7C,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC7B,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;;;;OAQG;IACH,SAAS,EAAE,aAAa,CAAC;IACzB,0BAA0B;IAC1B,EAAE,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAWjF;AAeD,sDAAsD;AACtD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGnD"}

package/dist/evaluators/file-discovery.js

@@ -0,0 +1,63 @@
+/**
+ * File discovery and reading for evaluators — the shared scaffolding behind the
+ * line-scanning rules. Owns directory walks, scope filtering, and per-file reads
+ * so each evaluator is left with only its own matcher.
+ */
+import { createNodeFileSystem, dirnamePath, relativePath, resolvePath, walkDir, } from '@gobing-ai/ts-runtime';
+import { matchesAny, matchesGlob } from './glob-match.js';
+/**
+ * Directory names pruned from every file walk — heavy or generated trees that no rule
+ * should scan. Shared so subprocess-backed evaluators (e.g. `sg`) can forward the same
+ * skip-list to the external tool instead of relying on each rule to remember it.
+ */
+export const DEFAULT_EXCLUDES = new Set(['.git', 'node_modules', 'dist', '.coverage', '.astro', '.wrangler']);
+/** Resolve source files for evaluators using conservative path-fragment matching. */
+export async function discoverFiles(options) {
+    const fs = options.fs ?? createNodeFileSystem();
+    const allFiles = await walkDir(options.workdir, fs, DEFAULT_EXCLUDES);
+    return allFiles
+        .map((path) => relativePath(options.workdir, path))
+        .filter((path) => !path.split('/').some((segment) => DEFAULT_EXCLUDES.has(segment)))
+        .filter((path) => matchesAny(path, options.include) &&
+        (options.exclude === undefined || !matchesAny(path, options.exclude)));
+}
+/** Read a file from a workdir-relative path. */
+export async function readWorkdirFile(workdir, filePath, fs = createNodeFileSystem()) {
+    return await fs.readFile(resolvePath(workdir, filePath));
+}
+/**
+ * Discover in-scope files and read each once — the shared scaffolding behind the
+ * line-scanning evaluators. Owns discovery, scope filtering (per `matchMode`), and
+ * reads, so each evaluator is left with only its own matcher.
+ *
+ * Scope is a parameter, not assumed one-per-rule: callers that scan under several
+ * scopes (e.g. import boundaries) pass no `include` here and apply their own globs to
+ * the returned paths.
+ */
+export async function scanFiles(options) {
+    const fs = options.fs ?? createNodeFileSystem();
+    const files = options.matchMode === 'loose'
+        ? await discoverFiles({ workdir: options.workdir, include: options.include, exclude: options.exclude, fs })
+        : await discoverFilesByGlob(options.workdir, options.include, options.exclude, fs);
+    const scanned = [];
+    for (const file of files) {
+        scanned.push({ file, content: await readWorkdirFile(options.workdir, file, fs) });
+    }
+    return scanned;
+}
+/** Discover files then filter with anchored globs (strict mode for {@link scanFiles}). */
+async function discoverFilesByGlob(workdir, include, exclude, fs) {
+    const all = await discoverFiles({ workdir, fs });
+    return all
+        .filter((file) => include === undefined || include.length === 0 || include.some((g) => matchesGlob(file, g)))
+        .filter((file) => exclude === undefined || !exclude.some((g) => matchesGlob(file, g)));
+}
+/** Ensure a path is workdir-relative for findings. */
+export function relativeToWorkdir(workdir, path) {
+    return relativePath(workdir, resolvePath(path));
+}
+/** Return parent directory for a workdir-relative path. */
+export function relativeParent(path) {
+    const parent = dirnamePath(path);
+    return parent === '.' ? '' : parent;
+}

package/dist/evaluators/file-utils.d.ts

@@ -1,123 +1,16 @@
-import { type LegacyFileSystem as FileSystem, NodeFileSystem } from '@gobing-ai/ts-runtime';
-/** Options for source-file discovery. */
-export interface SourceDiscoveryOptions {
-    /** Working directory. */
-    workdir: string;
-    /** Include path fragments or suffixes. */
-    include?: string[];
-    /** Exclude path fragments. */
-    exclude?: string[];
-    /** Filesystem adapter. */
-    fs?: FileSystem;
-}
 /**
- * Directory names pruned from every file walk — heavy or generated trees that no rule
- * should scan. Shared so subprocess-backed evaluators (e.g. `sg`) can forward the same
- * skip-list to the external tool instead of relying on each rule to remember it.
- */
-export declare const DEFAULT_EXCLUDES: Set<string>;
-/** Resolve source files for evaluators using conservative path-fragment matching. */
-export declare function discoverFiles(options: SourceDiscoveryOptions): Promise<string[]>;
-/** Read a file from a workdir-relative path. */
-export declare function readWorkdirFile(workdir: string, filePath: string, fs?: NodeFileSystem): Promise<string>;
-/** A discovered in-scope file paired with its contents. */
-export interface ScannedFile {
-    /** Workdir-relative path. */
-    readonly file: string;
-    /** Full file contents. */
-    readonly content: string;
-}
-/** How `scanFiles` matches `include` / `exclude` against discovered paths. */
-export type ScanMatchMode = 'loose' | 'glob';
-/** Options for {@link scanFiles}. */
-export interface ScanFilesOptions {
-    /** Working directory to walk. */
-    workdir: string;
-    /** Include patterns; semantics depend on `matchMode`. Undefined/empty = all files. */
-    include?: string[];
-    /** Exclude patterns; semantics depend on `matchMode`. */
-    exclude?: string[];
-    /**
-     * Scope matching policy:
-     * - `loose` — substring/suffix fragments via {@link matchesAny} (back-compat for
-     *   evaluators that historically accepted bare fragments like `.ts` or `src/`).
-     * - `glob` — anchored `**`/`*` globs via {@link matchesGlob}.
-     *
-     * The two are NOT interchangeable: a bare `src/` matches different sets under each.
-     * Each evaluator declares the mode that preserves its existing behavior.
-     */
-    matchMode: ScanMatchMode;
-    /** Filesystem adapter. */
-    fs?: FileSystem;
-}
-/**
- * Discover in-scope files and read each once — the shared scaffolding behind the
- * line-scanning evaluators. Owns discovery, scope filtering (per `matchMode`), and
- * reads, so each evaluator is left with only its own matcher.
- *
- * Scope is a parameter, not assumed one-per-rule: callers that scan under several
- * scopes (e.g. import boundaries) pass no `include` here and apply their own globs to
- * the returned paths.
- */
-export declare function scanFiles(options: ScanFilesOptions): Promise<ScannedFile[]>;
-/** Ensure a path is workdir-relative for findings. */
-export declare function relativeToWorkdir(workdir: string, path: string): string;
-/** Return parent directory for a workdir-relative path. */
-export declare function relativeParent(path: string): string;
-/**
- * Return true when a path matches any supplied pattern.
- *
- * Each pattern is matched in two passes, most-specific first:
- *  1. If it contains a glob metachar (`*`), try anchored {@link matchesGlob} —
- *     so `packages/**\/*.ts` resolves segment-by-segment instead of collapsing
- *     to a bare fragment (the latter silently matched nothing, leaving every
- *     glob-scoped loose-mode rule scanning zero files).
- *  2. Otherwise (or if the glob did not match), fall back to the legacy
- *     fragment/suffix substring test, where stars are stripped — preserving
- *     bare fragments like `.ts`, `src/`, `/tests/` that loose-mode evaluators
- *     have always accepted, and keeping unanchored patterns like `*.ts`
- *     (→ suffix `.ts`) matching nested paths.
- */
-export declare function matchesAny(path: string, patterns: string[] | undefined): boolean;
-/**
- * Segment-aware glob matching with `**` (any depth) and `*` (single segment).
+ * Aggregating barrel for evaluator file utilities — kept so existing imports
+ * (`./file-utils`) stay stable. The implementation now lives in three focused
+ * modules by concern:
  *
- * Stricter than {@link matchesAny}: it anchors the whole path, so `apps/**` does
- * not match `vendor/apps/x`. Used by evaluators that enforce path policies
- * (coverage scoping, test-file location) where a loose match would change findings.
- */
-export declare function matchesGlob(path: string, pattern: string): boolean;
-/** Escape a string for safe literal use inside a `RegExp` source. */
-export declare function escapeRegExp(value: string): string;
-/** Return the value as a `string[]` when every item is a string, otherwise undefined. */
-export declare function stringArray(value: unknown): string[] | undefined;
-/** Optional accessor context — names the evaluator in "required config" errors for rule authors. */
-export interface ConfigAccessorOptions {
-    /** Evaluator name surfaced in the error, e.g. `"regex evaluator requires string config \"pattern\""`. */
-    evaluator?: string;
-}
-/**
- * Read a string entry from a rule's evaluator config. Returns the value when it is a string,
- * the `fallback` when one is supplied, otherwise throws — so required keys fail loudly.
- */
-export declare function configString(config: Record<string, unknown>, key: string, fallback?: string, options?: ConfigAccessorOptions): string;
-/**
- * Read a string-array entry from a rule's evaluator config. A bare string is coerced to a
- * single-element array. Returns the `fallback` when one is supplied and the value is absent;
- * otherwise throws — so required keys fail loudly.
- */
-export declare function configArray(config: Record<string, unknown>, key: string, fallback?: string[], options?: ConfigAccessorOptions): string[];
-/** Read a finite-number entry from a rule's evaluator config, falling back when absent or invalid. */
-export declare function configNumber(config: Record<string, unknown>, key: string, fallback: number): number;
-/**
- * Split a leading ripgrep/PCRE-style `(?flags)` inline group off a regex source.
+ * - `./glob-match`      — path-pattern matching (`matchesAny`, `matchesGlob`, `escapeRegExp`)
+ * - `./file-discovery`  — directory walks, scope filtering, per-file reads
+ * - `./config-access`   — typed `evaluator.config` accessors + inline-flag parsing
  *
- * Returns the JS-relevant flags found in the group (filtered to `imsu`) and the
- * remaining source with the group removed. When no leading group is present, returns
- * empty flags and the source unchanged. Shared by evaluators that accept inline flags.
+ * Prefer importing from the specific module in new code; this barrel exists for
+ * back-compat and as a convenience surface.
  */
-export declare function parseInlineFlags(source: string): {
-    flags: string;
-    rest: string;
-};
+export { type ConfigAccessorOptions, configArray, configNumber, configString, parseInlineFlags, stringArray, } from './config-access';
+export { DEFAULT_EXCLUDES, discoverFiles, readWorkdirFile, relativeParent, relativeToWorkdir, type ScanFilesOptions, type ScanMatchMode, type ScannedFile, type SourceDiscoveryOptions, scanFiles, } from './file-discovery';
+export { escapeRegExp, matchesAny, matchesGlob } from './glob-match';
 //# sourceMappingURL=file-utils.d.ts.map

package/dist/evaluators/file-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../src/evaluators/file-utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../src/evaluators/file-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACH,KAAK,qBAAqB,EAC1B,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,WAAW,GACd,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACH,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAC3B,SAAS,GACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}