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

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

@@ -46,6 +46,8 @@ export interface RuleFixConfig {
 
 /** Rule file shape before normalization. */
 export interface ConstraintRuleFile {
+    /** Optional JSON Schema ref used by editors and loader validation. */
+    $schema?: string;
     /** File-level default include patterns. */
     include?: string[];
     /** File-level default exclude patterns. */
@@ -56,8 +58,22 @@ 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 {
+    /** Optional JSON Schema ref used by editors and loader validation. */
+    $schema?: string;
     /** Preset name. */
     name: string;
     /** Category folders or preset names to compose. */
@@ -66,6 +82,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 +102,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 +128,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. */
@@ -180,6 +210,7 @@ export const ConstraintRuleSchema = z.object({
 
 /** Zod schema for a constraint rule file. */
 export const ConstraintRuleFileSchema = z.object({
+    $schema: z.string().optional(),
     include: z.array(z.string()).optional(),
     exclude: z.array(z.string()).optional(),
     severity: z.enum(['error', 'warning', 'info']).optional(),
@@ -188,10 +219,19 @@ export const ConstraintRuleFileSchema = z.object({
 
 /** Zod schema for a preset definition. */
 export const PresetDefinitionSchema = z.object({
+    $schema: z.string().optional(),
     name: z.string().min(1),
     extends: z.array(z.string()).default([]),
     disable: z.array(z.string()).optional(),
     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(),
 });