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

package/dist/evaluators/file-utils.js

@@ -1,181 +1,15 @@
-import { dirnamePath, NodeFileSystem, relativePath, resolvePath, walkDir, } from '@gobing-ai/ts-runtime';
 /**
- * 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 ?? new NodeFileSystem();
-    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 = new NodeFileSystem()) {
-    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 ?? new NodeFileSystem();
-    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;
-}
-/**
- * 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 function matchesAny(path, patterns) {
-    if (patterns === undefined || patterns.length === 0)
-        return true;
-    const normalizedPath = path.replaceAll('\\', '/');
-    return patterns.some((pattern) => {
-        const normalized = pattern.replaceAll('\\', '/');
-        if (normalized.includes('*') && matchesGlob(normalizedPath, normalized))
-            return true;
-        const clean = normalized.replaceAll('**/', '').replaceAll('*', '');
-        return clean.length === 0 || normalizedPath.includes(clean) || normalizedPath.endsWith(clean);
-    });
-}
-/**
- * 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 function matchesGlob(path, pattern) {
-    const normalized = path.replaceAll('\\', '/');
-    if (pattern.startsWith('**/')) {
-        const suffix = pattern.slice(3);
-        if (suffix.indexOf('*') === -1) {
-            return normalized.endsWith(suffix) || normalized.endsWith(`/${suffix}`);
-        }
-    }
-    if (pattern === normalized)
-        return true;
-    return matchSegments(normalized.split('/'), pattern.split('/'), 0, 0);
-}
-/** Recursive segment-level glob matcher backing {@link matchesGlob}. */
-function matchSegments(file, pattern, fi, pi) {
-    if (pi >= pattern.length)
-        return fi >= file.length;
-    if (fi >= file.length)
-        return pattern.slice(pi).every((segment) => segment === '**');
-    const pat = pattern[pi] ?? '';
-    if (pat === '**') {
-        return matchSegments(file, pattern, fi, pi + 1) || matchSegments(file, pattern, fi + 1, pi);
-    }
-    if (!matchSegment(file[fi] ?? '', pat))
-        return false;
-    return matchSegments(file, pattern, fi + 1, pi + 1);
-}
-/** Match one path segment against a pattern segment where `*` matches any run of non-`/` chars. */
-function matchSegment(segment, pattern) {
-    if (pattern.indexOf('*') === -1)
-        return segment === pattern;
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replaceAll('*', '[^/]*');
-    return new RegExp(`^${escaped}$`).test(segment);
-}
-/** Escape a string for safe literal use inside a `RegExp` source. */
-export function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/** 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.
+ * - `./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 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) };
-}
+export { configArray, configNumber, configString, parseInlineFlags, stringArray, } from './config-access.js';
+export { DEFAULT_EXCLUDES, discoverFiles, readWorkdirFile, relativeParent, relativeToWorkdir, scanFiles, } from './file-discovery.js';
+export { escapeRegExp, matchesAny, matchesGlob } from './glob-match.js';

package/dist/evaluators/forbidden-import-evaluator.d.ts

@@ -17,6 +17,7 @@ import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type
  */
 export declare class ForbiddenImportEvaluator implements RuleEvaluator {
     /** Evaluate import/usage against the configured forbidden set. */
+    constructor();
     evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
     /** Legacy path: `{ patterns: string[] }`, substring-matched against import specifiers. */
     private evaluateSimple;

package/dist/evaluators/forbidden-import-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"forbidden-import-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/forbidden-import-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAclB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,wBAAyB,YAAW,aAAa;IAC1D,kEAAkE;IAC5D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAOzF,0FAA0F;YAC5E,cAAc;IAgC5B,4EAA4E;YAC9D,kBAAkB;CAiCnC"}
+{"version":3,"file":"forbidden-import-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/forbidden-import-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAclB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,wBAAyB,YAAW,aAAa;IAC1D,kEAAkE;;IAM5D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAOzF,0FAA0F;YAC5E,cAAc;IAkC5B,4EAA4E;YAC9D,kBAAkB;CAiCnC"}

package/dist/evaluators/forbidden-import-evaluator.js

@@ -1,3 +1,4 @@
+import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { createFinding, } from '../types.js';
 import { configArray, escapeRegExp, scanFiles, stringArray } from './file-utils.js';
 /**
@@ -18,6 +19,10 @@ import { configArray, escapeRegExp, scanFiles, stringArray } from './file-utils.
  */
 export class ForbiddenImportEvaluator {
     /** Evaluate import/usage against the configured forbidden set. */
+    // Explicit constructor avoids a V8 function-coverage phantom (synthesized default ctor).
+    constructor() {
+        // no-op; all state comes from evaluate() context
+    }
     async evaluate(rule, context) {
         const config = rule.evaluator.config ?? {};
         return Array.isArray(config.forbidden)
@@ -27,11 +32,13 @@ export class ForbiddenImportEvaluator {
     /** Legacy path: `{ patterns: string[] }`, substring-matched against import specifiers. */
     async evaluateSimple(rule, context, config) {
         const forbidden = configArray(config, 'patterns', undefined, { evaluator: 'forbidden-import' });
+        const fs = context.fileSystem ?? createNodeFileSystem();
         const files = await scanFiles({
             workdir: context.workdir,
             include: rule.include ?? ['.ts', '.tsx', '.js', '.jsx'],
             exclude: rule.exclude,
             matchMode: 'loose',
+            fs,
         });
         const findings = [];
         for (const { file, content } of files) {
@@ -60,8 +67,9 @@ export class ForbiddenImportEvaluator {
         }
         const exclude = stringArray(scope?.exclude) ?? [];
         const entries = config.forbidden.map(compileEntry);
+        const fs = context.fileSystem ?? createNodeFileSystem();
         // Anchored `**`-glob scoping: scanFiles' 'glob' mode applies matchesGlob precisely.
-        const files = await scanFiles({ workdir: context.workdir, include, exclude, matchMode: 'glob' });
+        const files = await scanFiles({ workdir: context.workdir, include, exclude, matchMode: 'glob', fs });
         const findings = [];
         for (const { file, content } of files) {
             const lines = content.split('\n');

package/dist/evaluators/glob-match.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Path-pattern matching for evaluators — two deliberately distinct algorithms.
+ *
+ * {@link matchesAny} is the loose, back-compatible fragment/suffix matcher;
+ * {@link matchesGlob} is the strict, anchored segment-aware glob matcher. They
+ * are NOT interchangeable (a bare `src/` matches different sets under each), so
+ * each evaluator picks the one that preserves its existing behavior.
+ */
+/**
+ * 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).
+ *
+ * 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;
+//# sourceMappingURL=glob-match.d.ts.map

package/dist/evaluators/glob-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-match.d.ts","sourceRoot":"","sources":["../../src/evaluators/glob-match.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,OAAO,CAShF;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAUlE;AAqBD,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dist/evaluators/glob-match.js

@@ -0,0 +1,78 @@
+/**
+ * Path-pattern matching for evaluators — two deliberately distinct algorithms.
+ *
+ * {@link matchesAny} is the loose, back-compatible fragment/suffix matcher;
+ * {@link matchesGlob} is the strict, anchored segment-aware glob matcher. They
+ * are NOT interchangeable (a bare `src/` matches different sets under each), so
+ * each evaluator picks the one that preserves its existing behavior.
+ */
+/**
+ * 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 function matchesAny(path, patterns) {
+    if (patterns === undefined || patterns.length === 0)
+        return true;
+    const normalizedPath = path.replaceAll('\\', '/');
+    return patterns.some((pattern) => {
+        const normalized = pattern.replaceAll('\\', '/');
+        if (normalized.includes('*') && matchesGlob(normalizedPath, normalized))
+            return true;
+        const clean = normalized.replaceAll('**/', '').replaceAll('*', '');
+        return clean.length === 0 || normalizedPath.includes(clean) || normalizedPath.endsWith(clean);
+    });
+}
+/**
+ * Segment-aware glob matching with `**` (any depth) and `*` (single segment).
+ *
+ * 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 function matchesGlob(path, pattern) {
+    const normalized = path.replaceAll('\\', '/');
+    if (pattern.startsWith('**/')) {
+        const suffix = pattern.slice(3);
+        if (suffix.indexOf('*') === -1) {
+            return normalized.endsWith(suffix) || normalized.endsWith(`/${suffix}`);
+        }
+    }
+    if (pattern === normalized)
+        return true;
+    return matchSegments(normalized.split('/'), pattern.split('/'), 0, 0);
+}
+/** Recursive segment-level glob matcher backing {@link matchesGlob}. */
+function matchSegments(file, pattern, fi, pi) {
+    if (pi >= pattern.length)
+        return fi >= file.length;
+    if (fi >= file.length)
+        return pattern.slice(pi).every((segment) => segment === '**');
+    const pat = pattern[pi] ?? '';
+    if (pat === '**') {
+        return matchSegments(file, pattern, fi, pi + 1) || matchSegments(file, pattern, fi + 1, pi);
+    }
+    if (!matchSegment(file[fi] ?? '', pat))
+        return false;
+    return matchSegments(file, pattern, fi + 1, pi + 1);
+}
+/** Match one path segment against a pattern segment where `*` matches any run of non-`/` chars. */
+function matchSegment(segment, pattern) {
+    if (pattern.indexOf('*') === -1)
+        return segment === pattern;
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replaceAll('*', '[^/]*');
+    return new RegExp(`^${escaped}$`).test(segment);
+}
+/** Escape a string for safe literal use inside a `RegExp` source. */
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/evaluators/import-boundary-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-boundary-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/import-boundary-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAUlB;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,uBAAwB,YAAW,aAAa;IACzD,4DAA4D;IACtD,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAsC5F"}
+{"version":3,"file":"import-boundary-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/import-boundary-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAUlB;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,uBAAwB,YAAW,aAAa;IACzD,4DAA4D;IACtD,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAuC5F"}

package/dist/evaluators/import-boundary-evaluator.js

@@ -1,3 +1,4 @@
+import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { createFinding, } from '../types.js';
 import { escapeRegExp, matchesGlob, scanFiles } from './file-utils.js';
 /**
@@ -28,7 +29,8 @@ export class ImportBoundaryEvaluator {
         }
         const compiled = boundaries.map((boundary, index) => compileBoundary(boundary, index));
         // Scan all files once (read up front); apply each boundary's globs in-memory below.
-        const allFiles = await scanFiles({ workdir: context.workdir, matchMode: 'glob' });
+        const fs = context.fileSystem ?? createNodeFileSystem();
+        const allFiles = await scanFiles({ workdir: context.workdir, matchMode: 'glob', fs });
         const findings = [];
         for (const boundary of compiled) {
             const inScope = allFiles

package/dist/evaluators/path-evaluator.d.ts

@@ -10,9 +10,8 @@ import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type
  *   exact paths relative to the workdir (`require` = must exist, `forbid` = must not).
  */
 export declare class PathEvaluator implements RuleEvaluator {
-    private readonly fs;
-    constructor();
     /** Evaluate required or forbidden paths in either config form. */
+    constructor();
     evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
     /** Glob form driven by `must` + the rule's include/exclude globs. */
     private evaluateGlob;

package/dist/evaluators/path-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/path-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;GASG;AACH,qBAAa,aAAc,YAAW,aAAa;IAC/C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAiB;;IAMpC,kEAAkE;IAC5D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IASzF,qEAAqE;YACvD,YAAY;IAuC1B,uEAAuE;YACzD,gBAAgB;CAmBjC"}
+{"version":3,"file":"path-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/path-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;GASG;AACH,qBAAa,aAAc,YAAW,aAAa;IAC/C,kEAAkE;;IAM5D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IASzF,qEAAqE;YACvD,YAAY;IAwC1B,uEAAuE;YACzD,gBAAgB;CAoBjC"}

package/dist/evaluators/path-evaluator.js

@@ -1,4 +1,4 @@
-import { joinPath, NodeFileSystem } from '@gobing-ai/ts-runtime';
+import { createNodeFileSystem, joinPath } from '@gobing-ai/ts-runtime';
 import { createFinding, } from '../types.js';
 import { configArray, configString, discoverFiles, matchesGlob } from './file-utils.js';
 /**
@@ -12,11 +12,11 @@ import { configArray, configString, discoverFiles, matchesGlob } from './file-ut
  *   exact paths relative to the workdir (`require` = must exist, `forbid` = must not).
  */
 export class PathEvaluator {
-    fs;
+    /** Evaluate required or forbidden paths in either config form. */
+    // 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 required or forbidden paths in either config form. */
     async evaluate(rule, context) {
         const config = rule.evaluator.config ?? {};
         const must = config.must;
@@ -29,7 +29,8 @@ export class PathEvaluator {
     async evaluateGlob(rule, context, must) {
         const include = rule.include ?? ['**'];
         const exclude = rule.exclude ?? [];
-        const files = await discoverFiles({ workdir: context.workdir });
+        const fs = context.fileSystem ?? createNodeFileSystem();
+        const files = await discoverFiles({ workdir: context.workdir, fs });
         const inScope = (file) => include.some((glob) => matchesGlob(file, glob)) && !exclude.some((glob) => matchesGlob(file, glob));
         const findings = [];
         if (must === 'present') {
@@ -57,9 +58,10 @@ export class PathEvaluator {
     async evaluateExplicit(rule, context, config) {
         const paths = configArray(config, 'paths', undefined, { evaluator: 'path' });
         const mode = configString(config, 'mode', 'require');
+        const fs = context.fileSystem ?? createNodeFileSystem();
         const findings = [];
         for (const path of paths) {
-            const exists = await this.fs.exists(joinPath(context.workdir, path));
+            const exists = await fs.exists(joinPath(context.workdir, path));
             if (mode === 'forbid' && exists) {
                 findings.push(createFinding(rule, `Forbidden path exists: ${path}`, path, { code: 'path:forbidden' }));
             }

package/dist/evaluators/regex-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/regex-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;GAQG;AACH,qBAAa,cAAe,YAAW,aAAa;;IAKhD,4DAA4D;IACtD,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAwD5F"}
+{"version":3,"file":"regex-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/regex-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;GAQG;AACH,qBAAa,cAAe,YAAW,aAAa;;IAKhD,4DAA4D;IACtD,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA0D5F"}

package/dist/evaluators/regex-evaluator.js

@@ -1,3 +1,4 @@
+import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { createFinding, } from '../types.js';
 import { configString, parseInlineFlags, scanFiles } from './file-utils.js';
 /**
@@ -19,11 +20,13 @@ export class RegexEvaluator {
         const { pattern, flags } = normalizePattern(configString(config, 'pattern', undefined, { evaluator: 'regex' }), configString(config, 'flags', ''), config.multiline === true);
         const mode = configString(config, 'mode', 'forbid');
         const regex = new RegExp(pattern, flags);
+        const fs = context.fileSystem ?? createNodeFileSystem();
         const files = await scanFiles({
             workdir: context.workdir,
             include: rule.include,
             exclude: rule.exclude,
             matchMode: 'loose',
+            fs,
         });
         const findings = [];
         for (const { file, content } of files) {

package/dist/evaluators/schema-artifact-evaluator.d.ts

@@ -13,9 +13,8 @@ import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type
  * - `requireRequiredArray` — enforce that `required` is a non-empty array (default: `false`).
  */
 export declare class SchemaArtifactEvaluator implements RuleEvaluator {
-    private readonly fs;
-    constructor();
     /** Evaluate the configured JSON schema artifact. */
+    constructor();
     evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
 }
 //# sourceMappingURL=schema-artifact-evaluator.d.ts.map

package/dist/evaluators/schema-artifact-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-artifact-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/schema-artifact-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;GAYG;AACH,qBAAa,uBAAwB,YAAW,aAAa;IACzD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAiB;;IAMpC,oDAAoD;IAC9C,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAiG5F"}
+{"version":3,"file":"schema-artifact-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/schema-artifact-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;GAYG;AACH,qBAAa,uBAAwB,YAAW,aAAa;IACzD,oDAAoD;;IAM9C,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAmG5F"}

package/dist/evaluators/schema-artifact-evaluator.js

@@ -1,4 +1,4 @@
-import { joinPath, NodeFileSystem } from '@gobing-ai/ts-runtime';
+import { createNodeFileSystem, joinPath } from '@gobing-ai/ts-runtime';
 import { createFinding, } from '../types.js';
 import { stringArray } from './file-utils.js';
 /**
@@ -15,12 +15,13 @@ import { stringArray } from './file-utils.js';
  * - `requireRequiredArray` — enforce that `required` is a non-empty array (default: `false`).
  */
 export class SchemaArtifactEvaluator {
-    fs;
+    /** Evaluate the configured JSON schema artifact. */
+    // 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 the configured JSON schema artifact. */
     async evaluate(rule, context) {
+        const fs = context.fileSystem ?? createNodeFileSystem();
         const config = rule.evaluator.config ?? {};
         const file = config.file;
         if (typeof file !== 'string' || file.length === 0) {
@@ -30,9 +31,9 @@ export class SchemaArtifactEvaluator {
         const requiredProperties = stringArray(config.requiredProperties);
         const requiredDefs = stringArray(config.requiredDefs);
         const requireRequiredArray = config.requireRequiredArray === true;
-        // Check existence.
         const absolutePath = joinPath(context.workdir, file);
-        const exists = await this.fs.exists(absolutePath);
+        // Check existence.
+        const exists = await fs.exists(absolutePath);
         if (!exists) {
             return {
                 findings: [
@@ -46,7 +47,7 @@ export class SchemaArtifactEvaluator {
         // Read and parse.
         let schema;
         try {
-            const raw = await this.fs.readFile(absolutePath);
+            const raw = await fs.readFile(absolutePath);
             schema = JSON.parse(raw);
         }
         catch (err) {

package/dist/evaluators/secrets-scanner-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secrets-scanner-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/secrets-scanner-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB,sCAAsC;AACtC,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,mBAAmB,CAAC;AA0BrG;;;;;;;;;;;;;;GAcG;AACH,qBAAa,uBAAwB,YAAW,aAAa;;IAKzD,iFAAiF;IAC3E,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA4B5F"}
+{"version":3,"file":"secrets-scanner-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/secrets-scanner-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB,sCAAsC;AACtC,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,mBAAmB,CAAC;AA0BrG;;;;;;;;;;;;;;GAcG;AACH,qBAAa,uBAAwB,YAAW,aAAa;;IAKzD,iFAAiF;IAC3E,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA6B5F"}

package/dist/evaluators/secrets-scanner-evaluator.js

@@ -1,3 +1,4 @@
+import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { createFinding, } from '../types.js';
 import { parseInlineFlags, scanFiles, stringArray } from './file-utils.js';
 // Patterns are assembled from a keyword group plus a value-shape suffix rather
@@ -41,7 +42,8 @@ export class SecretsScannerEvaluator {
         const scope = config.scope;
         const include = stringArray(scope?.include) ?? rule.include;
         const exclude = stringArray(scope?.exclude) ?? rule.exclude;
-        const files = await scanFiles({ workdir: context.workdir, include, exclude, matchMode: 'loose' });
+        const fs = context.fileSystem ?? createNodeFileSystem();
+        const files = await scanFiles({ workdir: context.workdir, include, exclude, matchMode: 'loose', fs });
         const findings = [];
         for (const { file, content } of files) {
             const lines = content.split('\n');

package/dist/evaluators/test-location-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-location-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/test-location-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,KAAK,gBAAgB,EAA8B,MAAM,iCAAiC,CAAC;AACpG,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAWlB;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IAE3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;IADvC,kFAAkF;gBACrD,SAAS,CAAC,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,YAAA;IAE7E,0EAA0E;IACpE,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAyDzF;;;;;OAKG;IACH,OAAO,CAAC,cAAc;CASzB"}
+{"version":3,"file":"test-location-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/test-location-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,KAAK,gBAAgB,EAA8B,MAAM,iCAAiC,CAAC;AACpG,OAAO,EAEH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAWlB;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IAE3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;IADvC,kFAAkF;gBACrD,SAAS,CAAC,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,YAAA;IAE7E,0EAA0E;IACpE,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA0DzF;;;;;OAKG;IACH,OAAO,CAAC,cAAc;CASzB"}

package/dist/evaluators/test-location-evaluator.js

@@ -1,3 +1,4 @@
+import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { TypeScriptTestPathResolver } from '../resolvers/test-path-resolver.js';
 import { createFinding, } from '../types.js';
 import { discoverFiles, matchesGlob } from './file-utils.js';
@@ -31,8 +32,9 @@ export class TestLocationEvaluator {
         const forbid = config.forbid ?? [];
         const include = rule.include ?? ['**/*.test.ts', '**/*.test.tsx', '**/*.spec.ts', '**/*.spec.tsx'];
         const exclude = rule.exclude ?? [];
-        const allFiles = await discoverFiles({ workdir: context.workdir });
         const findings = [];
+        const fs = context.fileSystem ?? createNodeFileSystem();
+        const allFiles = await discoverFiles({ workdir: context.workdir, fs });
         const testPatterns = config.requireCorrespondingTest ? [expected] : include;
         const testFiles = allFiles.filter((file) => testPatterns.some((pattern) => matchesGlob(file, pattern)));
         for (const file of testFiles) {

package/dist/evaluators/tsdoc-export-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsdoc-export-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/tsdoc-export-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAwBlB;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,aAAa;;IAKtD,+EAA+E;IACzE,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA8B5F"}
+{"version":3,"file":"tsdoc-export-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/tsdoc-export-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAwBlB;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,aAAa;;IAKtD,+EAA+E;IACzE,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA+B5F"}