@gobing-ai/ts-rule-engine 0.2.5 → 0.2.7

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":"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"}

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;AAS7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,4DAA4D;AAC5D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,CAavF"}
+{"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

@@ -1,11 +1,18 @@
 import { AgentDetectionEvaluator } from '../evaluators/agent-detection-evaluator.js';
+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();
@@ -18,6 +25,16 @@ export function registerBuiltins(host, executor) {
     host.evaluators.register('exit-code', new ExitCodeEvaluator(executor), 'builtin');
     host.evaluators.register('secrets-scanner', new SecretsScannerEvaluator(), 'builtin');
     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.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');
 }

package/dist/host/rule-engine-host.d.ts

@@ -1,3 +1,4 @@
+import type { TestPathResolver } from '../resolvers/test-path-resolver';
 import type { ResultFormatter, RuleEvaluator } from '../types';
 import { CapabilityRegistry } from './capability-registry';
 /** Host container for rule-engine capabilities. */
@@ -6,6 +7,8 @@ export declare class RuleEngineHost {
     readonly evaluators: CapabilityRegistry<RuleEvaluator>;
     /** Formatter registry keyed by formatter name. */
     readonly formatters: CapabilityRegistry<ResultFormatter>;
+    /** Test-path resolver registry keyed by language name. */
+    readonly resolvers: CapabilityRegistry<TestPathResolver>;
     constructor();
 }
 //# sourceMappingURL=rule-engine-host.d.ts.map

package/dist/host/rule-engine-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-engine-host.d.ts","sourceRoot":"","sources":["../../src/host/rule-engine-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,mDAAmD;AACnD,qBAAa,cAAc;IACvB,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC;IACvD,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC,eAAe,CAAC,CAAC;;CAM5D"}
+{"version":3,"file":"rule-engine-host.d.ts","sourceRoot":"","sources":["../../src/host/rule-engine-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,mDAAmD;AACnD,qBAAa,cAAc;IACvB,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC;IACvD,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC,eAAe,CAAC,CAAC;IACzD,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;;CAO5D"}

package/dist/host/rule-engine-host.js

@@ -5,8 +5,11 @@ export class RuleEngineHost {
     evaluators;
     /** Formatter registry keyed by formatter name. */
     formatters;
+    /** Test-path resolver registry keyed by language name. */
+    resolvers;
     constructor() {
         this.evaluators = new CapabilityRegistry('evaluator');
         this.formatters = new CapabilityRegistry('formatter');
+        this.resolvers = new CapabilityRegistry('resolver');
     }
 }

package/dist/index.d.ts

@@ -1,8 +1,12 @@
+export * from './config/extensions';
 export * from './config/loader';
 export * from './engine';
+export * from './fixers/fixers';
+export * from './fixers/test-stub-fixer';
 export * from './formatters/json';
 export * from './formatters/text';
 export * from './host/capability-registry';
 export * from './host/rule-engine-host';
+export * from './resolvers/test-path-resolver';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -1,7 +1,11 @@
+export * from './config/extensions.js';
 export * from './config/loader.js';
 export * from './engine.js';
+export * from './fixers/fixers.js';
+export * from './fixers/test-stub-fixer.js';
 export * from './formatters/json.js';
 export * from './formatters/text.js';
 export * from './host/capability-registry.js';
 export * from './host/rule-engine-host.js';
+export * from './resolvers/test-path-resolver.js';
 export * from './types.js';

package/dist/resolvers/test-path-resolver.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pluggable test-path resolution for the test-location evaluator.
+ *
+ * Each implementation maps a source file path to its conventional test file path
+ * for one language, so the same evaluator works across TypeScript, Python, Go, and
+ * Rust projects. Resolvers are registered on the host and selected per rule via
+ * `evaluator.config.resolver`.
+ */
+/** Metadata about an exported symbol, used when generating a test skeleton. */
+export interface ExportInfo {
+    /** Symbol name. */
+    readonly name: string;
+    /** Declaration kind. */
+    readonly kind: 'function' | 'class' | 'const' | 'type' | 'interface' | 'unknown';
+    /** One-based source line, when known. */
+    readonly line?: number;
+}
+/** Maps source files to expected test files for a project type. */
+export interface TestPathResolver {
+    /** Language name this resolver handles (registry key). */
+    readonly name: string;
+    /** Compute the expected test file path for a source file. */
+    resolveTestPath(srcRelPath: string): string;
+    /** Optionally generate a test skeleton for a source file. */
+    generateSkeleton?(srcRelPath: string, exports: ExportInfo[]): string;
+}
+/**
+ * TypeScript conventions:
+ *   src/foo/bar.ts → tests/foo/bar.test.ts
+ *   packages/core/src/foo/bar.ts → packages/core/tests/foo/bar.test.ts
+ */
+export declare class TypeScriptTestPathResolver implements TestPathResolver {
+    /** Registry key. */
+    readonly name = "typescript";
+    constructor();
+    /** Map a TS/JS source path to its `tests/…test.ts` counterpart. */
+    resolveTestPath(srcRelPath: string): string;
+}
+/**
+ * Python conventions (pytest):
+ *   src/foo/bar.py → tests/foo/test_bar.py
+ */
+export declare class PythonTestPathResolver implements TestPathResolver {
+    /** Registry key. */
+    readonly name = "python";
+    constructor();
+    /** Map a Python source path to its `tests/…/test_*.py` counterpart. */
+    resolveTestPath(srcRelPath: string): string;
+}
+/**
+ * Go conventions:
+ *   foo/bar.go → foo/bar_test.go (sibling)
+ */
+export declare class GoTestPathResolver implements TestPathResolver {
+    /** Registry key. */
+    readonly name = "go";
+    constructor();
+    /** Map a Go source path to its sibling `_test.go` file. */
+    resolveTestPath(srcRelPath: string): string;
+}
+/**
+ * Rust conventions (Cargo integration tests):
+ *   crate/src/foo.rs → crate/tests/foo.rs
+ */
+export declare class RustTestPathResolver implements TestPathResolver {
+    /** Registry key. */
+    readonly name = "rust";
+    constructor();
+    /** Map a Rust source path to its `tests/` integration-test counterpart. */
+    resolveTestPath(srcRelPath: string): string;
+}
+//# sourceMappingURL=test-path-resolver.d.ts.map

package/dist/resolvers/test-path-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-path-resolver.d.ts","sourceRoot":"","sources":["../../src/resolvers/test-path-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,+EAA+E;AAC/E,MAAM,WAAW,UAAU;IACvB,mBAAmB;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wBAAwB;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IACjF,yCAAyC;IACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,mEAAmE;AACnE,MAAM,WAAW,gBAAgB;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5C,6DAA6D;IAC7D,gBAAgB,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;CACxE;AAED;;;;GAIG;AACH,qBAAa,0BAA2B,YAAW,gBAAgB;IAC/D,oBAAoB;IACpB,QAAQ,CAAC,IAAI,gBAAgB;;IAI7B,mEAAmE;IACnE,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;CAW9C;AAED;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,gBAAgB;IAC3D,oBAAoB;IACpB,QAAQ,CAAC,IAAI,YAAY;;IAIzB,uEAAuE;IACvE,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;CAe9C;AAED;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,gBAAgB;IACvD,oBAAoB;IACpB,QAAQ,CAAC,IAAI,QAAQ;;IAIrB,2DAA2D;IAC3D,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;CAM9C;AAED;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IACzD,oBAAoB;IACpB,QAAQ,CAAC,IAAI,UAAU;;IAIvB,2EAA2E;IAC3E,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;CAY9C"}