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

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

package/dist/resolvers/test-path-resolver.js

@@ -0,0 +1,112 @@
+/**
+ * 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`.
+ */
+/**
+ * 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 class TypeScriptTestPathResolver {
+    /** Registry key. */
+    name = 'typescript';
+    constructor() { }
+    /** Map a TS/JS source path to its `tests/…test.ts` counterpart. */
+    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`;
+    }
+}
+/**
+ * Python conventions (pytest):
+ *   src/foo/bar.py → tests/foo/test_bar.py
+ */
+export class PythonTestPathResolver {
+    /** Registry key. */
+    name = 'python';
+    constructor() { }
+    /** Map a Python source path to its `tests/…/test_*.py` counterpart. */
+    resolveTestPath(srcRelPath) {
+        if (!srcRelPath)
+            throw new Error('empty source path');
+        if (srcRelPath.endsWith('_test.py') || srcRelPath.includes('/test_') || srcRelPath.startsWith('test_')) {
+            return srcRelPath;
+        }
+        if (srcRelPath.startsWith('tests/'))
+            return srcRelPath;
+        if (!srcRelPath.endsWith('.py'))
+            throw new Error(`unsupported extension for python resolver: ${srcRelPath}`);
+        const srcIdx = srcRelPath.indexOf('/src/');
+        if (srcIdx !== -1) {
+            const pkg = srcRelPath.slice(0, srcIdx);
+            return `${pkg}/tests/${testify(srcRelPath.slice(srcIdx + '/src/'.length))}`;
+        }
+        if (srcRelPath.startsWith('src/'))
+            return `tests/${testify(srcRelPath.slice(4))}`;
+        return `tests/${testify(srcRelPath)}`;
+    }
+}
+/**
+ * Go conventions:
+ *   foo/bar.go → foo/bar_test.go (sibling)
+ */
+export class GoTestPathResolver {
+    /** Registry key. */
+    name = 'go';
+    constructor() { }
+    /** Map a Go source path to its sibling `_test.go` file. */
+    resolveTestPath(srcRelPath) {
+        if (!srcRelPath)
+            throw new Error('empty source path');
+        if (srcRelPath.endsWith('_test.go'))
+            return srcRelPath;
+        if (!srcRelPath.endsWith('.go'))
+            throw new Error(`unsupported extension for go resolver: ${srcRelPath}`);
+        return srcRelPath.replace(/\.go$/, '_test.go');
+    }
+}
+/**
+ * Rust conventions (Cargo integration tests):
+ *   crate/src/foo.rs → crate/tests/foo.rs
+ */
+export class RustTestPathResolver {
+    /** Registry key. */
+    name = 'rust';
+    constructor() { }
+    /** Map a Rust source path to its `tests/` integration-test counterpart. */
+    resolveTestPath(srcRelPath) {
+        if (!srcRelPath)
+            throw new Error('empty source path');
+        if (srcRelPath.startsWith('tests/') || srcRelPath.includes('/tests/'))
+            return srcRelPath;
+        if (!srcRelPath.endsWith('.rs'))
+            throw new Error(`unsupported extension for rust resolver: ${srcRelPath}`);
+        const srcIdx = srcRelPath.indexOf('/src/');
+        if (srcIdx !== -1) {
+            const crate = srcRelPath.slice(0, srcIdx);
+            return `${crate}/tests/${srcRelPath.slice(srcIdx + '/src/'.length)}`;
+        }
+        if (srcRelPath.startsWith('src/'))
+            return `tests/${srcRelPath.slice(4)}`;
+        return `tests/${srcRelPath}`;
+    }
+}
+/** Prefix the basename of a Python source path with `test_`. */
+function testify(rel) {
+    const lastSlash = rel.lastIndexOf('/');
+    const dir = lastSlash >= 0 ? rel.slice(0, lastSlash + 1) : '';
+    const base = lastSlash >= 0 ? rel.slice(lastSlash + 1) : rel;
+    return `${dir}test_${base}`;
+}

package/dist/types.d.ts

@@ -49,6 +49,17 @@ export interface ConstraintRuleFile {
     /** Rule definitions. */
     rules: ConstraintRule[];
 }
+/** Relative module paths a preset contributes per capability kind. */
+export interface PresetExtensions {
+    /** Test-path resolver module paths. */
+    resolvers?: string[];
+    /** Evaluator module paths. */
+    evaluators?: string[];
+    /** Fixer module paths. */
+    fixers?: string[];
+    /** Formatter module paths. */
+    formatters?: string[];
+}
 /** Preset definition that composes category folders or other presets. */
 export interface PresetDefinition {
     /** Preset name. */
@@ -63,6 +74,8 @@ export interface PresetDefinition {
             mode: FixMode;
         };
     }>;
+    /** Custom capability modules contributed by this preset (opt-in to load). */
+    extensions?: PresetExtensions;
 }
 /** Candidate fix emitted by an evaluator or fixer. */
 export interface Fix {
@@ -79,6 +92,15 @@ export interface Fix {
     /** Whether this fix may be applied automatically. */
     mode: Exclude<FixMode, 'none'>;
 }
+/**
+ * What a finding represents.
+ *
+ * - `violation`: the rule ran and the project breached its policy (the default).
+ * - `error`: the rule could not run — a misconfiguration or runtime fault in the
+ *   evaluator itself. These are not policy breaches and callers may surface them
+ *   separately (e.g. "rule misconfigured") rather than as project violations.
+ */
+export type FindingKind = 'violation' | 'error';
 /** Finding emitted by a constraint rule. */
 export interface ConstraintFinding {
     /** Rule identifier. */
@@ -95,6 +117,8 @@ export interface ConstraintFinding {
     column?: number;
     /** Machine-readable evaluator/source code. */
     code?: string;
+    /** Whether this is a policy violation or an evaluator error. Absent means `violation`. */
+    kind?: FindingKind;
 }
 /** Aggregate result returned by a rule evaluator. */
 export interface RuleEvaluationResult {
@@ -214,5 +238,11 @@ export declare const PresetDefinitionSchema: z.ZodObject<{
             }>;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    extensions: z.ZodOptional<z.ZodObject<{
+        resolvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        evaluators: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fixers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        formatters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -46,4 +46,12 @@ export const PresetDefinitionSchema = z.object({
     overrides: z
         .record(z.string(), z.object({ fix: z.object({ mode: z.enum(['none', 'suggest', 'auto']) }).optional() }))
         .optional(),
+    extensions: z
+        .object({
+        resolvers: z.array(z.string()).optional(),
+        evaluators: z.array(z.string()).optional(),
+        fixers: z.array(z.string()).optional(),
+        formatters: z.array(z.string()).optional(),
+    })
+        .optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/ts-rule-engine",
-    "version": "0.2.6",
+    "version": "0.2.7",
     "description": "@gobing-ai/ts-rule-engine — Constraint rule schemas, loading, evaluation, and result formatting.",
     "keywords": [
         "typescript",
@@ -47,8 +47,8 @@
         "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-rule-engine-v<version> && git push --tags' && exit 1"
     },
     "dependencies": {
-        "@gobing-ai/ts-ai-runner": "^0.2.6",
-        "@gobing-ai/ts-runtime": "^0.2.6",
+        "@gobing-ai/ts-ai-runner": "^0.2.7",
+        "@gobing-ai/ts-runtime": "^0.2.7",
         "yaml": "^2.7.0",
         "zod": "^4.1.0"
     },

package/src/config/extensions.ts

@@ -0,0 +1,108 @@
+import { resolve } from 'node:path';
+import type { RuleEngineHost } from '../host/rule-engine-host';
+
+/** A capability kind a preset extension can contribute. */
+export type ExtensionKind = 'resolvers' | 'evaluators' | 'fixers' | 'formatters';
+
+/** A single extension module reference, resolved to an absolute path. */
+export interface ExtensionRef {
+    /** Capability registry the module registers into. */
+    readonly kind: ExtensionKind;
+    /** Absolute path to the module to import. */
+    readonly absPath: string;
+    /** Name of the preset that declared this extension (for diagnostics). */
+    readonly presetName: string;
+}
+
+/** Options controlling preset-extension loading. */
+export interface LoadExtensionsOptions {
+    /**
+     * Whether to actually import extension modules. Defaults to `false`: loading
+     * arbitrary code referenced by a preset is a trust decision the caller must
+     * make explicitly. When refs exist and this is false, loading throws.
+     */
+    allowExtensions?: boolean;
+    /** Optional sink for non-fatal warnings (e.g. built-in overrides). */
+    logger?: { warn: (message: string) => void };
+}
+
+/** Host registries that can receive extension capabilities (fixers live on the engine, not the host). */
+const HOST_REGISTRY_BY_KIND: Partial<Record<ExtensionKind, 'resolvers' | 'evaluators' | 'formatters'>> = {
+    resolvers: 'resolvers',
+    evaluators: 'evaluators',
+    formatters: 'formatters',
+};
+
+/**
+ * Collect extension refs declared by a preset's `extensions` block.
+ *
+ * Paths are resolved relative to the preset file's directory. Use the returned
+ * refs with {@link loadExtensionsIntoHost}.
+ */
+export function collectPresetExtensions(
+    presetName: string,
+    presetDir: string,
+    extensions: Partial<Record<ExtensionKind, string[] | undefined>> | undefined,
+): ExtensionRef[] {
+    if (extensions === undefined) return [];
+    const refs: ExtensionRef[] = [];
+    for (const kind of ['resolvers', 'evaluators', 'fixers', 'formatters'] as ExtensionKind[]) {
+        for (const path of extensions[kind] ?? []) {
+            refs.push({ kind, presetName, absPath: resolve(presetDir, path) });
+        }
+    }
+    return refs;
+}
+
+/**
+ * Import each extension module and register its export on the matching host
+ * registry.
+ *
+ * A module must default-export (or named-export `extension`) an object with a
+ * `name: string` and the capability implementation. Loading is gated by
+ * {@link LoadExtensionsOptions.allowExtensions}; when refs are present but
+ * loading is not allowed, this throws so the requirement is never silently dropped.
+ *
+ * @throws When extensions are present but `allowExtensions` is not true, or when
+ *   a module cannot be imported or lacks a valid `name`.
+ */
+export async function loadExtensionsIntoHost(
+    host: RuleEngineHost,
+    refs: readonly ExtensionRef[],
+    options: LoadExtensionsOptions = {},
+): Promise<void> {
+    if (refs.length === 0) return;
+    if (options.allowExtensions !== true) {
+        const first = refs[0] as ExtensionRef;
+        throw new Error(
+            `preset "${first.presetName}" declares ${first.kind} extension "${first.absPath}", but extensions are disabled — pass allowExtensions: true to load preset extension modules`,
+        );
+    }
+
+    for (const ref of refs) {
+        const moduleExports = (await import(ref.absPath)) as Record<string, unknown>;
+        const candidate = moduleExports.default ?? moduleExports.extension;
+        if (
+            candidate === null ||
+            typeof candidate !== 'object' ||
+            typeof (candidate as { name?: unknown }).name !== 'string'
+        ) {
+            throw new Error(
+                `preset "${ref.presetName}" extension "${ref.absPath}" must export an object with a string "name"`,
+            );
+        }
+        const name = (candidate as { name: string }).name;
+        const registryKey = HOST_REGISTRY_BY_KIND[ref.kind];
+        if (registryKey === undefined) {
+            throw new Error(`preset "${ref.presetName}" ${ref.kind} extensions are not supported`);
+        }
+        const registry = host[registryKey] as unknown as {
+            register: (name: string, impl: unknown, origin: 'builtin' | 'extension') => void;
+            has?: (name: string) => boolean;
+        };
+        if (options.logger && registry.has?.(name)) {
+            options.logger.warn(`preset "${ref.presetName}" ${ref.kind} extension overrides existing "${name}"`);
+        }
+        registry.register(name, candidate, 'extension');
+    }
+}

package/src/config/loader.ts

@@ -63,9 +63,12 @@ export async function loadRuleFile(filePath: string): Promise<ConstraintRule[]>
 }
 
 async function loadPresetEntry(merged: MergedRoots, entry: string, seen: Set<string>): Promise<ConstraintRule[]> {
-    // Sub-preset reference — recurse (cycle-guarded).
+    // Sub-preset reference — recurse, erroring on a genuine cycle.
     const presetPath = findMergedPreset(merged, entry);
-    if (presetPath !== null && !seen.has(entry)) {
+    if (presetPath !== null) {
+        if (seen.has(entry)) {
+            throw new Error(`Circular preset dependency detected: ${[...seen, entry].join(' → ')}`);
+        }
         seen.add(entry);
         const preset = PresetDefinitionSchema.safeParse(await readStructuredFile(presetPath));
         if (preset.success) {
@@ -200,7 +203,8 @@ function normalizeFileRules(file: ConstraintRuleFile, sourceDir: string): Constr
                 ...rule,
                 severity: rule.severity ?? file.severity ?? 'error',
                 include: rule.include ?? file.include,
-                exclude: rule.exclude ?? file.exclude,
+                // File-level excludes always apply; a rule's own excludes add to (not replace) them.
+                exclude: mergeExcludes(file.exclude, rule.exclude),
             },
             {},
             sourceDir,
@@ -208,6 +212,12 @@ function normalizeFileRules(file: ConstraintRuleFile, sourceDir: string): Constr
     );
 }
 
+/** Union of file-level and rule-level excludes, de-duplicated. Returns undefined when both empty. */
+function mergeExcludes(fileExclude?: string[], ruleExclude?: string[]): string[] | undefined {
+    if (fileExclude === undefined && ruleExclude === undefined) return undefined;
+    return [...new Set([...(fileExclude ?? []), ...(ruleExclude ?? [])])];
+}
+
 function normalizeRule(rule: ConstraintRule, _defaults: Partial<ConstraintRule>, _sourceDir: string): ConstraintRule {
     return {
         ...rule,

package/src/engine.ts

@@ -1,7 +1,15 @@
 import type { ProcessExecutor } from '@gobing-ai/ts-runtime';
+import {
+    applyFixes as applyFixesImpl,
+    builtInFixers,
+    type EffectiveFix,
+    FIX_MODE_RANK,
+    type FixApplicationResult,
+    type RuleFixerProvider,
+} from './fixers/fixers';
 import { registerBuiltins } from './host/builtins';
 import { RuleEngineHost } from './host/rule-engine-host';
-import type { ConstraintFinding, ConstraintRule, RuleEngineResult, RuleEvaluator } from './types';
+import type { ConstraintFinding, ConstraintRule, Fix, FixMode, RuleEngineResult, RuleEvaluator } from './types';
 import { createFinding } from './types';
 
 /** Options for constructing a RuleEngine. */
@@ -17,9 +25,13 @@ export class RuleEngine {
     /** Capability host used by this engine. */
     readonly host: RuleEngineHost;
 
+    /** Fixer providers keyed by evaluator type. */
+    private readonly fixers: Map<string, RuleFixerProvider>;
+
     constructor(options: RuleEngineOptions = {}) {
         this.host = options.host ?? new RuleEngineHost();
         registerBuiltins(this.host, options.processExecutor);
+        this.fixers = builtInFixers(this.host, options.processExecutor);
     }
 
     /** Register or replace an evaluator. */
@@ -30,7 +42,7 @@ export class RuleEngine {
     /** Evaluate all enabled rules against a working directory. */
     async evaluate(rules: ConstraintRule[], workdir: string): Promise<RuleEngineResult> {
         const findings: ConstraintFinding[] = [];
-        const fixes = [];
+        const fixes: Fix[] = [];
         for (const rule of rules) {
             if (rule.enabled === false) continue;
             try {
@@ -41,10 +53,95 @@ export class RuleEngine {
                 findings.push(
                     createFinding(rule, error instanceof Error ? error.message : String(error), null, {
                         code: `evaluator:${rule.evaluator.type}`,
+                        kind: 'error',
                     }),
                 );
             }
         }
         return { findings, fixes };
     }
+
+    /**
+     * Evaluate all enabled rules and collect candidate fixes.
+     *
+     * For each rule with findings and a non-none fix mode, looks up the fixer
+     * provider by evaluator type and calls `createFixes`. The effective fix mode
+     * is the minimum of the rule's configured mode and `maxFixMode`.
+     *
+     * @param rules - Normalized rule definitions to evaluate.
+     * @param workdir - Working directory to scan.
+     * @param maxFixMode - Highest fix authority requested by the caller.
+     * @returns Findings plus fixes allowed by the requested authority.
+     */
+    async evaluateWithFixes(
+        rules: ConstraintRule[],
+        workdir: string,
+        maxFixMode: FixMode = 'auto',
+    ): Promise<RuleEngineResult> {
+        const findings: ConstraintFinding[] = [];
+        const fixes: Fix[] = [];
+
+        for (const rule of rules) {
+            if (rule.enabled === false) continue;
+
+            let ruleFindings: ConstraintFinding[] = [];
+            let ruleEvalFixes: Fix[] = [];
+            try {
+                const result = await this.host.evaluators.get(rule.evaluator.type).evaluate(rule, { rule, workdir });
+                ruleFindings = result.findings;
+                ruleEvalFixes = result.fixes;
+            } catch (error) {
+                ruleFindings = [
+                    createFinding(rule, error instanceof Error ? error.message : String(error), null, {
+                        code: `evaluator:${rule.evaluator.type}`,
+                        kind: 'error',
+                    }),
+                ];
+            }
+
+            findings.push(...ruleFindings);
+            fixes.push(...ruleEvalFixes);
+
+            const ruleMode = rule.fix?.mode ?? 'none';
+            const effectiveMode = effectiveFixMode(ruleMode, maxFixMode);
+
+            if (effectiveMode !== 'none' && ruleFindings.length > 0) {
+                const provider = this.fixers.get(rule.evaluator.type);
+                if (provider) {
+                    const effectiveFix: EffectiveFix = {
+                        mode: effectiveMode,
+                        ...(rule.fix?.replacement !== undefined ? { replacement: rule.fix.replacement } : {}),
+                        ...(rule.fix?.params !== undefined ? { params: rule.fix.params } : {}),
+                    };
+                    const providerFixes = await provider.createFixes({
+                        rule,
+                        context: { rule, workdir },
+                        findings: ruleFindings,
+                        fix: effectiveFix,
+                    });
+                    fixes.push(...providerFixes);
+                }
+            }
+        }
+
+        return { findings, fixes };
+    }
+
+    /**
+     * Apply or preview candidate byte-range fixes.
+     *
+     * @param workdir - Working directory that fix file paths are relative to.
+     * @param fixes - Fixes to apply.
+     * @param dryRun - When true, return a diff without writing files.
+     * @returns Application details and optional diff.
+     */
+    async applyFixes(workdir: string, fixes: readonly Fix[], dryRun = false): Promise<FixApplicationResult> {
+        return applyFixesImpl(workdir, fixes, dryRun);
+    }
+}
+
+/** Return the lower-authority mode between what the rule requests and what the caller allows. */
+function effectiveFixMode(ruleMode: FixMode, requestedMode: FixMode): FixMode {
+    if (requestedMode === 'none' || ruleMode === 'none') return 'none';
+    return FIX_MODE_RANK[ruleMode] <= FIX_MODE_RANK[requestedMode] ? ruleMode : requestedMode;
 }