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

package/src/host/builtins.ts

@@ -1,12 +1,24 @@
 import type { ProcessExecutor } from '@gobing-ai/ts-runtime';
 import { AgentDetectionEvaluator } from '../evaluators/agent-detection-evaluator';
+import { CoverageGateEvaluator } from '../evaluators/coverage-gate-evaluator';
 import { ExitCodeEvaluator } from '../evaluators/exit-code-evaluator';
 import { ForbiddenImportEvaluator } from '../evaluators/forbidden-import-evaluator';
+import { ImportBoundaryEvaluator } from '../evaluators/import-boundary-evaluator';
 import { PathEvaluator } from '../evaluators/path-evaluator';
 import { RegexEvaluator } from '../evaluators/regex-evaluator';
+import { SchemaArtifactEvaluator } from '../evaluators/schema-artifact-evaluator';
 import { SecretsScannerEvaluator } from '../evaluators/secrets-scanner-evaluator';
+import { SgEvaluator } from '../evaluators/sg-evaluator';
+import { TestLocationEvaluator } from '../evaluators/test-location-evaluator';
+import { TsdocExportEvaluator } from '../evaluators/tsdoc-export-evaluator';
 import { JsonFormatter } from '../formatters/json';
 import { TextFormatter } from '../formatters/text';
+import {
+    GoTestPathResolver,
+    PythonTestPathResolver,
+    RustTestPathResolver,
+    TypeScriptTestPathResolver,
+} from '../resolvers/test-path-resolver';
 import type { RuleEngineHost } from './rule-engine-host';
 
 /** Register bundled evaluators and formatters on a host. */
@@ -21,6 +33,16 @@ export function registerBuiltins(host: RuleEngineHost, executor?: ProcessExecuto
     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/src/host/rule-engine-host.ts

@@ -1,3 +1,4 @@
+import type { TestPathResolver } from '../resolvers/test-path-resolver';
 import type { ResultFormatter, RuleEvaluator } from '../types';
 import { CapabilityRegistry } from './capability-registry';
 
@@ -7,9 +8,12 @@ export 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() {
         this.evaluators = new CapabilityRegistry<RuleEvaluator>('evaluator');
         this.formatters = new CapabilityRegistry<ResultFormatter>('formatter');
+        this.resolvers = new CapabilityRegistry<TestPathResolver>('resolver');
     }
 }

package/src/index.ts

@@ -1,7 +1,11 @@
+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';

package/src/resolvers/test-path-resolver.ts

@@ -0,0 +1,133 @@
+/**
+ * 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 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 {
+        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 implements TestPathResolver {
+    /** Registry key. */
+    readonly name = 'python';
+
+    constructor() {}
+
+    /** Map a Python source path to its `tests/…/test_*.py` counterpart. */
+    resolveTestPath(srcRelPath: string): string {
+        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 implements TestPathResolver {
+    /** Registry key. */
+    readonly name = 'go';
+
+    constructor() {}
+
+    /** Map a Go source path to its sibling `_test.go` file. */
+    resolveTestPath(srcRelPath: string): string {
+        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 implements TestPathResolver {
+    /** Registry key. */
+    readonly name = 'rust';
+
+    constructor() {}
+
+    /** Map a Rust source path to its `tests/` integration-test counterpart. */
+    resolveTestPath(srcRelPath: string): string {
+        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: string): string {
+    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/src/types.ts

@@ -56,6 +56,18 @@ export interface ConstraintRuleFile {
     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. */
@@ -66,6 +78,8 @@ export interface PresetDefinition {
     disable?: string[];
     /** Per-rule overrides. */
     overrides?: Record<string, { fix?: { mode: FixMode } }>;
+    /** Custom capability modules contributed by this preset (opt-in to load). */
+    extensions?: PresetExtensions;
 }
 
 /** Candidate fix emitted by an evaluator or fixer. */
@@ -84,6 +98,16 @@ export interface Fix {
     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. */
@@ -100,6 +124,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. */
@@ -194,4 +220,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(),
 });