@gobing-ai/ts-rule-engine 0.2.6 → 0.2.8

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

@@ -8,12 +8,18 @@ import { discoverFiles, matchesGlob } from './file-utils.js';
  * - `expected`: glob the test files must match (required)
  * - `forbid`: globs where tests must not live (e.g. `**\/__tests__/**`)
  * - `requireCorrespondingTest`: when true, flags source files (from `rule.include`)
- *   that lack a test at the TypeScript-conventional path
+ *   that lack a test at the resolver's conventional path
+ * - `resolver`: language resolver name (`typescript` default, or `python`/`go`/`rust`)
  *
  * Discovery walks the workdir and applies `**` globs precisely, so it stays
  * self-contained (no `rg --files` shell-out).
  */
 export class TestLocationEvaluator {
+    resolvers;
+    /** Optional resolver registry; when absent, the TypeScript convention is used. */
+    constructor(resolvers) {
+        this.resolvers = resolvers;
+    }
     /** Evaluate test-file placement and optional coverage of source files. */
     async evaluate(rule, context) {
         const config = (rule.evaluator.config ?? {});
@@ -33,18 +39,19 @@ export class TestLocationEvaluator {
                 continue;
             const violated = forbid.find((pattern) => matchesGlob(file, pattern));
             if (violated !== undefined) {
-                findings.push(createFinding(rule, `Test file "${file}" is in a forbidden location (matches "${violated}")`, file, {
+                findings.push(createFinding(rule, `test file in forbidden location (matches "${violated}")`, file, {
                     code: 'test-location:forbidden',
                 }));
                 continue;
             }
             if (!matchesGlob(file, expected)) {
-                findings.push(createFinding(rule, `Test file "${file}" does not match expected pattern "${expected}"`, file, {
+                findings.push(createFinding(rule, `test file outside expected location (expected "${expected}")`, file, {
                     code: 'test-location:unexpected',
                 }));
             }
         }
         if (config.requireCorrespondingTest) {
+            const resolver = this.selectResolver(config.resolver);
             const srcPatterns = rule.include ?? ['**/*.ts', '**/*.tsx'];
             const testSet = new Set(testFiles);
             for (const srcFile of allFiles) {
@@ -52,11 +59,11 @@ export class TestLocationEvaluator {
                     continue;
                 if (exclude.some((pattern) => matchesGlob(srcFile, pattern)))
                     continue;
-                const testPath = resolveTestPath(srcFile);
+                const testPath = resolver.resolveTestPath(srcFile);
                 if (testPath === srcFile)
                     continue;
                 if (!testSet.has(testPath)) {
-                    findings.push(createFinding(rule, `Source file "${srcFile}" has no corresponding test → ${testPath}`, srcFile, {
+                    findings.push(createFinding(rule, `no corresponding test → ${testPath}`, srcFile, {
                         code: 'test-location:missing',
                     }));
                 }
@@ -64,22 +71,35 @@ export class TestLocationEvaluator {
         }
         return { findings, fixes: [] };
     }
-}
-/**
- * Map a TypeScript source path to its conventional test path.
- *
- *   packages/core/src/foo/bar.ts → packages/core/tests/foo/bar.test.ts
- *   src/foo/bar.ts               → tests/foo/bar.test.ts
- */
-function resolveTestPath(srcRelPath) {
-    if (srcRelPath.includes('.test.') || srcRelPath.includes('.spec.'))
-        return srcRelPath;
-    const srcIdx = srcRelPath.indexOf('/src/');
-    if (srcIdx !== -1) {
-        const pkg = srcRelPath.slice(0, srcIdx);
-        const rel = srcRelPath.slice(srcIdx + '/src/'.length).replace(/\.(ts|tsx|js|jsx)$/, '.test.ts');
-        return `${pkg}/tests/${rel}`;
+    /**
+     * Pick the resolver named in config (default `typescript`).
+     *
+     * Falls back to the built-in TypeScript convention when no registry was
+     * injected; throws if a named resolver is requested but not registered.
+     */
+    selectResolver(name = 'typescript') {
+        if (this.resolvers === undefined) {
+            if (name !== 'typescript') {
+                throw new Error(`test-location resolver "${name}" requested but no resolver registry is available`);
+            }
+            return TYPESCRIPT_FALLBACK;
+        }
+        return this.resolvers.get(name);
     }
-    const withoutExt = srcRelPath.replace(/\.(ts|tsx|js|jsx)$/, '');
-    return `tests/${withoutExt.replace(/^src\//, '')}.test.ts`;
 }
+/** Built-in TypeScript convention used when no resolver registry is injected. */
+const TYPESCRIPT_FALLBACK = {
+    name: 'typescript',
+    resolveTestPath(srcRelPath) {
+        if (srcRelPath.includes('.test.') || srcRelPath.includes('.spec.'))
+            return srcRelPath;
+        const srcIdx = srcRelPath.indexOf('/src/');
+        if (srcIdx !== -1) {
+            const pkg = srcRelPath.slice(0, srcIdx);
+            const rel = srcRelPath.slice(srcIdx + '/src/'.length).replace(/\.(ts|tsx|js|jsx)$/, '.test.ts');
+            return `${pkg}/tests/${rel}`;
+        }
+        const withoutExt = srcRelPath.replace(/\.(ts|tsx|js|jsx)$/, '');
+        return `tests/${withoutExt.replace(/^src\//, '')}.test.ts`;
+    },
+};

package/dist/evaluators/tsdoc-export-evaluator.js

@@ -3,8 +3,8 @@ import { discoverFiles, matchesGlob, readWorkdirFile } from './file-utils.js';
 /** Export kinds this evaluator can check for a preceding JSDoc block. */
 const VALID_KINDS = ['function', 'class', 'type', 'const', 'enum', 'interface'];
 const KIND_PATTERN = {
-    function: /^export\s+(?:async\s+)?function\s+([A-Za-z0-9_$]+)/,
-    class: /^export\s+(?:abstract\s+)?class\s+([A-Za-z0-9_$]+)/,
+    function: /^export\s+(?:default\s+)?(?:async\s+)?function\s*\*?\s+([A-Za-z0-9_$]+)/,
+    class: /^export\s+(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z0-9_$]+)/,
     interface: /^export\s+interface\s+([A-Za-z0-9_$]+)/,
     type: /^export\s+type\s+([A-Za-z0-9_$]+)/,
     const: /^export\s+const\s+([A-Za-z0-9_$]+)/,
@@ -70,8 +70,22 @@ function findExports(lines, requested) {
     }
     return sites;
 }
-/** True when the line immediately above a declaration closes a JSDoc block. */
+/**
+ * True when a JSDoc block precedes a declaration.
+ *
+ * Skips decorator lines (`@Component(...)`) so a documented but decorated class
+ * is not falsely flagged, then checks whether the nearest preceding non-decorator
+ * line closes (or is) a JSDoc comment.
+ */
 function precededByJsdoc(lines, declarationLine) {
-    const prev = lines[declarationLine - 2]?.trim();
-    return prev !== undefined && (prev.endsWith('*/') || prev.startsWith('/**'));
+    let cursor = declarationLine - 2; // zero-based line above the declaration
+    while (cursor >= 0) {
+        const prev = lines[cursor]?.trim() ?? '';
+        if (prev.startsWith('@')) {
+            cursor -= 1; // decorator — keep walking up
+            continue;
+        }
+        return prev.endsWith('*/') || prev.startsWith('/**');
+    }
+    return false;
 }

package/dist/fixers/fixers.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Core fixer pipeline: provider contracts, built-in fixer implementations,
+ * and the byte-range fix application function.
+ *
+ * @module rule-engine/fixers
+ */
+import { NodeFileSystem, type ProcessExecutor } from '@gobing-ai/ts-runtime';
+import type { CapabilityRegistry } from '../host/capability-registry';
+import type { TestPathResolver } from '../resolvers/test-path-resolver';
+import type { ConstraintFinding, ConstraintRule, Fix, FixMode, RuleContext } from '../types';
+/** Numeric ordering for fix authority; higher means more write authority. */
+export declare const FIX_MODE_RANK: Record<FixMode, number>;
+/** Result of resolving effective fix authority for a rule. */
+export interface EffectiveFix {
+    /** Effective mode after all downgrades. */
+    readonly mode: FixMode;
+    /** Optional replacement text configured by the rule author. */
+    readonly replacement?: string;
+    /** Optional provider-specific parameters. */
+    readonly params?: Record<string, unknown>;
+}
+/** Input passed to a rule fixer provider. */
+export interface RuleFixerInput {
+    /** Rule that produced the findings. */
+    readonly rule: ConstraintRule;
+    /** Rule execution context. */
+    readonly context: RuleContext;
+    /** Findings emitted for this rule. */
+    readonly findings: ConstraintFinding[];
+    /** Effective fix metadata after authority enforcement. */
+    readonly fix: EffectiveFix;
+}
+/** Provider that turns findings into byte-range fixes. */
+export interface RuleFixerProvider {
+    /** Produce fixes for mechanically fixable findings. */
+    createFixes(input: RuleFixerInput): Fix[] | Promise<Fix[]>;
+}
+/** Result of applying or previewing a batch of fixes. */
+export interface FixApplicationResult {
+    /** Files changed in memory or on disk. */
+    readonly changedFiles: string[];
+    /** Fixes successfully applied. */
+    readonly applied: Fix[];
+    /** Fixes skipped because they overlapped an already-applied edit. */
+    readonly deferred: Fix[];
+    /** Unified diff when dry-run mode is requested. */
+    readonly diff: string;
+}
+/** Dependencies required for the built-in fixer registry. */
+export interface BuiltInFixersDeps {
+    /** Resolver registry, required for TestStubFixer. */
+    resolvers: CapabilityRegistry<TestPathResolver>;
+}
+/** Registry of built-in rule fixer providers keyed by evaluator type. */
+export declare function builtInFixers(host?: BuiltInFixersDeps, exec?: ProcessExecutor): Map<string, RuleFixerProvider>;
+/** Resolve a workdir-relative or absolute path to an absolute path. */
+export declare function resolveWorkdirPath(workdir: string, filePath: string): string;
+/** Apply byte-range fixes to files, optionally returning a dry-run diff only. */
+export declare function applyFixes(workdir: string, fixes: readonly Fix[], dryRun?: boolean, fs?: NodeFileSystem): Promise<FixApplicationResult>;
+/** Create a coarse unified diff string for dry-run CLI output. */
+export declare function createUnifiedDiff(filePath: string, before: string, after: string): string;
+/**
+ * Fixer provider for `regex` / `rg` evaluators.
+ *
+ * For each finding with a known line number, reads the file and emits a Fix that
+ * replaces every regex match on that line using `rule.fix.replacement` as the
+ * replacement string (supports `$1` / `$&` back-references).
+ */
+export declare class RegexFixerProvider implements RuleFixerProvider {
+    private readonly fs;
+    /** Produce fixes for regex-evaluator findings. */
+    createFixes({ rule, context, findings, fix }: RuleFixerInput): Promise<Fix[]>;
+}
+/**
+ * Fixer provider for `path` / `file-exist` evaluators.
+ *
+ * In `auto` mode, when a rule requires a file to be absent (`must: absent`),
+ * emits a Fix that replaces the entire file content with an empty string.
+ * `applyFixes` interprets a zero-length result spanning the full file as a deletion.
+ */
+export declare class PathFixerProvider implements RuleFixerProvider {
+    private readonly fs;
+    /** Produce deletion fixes for path-evaluator findings. */
+    createFixes({ rule, context, findings, fix }: RuleFixerInput): Promise<Fix[]>;
+}
+//# sourceMappingURL=fixers.d.ts.map

package/dist/fixers/fixers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixers.d.ts","sourceRoot":"","sources":["../../src/fixers/fixers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG7F,6EAA6E;AAC7E,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAIjD,CAAC;AAEF,8DAA8D;AAC9D,MAAM,WAAW,YAAY;IACzB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED,6CAA6C;AAC7C,MAAM,WAAW,cAAc;IAC3B,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IACvC,0DAA0D;IAC1D,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;CAC9B;AAED,0DAA0D;AAC1D,MAAM,WAAW,iBAAiB;IAC9B,uDAAuD;IACvD,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;CAC9D;AAED,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAChC,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC;IACzB,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACzB;AAED,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAC9B,qDAAqD;IACrD,SAAS,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;CACnD;AAED,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,iBAAiB,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAa9G;AAED,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,iFAAiF;AACjF,wBAAsB,UAAU,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,GAAG,EAAE,EACrB,MAAM,UAAQ,EACd,EAAE,GAAE,cAAqC,GAC1C,OAAO,CAAC,oBAAoB,CAAC,CA0D/B;AAED,kEAAkE;AAClE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAOzF;AA8BD;;;;;;GAMG;AACH,qBAAa,kBAAmB,YAAW,iBAAiB;IACxD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAwB;IAE3C,kDAAkD;IAC5C,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAkCtF;AAED;;;;;;GAMG;AACH,qBAAa,iBAAkB,YAAW,iBAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAwB;IAE3C,0DAA0D;IACpD,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAoBtF"}

package/dist/fixers/fixers.js

@@ -0,0 +1,230 @@
+/**
+ * Core fixer pipeline: provider contracts, built-in fixer implementations,
+ * and the byte-range fix application function.
+ *
+ * @module rule-engine/fixers
+ */
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { NodeFileSystem } from '@gobing-ai/ts-runtime';
+import { TestStubFixer } from './test-stub-fixer.js';
+/** Numeric ordering for fix authority; higher means more write authority. */
+export const FIX_MODE_RANK = {
+    none: 0,
+    suggest: 1,
+    auto: 2,
+};
+/** Registry of built-in rule fixer providers keyed by evaluator type. */
+export function builtInFixers(host, exec) {
+    const regexFixer = new RegexFixerProvider();
+    const pathFixer = new PathFixerProvider();
+    const entries = [
+        ['regex', regexFixer],
+        ['rg', regexFixer],
+        ['path', pathFixer],
+        ['file-exist', pathFixer],
+    ];
+    if (host && exec) {
+        entries.push(['test-location', new TestStubFixer({ resolvers: host.resolvers, processExecutor: exec })]);
+    }
+    return new Map(entries);
+}
+/** Resolve a workdir-relative or absolute path to an absolute path. */
+export function resolveWorkdirPath(workdir, filePath) {
+    return isAbsolute(filePath) ? filePath : join(workdir, filePath);
+}
+/** Apply byte-range fixes to files, optionally returning a dry-run diff only. */
+export async function applyFixes(workdir, fixes, dryRun = false, fs = new NodeFileSystem()) {
+    const byFile = new Map();
+    for (const fix of fixes) {
+        const list = byFile.get(fix.filePath) ?? [];
+        list.push(fix);
+        byFile.set(fix.filePath, list);
+    }
+    const applied = [];
+    const deferred = [];
+    const changedFiles = [];
+    const diffs = [];
+    for (const [filePath, fileFixes] of byFile) {
+        const absPath = resolveWorkdirPath(workdir, filePath);
+        if (!isInsideWorkdir(workdir, absPath)) {
+            deferred.push(...fileFixes);
+            continue;
+        }
+        const fileExists = await fs.exists(absPath);
+        const original = fileExists ? await fs.readFile(absPath) : '';
+        const selected = selectNonOverlappingFixes(fileFixes);
+        deferred.push(...selected.deferred);
+        let next = original;
+        for (const fix of [...selected.applied].sort((a, b) => b.start - a.start)) {
+            if (!fileExists && (fix.start !== 0 || fix.end !== 0)) {
+                deferred.push(fix);
+                continue;
+            }
+            if (!isValidRange(fix.start, fix.end, original.length)) {
+                deferred.push(fix);
+                continue;
+            }
+            next = `${next.slice(0, fix.start)}${fix.replacement}${next.slice(fix.end)}`;
+            applied.push(fix);
+        }
+        if (next === original) {
+            continue;
+        }
+        changedFiles.push(filePath);
+        diffs.push(createUnifiedDiff(filePath, original, next));
+        if (!dryRun) {
+            const isFullDeletion = next.length === 0 && selected.applied.some((fix) => fix.start === 0 && fix.end === original.length);
+            if (isFullDeletion) {
+                await fs.unlink(absPath);
+            }
+            else {
+                await fs.writeFile(absPath, next);
+            }
+        }
+    }
+    return { changedFiles, applied, deferred, diff: diffs.join('\n') };
+}
+/** Create a coarse unified diff string for dry-run CLI output. */
+export function createUnifiedDiff(filePath, before, after) {
+    const beforeLines = before.split('\n');
+    const afterLines = after.split('\n');
+    const lines = [`--- ${filePath}`, `+++ ${filePath}`, `@@ -1,${beforeLines.length} +1,${afterLines.length} @@`];
+    lines.push(...beforeLines.map((line) => `-${line}`));
+    lines.push(...afterLines.map((line) => `+${line}`));
+    return lines.join('\n');
+}
+/** Select the maximal non-overlapping set of fixes, ordered by ascending start offset. */
+function selectNonOverlappingFixes(fixes) {
+    const applied = [];
+    const deferred = [];
+    const ordered = [...fixes].sort((a, b) => a.start - b.start || a.end - b.end);
+    let lastEnd = -1;
+    for (const fix of ordered) {
+        if (fix.start < lastEnd) {
+            deferred.push(fix);
+            continue;
+        }
+        applied.push(fix);
+        lastEnd = fix.end;
+    }
+    return { applied, deferred };
+}
+/** Return true when absPath is at or below workdir. */
+function isInsideWorkdir(workdir, absPath) {
+    const rel = relative(resolve(workdir), resolve(absPath));
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+/** Return true when [start, end] is a valid byte range for a string of contentLength bytes. */
+function isValidRange(start, end, contentLength) {
+    return start >= 0 && end >= start && end <= contentLength;
+}
+/**
+ * Fixer provider for `regex` / `rg` evaluators.
+ *
+ * For each finding with a known line number, reads the file and emits a Fix that
+ * replaces every regex match on that line using `rule.fix.replacement` as the
+ * replacement string (supports `$1` / `$&` back-references).
+ */
+export class RegexFixerProvider {
+    fs = new NodeFileSystem();
+    /** Produce fixes for regex-evaluator findings. */
+    async createFixes({ rule, context, findings, fix }) {
+        if (fix.mode === 'none' || fix.replacement === undefined)
+            return [];
+        // After the guard above, mode is guaranteed to not be 'none'.
+        const fixMode = fix.mode;
+        const replacement = fix.replacement;
+        const pattern = rule.evaluator.config?.pattern;
+        if (typeof pattern !== 'string' || pattern.length === 0)
+            return [];
+        const flags = flagsFromRule(rule);
+        const regex = new RegExp(pattern, flags.includes('g') ? flags : `${flags}g`);
+        const fixes = [];
+        for (const finding of findings) {
+            if (!finding.filePath)
+                continue;
+            const absPath = resolveWorkdirPath(context.workdir, finding.filePath);
+            if (!isInsideWorkdir(context.workdir, absPath) || finding.line == null)
+                continue;
+            if (!(await this.fs.exists(absPath)))
+                continue;
+            const source = await this.fs.readFile(absPath);
+            const line = getLineRange(source, finding.line);
+            if (!line)
+                continue;
+            for (const match of source.slice(line.start, line.end).matchAll(regex)) {
+                if (match.index === undefined)
+                    continue;
+                const matched = match[0];
+                fixes.push({
+                    ruleId: rule.id,
+                    filePath: finding.filePath,
+                    start: line.start + match.index,
+                    end: line.start + match.index + matched.length,
+                    replacement: matched.replace(new RegExp(pattern, flags), replacement),
+                    mode: fixMode,
+                });
+            }
+        }
+        return fixes;
+    }
+}
+/**
+ * Fixer provider for `path` / `file-exist` evaluators.
+ *
+ * In `auto` mode, when a rule requires a file to be absent (`must: absent`),
+ * emits a Fix that replaces the entire file content with an empty string.
+ * `applyFixes` interprets a zero-length result spanning the full file as a deletion.
+ */
+export class PathFixerProvider {
+    fs = new NodeFileSystem();
+    /** Produce deletion fixes for path-evaluator findings. */
+    async createFixes({ rule, context, findings, fix }) {
+        if (fix.mode !== 'auto' || rule.evaluator.config?.must !== 'absent')
+            return [];
+        const fixes = [];
+        for (const finding of findings) {
+            if (!finding.filePath)
+                continue;
+            const absPath = resolveWorkdirPath(context.workdir, finding.filePath);
+            if (!isInsideWorkdir(context.workdir, absPath))
+                continue;
+            if (!(await this.fs.exists(absPath)))
+                continue;
+            const content = await this.fs.readFile(absPath);
+            fixes.push({
+                ruleId: rule.id,
+                filePath: finding.filePath,
+                start: 0,
+                end: content.length,
+                replacement: '',
+                mode: 'auto',
+            });
+        }
+        return fixes;
+    }
+}
+/** Extract regex flags from a rule's evaluator config. */
+function flagsFromRule(rule) {
+    const raw = rule.evaluator.config?.flags;
+    if (typeof raw !== 'string')
+        return '';
+    if (raw.startsWith('(?') && raw.endsWith(')')) {
+        return raw.slice(2, -1).replace(/[^imsuy]/g, '');
+    }
+    return raw.replace(/[^imsuy]/g, '');
+}
+/** Return the byte range [start, end) of a one-based line number within source. */
+function getLineRange(source, oneBasedLine) {
+    if (oneBasedLine < 1)
+        return null;
+    let start = 0;
+    for (let line = 1; line < oneBasedLine; line += 1) {
+        const next = source.indexOf('\n', start);
+        if (next === -1)
+            return null;
+        start = next + 1;
+    }
+    const newline = source.indexOf('\n', start);
+    return { start, end: newline === -1 ? source.length : newline };
+}

package/dist/fixers/test-stub-fixer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Fixer that generates test file skeletons for source files missing tests.
+ *
+ * Resolver-aware: selects the correct {@link TestPathResolver} from
+ * `rule.evaluator.config.resolver`. Passes empty exports to the resolver's
+ * `generateSkeleton` — AST / sg discovery is intentionally omitted here to
+ * keep the shared package dependency-free; callers that need export-aware
+ * skeletons should register a custom resolver that performs its own discovery.
+ * Never overwrites an existing test file.
+ *
+ * @module rule-engine/fixers/test-stub-fixer
+ */
+import { type ProcessExecutor } from '@gobing-ai/ts-runtime';
+import type { CapabilityRegistry } from '../host/capability-registry';
+import type { TestPathResolver } from '../resolvers/test-path-resolver';
+import type { Fix } from '../types';
+import type { RuleFixerInput, RuleFixerProvider } from './fixers';
+/** File-system seam for dependency injection in tests. */
+export interface TestStubFileSystem {
+    /** Resolve to true if the path exists on disk. */
+    exists(path: string): Promise<boolean>;
+}
+/** Real file-system implementation backed by the runtime FileSystem seam. */
+export declare const realFileSystem: TestStubFileSystem;
+/** Dependencies injected into {@link TestStubFixer}. */
+export interface TestStubFixerDeps {
+    /** Resolver registry from the engine host. */
+    readonly resolvers: CapabilityRegistry<TestPathResolver>;
+    /** Process executor (reserved for future export discovery). */
+    readonly processExecutor: ProcessExecutor;
+    /** Optional file-system override for testing. */
+    readonly fileSystem?: TestStubFileSystem;
+}
+/**
+ * Fixer provider for the `test-location` evaluator.
+ *
+ * Emits a create-file Fix (start=0, end=0) for each finding whose source file
+ * has no corresponding test file yet. The test path and skeleton content are
+ * produced by the resolver named in `rule.evaluator.config.resolver`
+ * (default: `typescript`).
+ */
+export declare class TestStubFixer implements RuleFixerProvider {
+    private readonly resolvers;
+    private readonly fs;
+    constructor(deps: TestStubFixerDeps);
+    /** Produce create-file fixes for missing test stubs. */
+    createFixes(input: RuleFixerInput): Promise<Fix[]>;
+}
+//# sourceMappingURL=test-stub-fixer.d.ts.map

package/dist/fixers/test-stub-fixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-stub-fixer.d.ts","sourceRoot":"","sources":["../../src/fixers/test-stub-fixer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElE,0DAA0D;AAC1D,MAAM,WAAW,kBAAkB;IAC/B,kDAAkD;IAClD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1C;AAED,6EAA6E;AAC7E,eAAO,MAAM,cAAc,EAAE,kBAAyC,CAAC;AAEvE,wDAAwD;AACxD,MAAM,WAAW,iBAAiB;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;IACzD,+DAA+D;IAC/D,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,iDAAiD;IACjD,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;CAC5C;AAUD;;;;;;;GAOG;AACH,qBAAa,aAAc,YAAW,iBAAiB;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuC;IACjE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAqB;gBAE5B,IAAI,EAAE,iBAAiB;IAOnC,wDAAwD;IAClD,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAkD3D"}

package/dist/fixers/test-stub-fixer.js

@@ -0,0 +1,91 @@
+/**
+ * Fixer that generates test file skeletons for source files missing tests.
+ *
+ * Resolver-aware: selects the correct {@link TestPathResolver} from
+ * `rule.evaluator.config.resolver`. Passes empty exports to the resolver's
+ * `generateSkeleton` — AST / sg discovery is intentionally omitted here to
+ * keep the shared package dependency-free; callers that need export-aware
+ * skeletons should register a custom resolver that performs its own discovery.
+ * Never overwrites an existing test file.
+ *
+ * @module rule-engine/fixers/test-stub-fixer
+ */
+import { isAbsolute, join } from 'node:path';
+import { NodeFileSystem } from '@gobing-ai/ts-runtime';
+/** Real file-system implementation backed by the runtime FileSystem seam. */
+export const realFileSystem = new NodeFileSystem();
+/** Normalize a finding path to a repository-relative POSIX path, or return null when invalid. */
+function normalizeFindingPath(filePath) {
+    if (!filePath || isAbsolute(filePath))
+        return null;
+    const normalized = filePath.replaceAll('\\', '/').replace(/^\.\//, '');
+    if (normalized === '..' || normalized.startsWith('../') || normalized.includes('/../'))
+        return null;
+    return normalized;
+}
+/**
+ * Fixer provider for the `test-location` evaluator.
+ *
+ * Emits a create-file Fix (start=0, end=0) for each finding whose source file
+ * has no corresponding test file yet. The test path and skeleton content are
+ * produced by the resolver named in `rule.evaluator.config.resolver`
+ * (default: `typescript`).
+ */
+export class TestStubFixer {
+    resolvers;
+    fs;
+    constructor(deps) {
+        this.resolvers = deps.resolvers;
+        // processExecutor is accepted for interface parity but export discovery
+        // is not performed in this shared-package implementation — see module doc.
+        this.fs = deps.fileSystem ?? realFileSystem;
+    }
+    /** Produce create-file fixes for missing test stubs. */
+    async createFixes(input) {
+        const { rule, context, findings, fix } = input;
+        if (fix.mode === 'none')
+            return [];
+        const resolverName = rule.evaluator.config?.resolver ?? 'typescript';
+        let resolver;
+        try {
+            resolver = this.resolvers.get(resolverName);
+        }
+        catch {
+            // Resolver not registered — return no fixes rather than silently falling back.
+            return [];
+        }
+        const result = [];
+        for (const finding of findings) {
+            if (!finding.filePath)
+                continue;
+            const srcRelPath = normalizeFindingPath(finding.filePath);
+            if (!srcRelPath)
+                continue;
+            let testRelPath;
+            try {
+                testRelPath = resolver.resolveTestPath(srcRelPath);
+            }
+            catch {
+                continue;
+            }
+            const absTestPath = join(context.workdir, testRelPath);
+            if (await this.fs.exists(absTestPath))
+                continue;
+            // Export discovery is intentionally omitted — pass empty exports array.
+            // Resolvers that need per-export stubs should perform their own discovery.
+            const skeleton = resolver.generateSkeleton?.(srcRelPath, []) ?? '';
+            if (!skeleton)
+                continue;
+            result.push({
+                ruleId: rule.id,
+                filePath: testRelPath,
+                start: 0,
+                end: 0,
+                replacement: skeleton,
+                // fix.mode !== 'none' is guaranteed by the guard at the top of this method.
+                mode: fix.mode,
+            });
+        }
+        return result;
+    }
+}

package/dist/host/builtins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../../src/host/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAY7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,CAgBvF"}
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../../src/host/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAqB7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,CAuBvF"}

package/dist/host/builtins.js

@@ -2,13 +2,17 @@ import { AgentDetectionEvaluator } from '../evaluators/agent-detection-evaluator
 import { CoverageGateEvaluator } from '../evaluators/coverage-gate-evaluator.js';
 import { ExitCodeEvaluator } from '../evaluators/exit-code-evaluator.js';
 import { ForbiddenImportEvaluator } from '../evaluators/forbidden-import-evaluator.js';
+import { ImportBoundaryEvaluator } from '../evaluators/import-boundary-evaluator.js';
 import { PathEvaluator } from '../evaluators/path-evaluator.js';
 import { RegexEvaluator } from '../evaluators/regex-evaluator.js';
+import { SchemaArtifactEvaluator } from '../evaluators/schema-artifact-evaluator.js';
 import { SecretsScannerEvaluator } from '../evaluators/secrets-scanner-evaluator.js';
+import { SgEvaluator } from '../evaluators/sg-evaluator.js';
 import { TestLocationEvaluator } from '../evaluators/test-location-evaluator.js';
 import { TsdocExportEvaluator } from '../evaluators/tsdoc-export-evaluator.js';
 import { JsonFormatter } from '../formatters/json.js';
 import { TextFormatter } from '../formatters/text.js';
+import { GoTestPathResolver, PythonTestPathResolver, RustTestPathResolver, TypeScriptTestPathResolver, } from '../resolvers/test-path-resolver.js';
 /** Register bundled evaluators and formatters on a host. */
 export function registerBuiltins(host, executor) {
     const regex = new RegexEvaluator();
@@ -23,7 +27,14 @@ export function registerBuiltins(host, executor) {
     host.evaluators.register('agent-detection', new AgentDetectionEvaluator(), 'builtin');
     host.evaluators.register('coverage-gate', new CoverageGateEvaluator(), 'builtin');
     host.evaluators.register('tsdoc-export', new TsdocExportEvaluator(), 'builtin');
-    host.evaluators.register('test-location', new TestLocationEvaluator(), 'builtin');
+    host.resolvers.register('typescript', new TypeScriptTestPathResolver(), 'builtin');
+    host.resolvers.register('python', new PythonTestPathResolver(), 'builtin');
+    host.resolvers.register('go', new GoTestPathResolver(), 'builtin');
+    host.resolvers.register('rust', new RustTestPathResolver(), 'builtin');
+    host.evaluators.register('test-location', new TestLocationEvaluator(host.resolvers), 'builtin');
+    host.evaluators.register('sg', new SgEvaluator(executor), 'builtin');
+    host.evaluators.register('schema-artifact', new SchemaArtifactEvaluator(), 'builtin');
+    host.evaluators.register('import-boundary', new ImportBoundaryEvaluator(), 'builtin');
     host.formatters.register('text', new TextFormatter(), 'builtin');
     host.formatters.register('json', new JsonFormatter(), 'builtin');
 }