@gobing-ai/ts-rule-engine 0.2.1

package/README.md

@@ -0,0 +1,3 @@
+# @gobing-ai/ts-rule-engine
+
+Constraint rule schemas, preset loading, evaluator orchestration, and result formatting for TypeScript/Bun projects.

package/dist/config/loader.d.ts

@@ -0,0 +1,13 @@
+import { type ConstraintRule } from '../types';
+/** Options for loading rule presets. */
+export interface RuleLoaderOptions {
+    /** Project working directory. */
+    workdir: string;
+    /** Rule root directory. Defaults to ".spur/rules". */
+    rulesRoot?: string;
+}
+/** Load and normalize a preset by name. */
+export declare function loadPresetRules(name: string, options: RuleLoaderOptions): Promise<ConstraintRule[]>;
+/** Load a direct rule file from disk. */
+export declare function loadRuleFile(filePath: string): Promise<ConstraintRule[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,KAAK,cAAc,EAMtB,MAAM,UAAU,CAAC;AAElB,wCAAwC;AACxC,MAAM,WAAW,iBAAiB;IAC9B,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,2CAA2C;AAC3C,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAoBzG;AAED,yCAAyC;AACzC,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAE9E"}

package/dist/config/loader.js

@@ -0,0 +1,98 @@
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { NodeFileSystem } from '@gobing-ai/ts-runtime';
+import { parse } from 'yaml';
+import { ConstraintRuleFileSchema, ConstraintRuleSchema, PresetDefinitionSchema, } from '../types.js';
+/** Load and normalize a preset by name. */
+export async function loadPresetRules(name, options) {
+    const fs = new NodeFileSystem();
+    const root = resolve(options.workdir, options.rulesRoot ?? '.spur/rules');
+    const presetPath = await findDefinitionPath(root, name);
+    if (presetPath === null)
+        return [];
+    const preset = PresetDefinitionSchema.parse(await readStructuredFile(presetPath));
+    const rules = [];
+    for (const entry of preset.extends) {
+        rules.push(...(await loadPresetEntry(root, entry, new Set([name]))));
+    }
+    const disabled = new Set(preset.disable ?? []);
+    const normalized = rules.filter((rule) => !disabled.has(rule.id));
+    for (const rule of normalized) {
+        const override = preset.overrides?.[rule.id];
+        if (override?.fix !== undefined) {
+            rule.fix = { ...(rule.fix ?? { mode: 'none' }), ...override.fix };
+        }
+    }
+    await fs.exists(root);
+    return normalized;
+}
+/** Load a direct rule file from disk. */
+export async function loadRuleFile(filePath) {
+    return normalizeRuleFile(await readStructuredFile(resolve(filePath)), dirname(resolve(filePath)));
+}
+async function loadPresetEntry(root, entry, seen) {
+    const presetPath = await findDefinitionPath(root, entry);
+    if (presetPath !== null && !seen.has(entry)) {
+        seen.add(entry);
+        const preset = PresetDefinitionSchema.safeParse(await readStructuredFile(presetPath));
+        if (preset.success) {
+            const rules = [];
+            for (const child of preset.data.extends)
+                rules.push(...(await loadPresetEntry(root, child, seen)));
+            return rules.filter((rule) => !(preset.data.disable ?? []).includes(rule.id));
+        }
+    }
+    const categoryDir = resolve(root, entry);
+    const fs = new NodeFileSystem();
+    if (!(await fs.exists(categoryDir)))
+        return [];
+    const entries = (await fs.readDir(categoryDir)).filter((file) => /\.(ya?ml|json)$/i.test(file)).sort();
+    const rules = [];
+    for (const file of entries) {
+        rules.push(...(await loadRuleFile(join(categoryDir, file))));
+    }
+    return rules;
+}
+async function findDefinitionPath(root, name) {
+    const fs = new NodeFileSystem();
+    const candidates = [
+        resolve(root, `${name}.yaml`),
+        resolve(root, `${name}.yml`),
+        resolve(root, `${name}.json`),
+        resolve(root, name, 'index.yaml'),
+        resolve(root, name, 'index.yml'),
+        resolve(root, name, 'index.json'),
+    ];
+    for (const candidate of candidates) {
+        if (await fs.exists(candidate))
+            return candidate;
+    }
+    return null;
+}
+async function readStructuredFile(path) {
+    const content = await new NodeFileSystem().readFile(path);
+    return extname(path) === '.json' ? JSON.parse(content) : parse(content);
+}
+function normalizeRuleFile(raw, sourceDir) {
+    const maybeFile = ConstraintRuleFileSchema.safeParse(raw);
+    if (maybeFile.success)
+        return normalizeFileRules(maybeFile.data, sourceDir);
+    const maybeRule = ConstraintRuleSchema.safeParse(raw);
+    if (maybeRule.success)
+        return [normalizeRule(maybeRule.data, {}, sourceDir)];
+    throw new Error(`Invalid rule file: ${basename(sourceDir)}`);
+}
+function normalizeFileRules(file, sourceDir) {
+    return file.rules.map((rule) => normalizeRule({
+        ...rule,
+        severity: rule.severity ?? file.severity ?? 'error',
+        include: rule.include ?? file.include,
+        exclude: rule.exclude ?? file.exclude,
+    }, {}, sourceDir));
+}
+function normalizeRule(rule, _defaults, _sourceDir) {
+    return {
+        ...rule,
+        enabled: rule.enabled ?? true,
+        severity: rule.severity ?? 'error',
+    };
+}

package/dist/engine.d.ts

@@ -0,0 +1,21 @@
+import type { ProcessExecutor } from '@gobing-ai/ts-runtime';
+import { RuleEngineHost } from './host/rule-engine-host';
+import type { ConstraintRule, RuleEngineResult, RuleEvaluator } from './types';
+/** Options for constructing a RuleEngine. */
+export interface RuleEngineOptions {
+    /** Optional executor supplied to process-backed evaluators. */
+    processExecutor?: ProcessExecutor;
+    /** Optional preconfigured host. */
+    host?: RuleEngineHost;
+}
+/** Orchestrates enabled constraint rules through a typed evaluator host. */
+export declare class RuleEngine {
+    /** Capability host used by this engine. */
+    readonly host: RuleEngineHost;
+    constructor(options?: RuleEngineOptions);
+    /** Register or replace an evaluator. */
+    registerEvaluator(type: string, evaluator: RuleEvaluator): void;
+    /** Evaluate all enabled rules against a working directory. */
+    evaluate(rules: ConstraintRule[], workdir: string): Promise<RuleEngineResult>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAqB,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGlG,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAC9B,+DAA+D;IAC/D,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,mCAAmC;IACnC,IAAI,CAAC,EAAE,cAAc,CAAC;CACzB;AAED,4EAA4E;AAC5E,qBAAa,UAAU;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;gBAElB,OAAO,GAAE,iBAAsB;IAK3C,wCAAwC;IACxC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI;IAI/D,8DAA8D;IACxD,QAAQ,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAmBtF"}

package/dist/engine.js

@@ -0,0 +1,36 @@
+import { registerBuiltins } from './host/builtins.js';
+import { RuleEngineHost } from './host/rule-engine-host.js';
+import { createFinding } from './types.js';
+/** Orchestrates enabled constraint rules through a typed evaluator host. */
+export class RuleEngine {
+    /** Capability host used by this engine. */
+    host;
+    constructor(options = {}) {
+        this.host = options.host ?? new RuleEngineHost();
+        registerBuiltins(this.host, options.processExecutor);
+    }
+    /** Register or replace an evaluator. */
+    registerEvaluator(type, evaluator) {
+        this.host.evaluators.register(type, evaluator, 'extension');
+    }
+    /** Evaluate all enabled rules against a working directory. */
+    async evaluate(rules, workdir) {
+        const findings = [];
+        const fixes = [];
+        for (const rule of rules) {
+            if (rule.enabled === false)
+                continue;
+            try {
+                const result = await this.host.evaluators.get(rule.evaluator.type).evaluate(rule, { rule, workdir });
+                findings.push(...result.findings);
+                fixes.push(...result.fixes);
+            }
+            catch (error) {
+                findings.push(createFinding(rule, error instanceof Error ? error.message : String(error), null, {
+                    code: `evaluator:${rule.evaluator.type}`,
+                }));
+            }
+        }
+        return { findings, fixes };
+    }
+}

package/dist/evaluators/agent-detection-evaluator.d.ts

@@ -0,0 +1,10 @@
+import { AgentDetector } from '@gobing-ai/ts-ai-runner';
+import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type RuleEvaluator } from '../types';
+/** Evaluates local availability of configured coding agents. */
+export declare class AgentDetectionEvaluator implements RuleEvaluator {
+    private readonly detector;
+    constructor(detector?: AgentDetector);
+    /** Probe required agents and emit findings for missing CLIs. */
+    evaluate(rule: ConstraintRule, _context: RuleContext): Promise<RuleEvaluationResult>;
+}
+//# sourceMappingURL=agent-detection-evaluator.d.ts.map

package/dist/evaluators/agent-detection-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-detection-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/agent-detection-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA+B,MAAM,yBAAyB,CAAC;AACrF,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAElB,gEAAgE;AAChE,qBAAa,uBAAwB,YAAW,aAAa;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,gBAAsB;IAE3D,gEAAgE;IAC1D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAe7F"}

package/dist/evaluators/agent-detection-evaluator.js

@@ -0,0 +1,33 @@
+import { AgentDetector, isAgentName } from '@gobing-ai/ts-ai-runner';
+import { createFinding, } from '../types.js';
+/** Evaluates local availability of configured coding agents. */
+export class AgentDetectionEvaluator {
+    detector;
+    constructor(detector = new AgentDetector()) {
+        this.detector = detector;
+    }
+    /** Probe required agents and emit findings for missing CLIs. */
+    async evaluate(rule, _context) {
+        const agents = arrayConfig(rule.evaluator.config ?? {}, 'agents');
+        const findings = [];
+        for (const agent of agents) {
+            if (!isAgentName(agent)) {
+                findings.push(createFinding(rule, `Unknown agent: ${agent}`, null, { code: 'agent:unknown' }));
+                continue;
+            }
+            const detected = await this.detector.detectOne(agent);
+            if (!detected.installed) {
+                findings.push(createFinding(rule, `Agent unavailable: ${agent}`, null, { code: 'agent:missing' }));
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}
+function arrayConfig(config, key) {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    if (typeof value === 'string')
+        return [value];
+    throw new Error(`agent-detection evaluator requires string[] config "${key}"`);
+}

package/dist/evaluators/exit-code-evaluator.d.ts

@@ -0,0 +1,10 @@
+import { type ProcessExecutor } from '@gobing-ai/ts-runtime';
+import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type RuleEvaluator } from '../types';
+/** Evaluates a rule by running a subprocess and checking its exit code. */
+export declare class ExitCodeEvaluator implements RuleEvaluator {
+    private readonly executor;
+    constructor(executor?: ProcessExecutor);
+    /** Run configured command and emit a finding on non-zero exit. */
+    evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
+}
+//# sourceMappingURL=exit-code-evaluator.d.ts.map

package/dist/evaluators/exit-code-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-code-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/exit-code-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAElB,2EAA2E;AAC3E,qBAAa,iBAAkB,YAAW,aAAa;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,GAAE,eAA2C;IAElF,kEAAkE;IAC5D,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAe5F"}

package/dist/evaluators/exit-code-evaluator.js

@@ -0,0 +1,38 @@
+import { NodeProcessExecutor } from '@gobing-ai/ts-runtime';
+import { createFinding, } from '../types.js';
+/** Evaluates a rule by running a subprocess and checking its exit code. */
+export class ExitCodeEvaluator {
+    executor;
+    constructor(executor = new NodeProcessExecutor()) {
+        this.executor = executor;
+    }
+    /** Run configured command and emit a finding on non-zero exit. */
+    async evaluate(rule, context) {
+        const config = rule.evaluator.config ?? {};
+        const command = stringConfig(config, 'command');
+        const args = arrayConfig(config, 'args', []);
+        const result = await this.executor.run({ command, args, cwd: context.workdir, rejectOnError: false });
+        if (result.exitCode === 0)
+            return { findings: [], fixes: [] };
+        return {
+            findings: [
+                createFinding(rule, `Command failed: ${command} ${args.join(' ')}`.trim(), null, {
+                    code: 'exit-code:failed',
+                }),
+            ],
+            fixes: [],
+        };
+    }
+}
+function stringConfig(config, key) {
+    const value = config[key];
+    if (typeof value === 'string')
+        return value;
+    throw new Error(`exit-code evaluator requires string config "${key}"`);
+}
+function arrayConfig(config, key, fallback) {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    return fallback;
+}

package/dist/evaluators/file-utils.d.ts

@@ -0,0 +1,23 @@
+import { type FileSystem, NodeFileSystem } from '@gobing-ai/ts-runtime';
+/** Options for source-file discovery. */
+export interface SourceDiscoveryOptions {
+    /** Working directory. */
+    workdir: string;
+    /** Include path fragments or suffixes. */
+    include?: string[];
+    /** Exclude path fragments. */
+    exclude?: string[];
+    /** Filesystem adapter. */
+    fs?: FileSystem;
+}
+/** Resolve source files for evaluators using conservative path-fragment matching. */
+export declare function discoverFiles(options: SourceDiscoveryOptions): Promise<string[]>;
+/** Read a file from a workdir-relative path. */
+export declare function readWorkdirFile(workdir: string, filePath: string, fs?: NodeFileSystem): Promise<string>;
+/** Ensure a path is workdir-relative for findings. */
+export declare function relativeToWorkdir(workdir: string, path: string): string;
+/** Return parent directory for a workdir-relative path. */
+export declare function relativeParent(path: string): string;
+/** Return true when a path matches any supplied fragment or suffix. */
+export declare function matchesAny(path: string, patterns: string[] | undefined): boolean;
+//# sourceMappingURL=file-utils.d.ts.map

package/dist/evaluators/file-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../src/evaluators/file-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,cAAc,EAAW,MAAM,uBAAuB,CAAC;AAEjF,yCAAyC;AACzC,MAAM,WAAW,sBAAsB;IACnC,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,0BAA0B;IAC1B,EAAE,CAAC,EAAE,UAAU,CAAC;CACnB;AAID,qFAAqF;AACrF,wBAAsB,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWtF;AAED,gDAAgD;AAChD,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,iBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnH;AAED,sDAAsD;AACtD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED,uEAAuE;AACvE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,OAAO,CAMhF"}

package/dist/evaluators/file-utils.js

@@ -0,0 +1,35 @@
+import { dirname, relative, resolve } from 'node:path';
+import { NodeFileSystem, walkDir } from '@gobing-ai/ts-runtime';
+const DEFAULT_EXCLUDES = new Set(['.git', 'node_modules', 'dist', '.coverage', '.astro', '.wrangler']);
+/** Resolve source files for evaluators using conservative path-fragment matching. */
+export async function discoverFiles(options) {
+    const fs = options.fs ?? new NodeFileSystem();
+    const allFiles = await walkDir(options.workdir, fs);
+    return allFiles
+        .map((path) => relative(options.workdir, path))
+        .filter((path) => !path.split('/').some((segment) => DEFAULT_EXCLUDES.has(segment)))
+        .filter((path) => matchesAny(path, options.include) &&
+        (options.exclude === undefined || !matchesAny(path, options.exclude)));
+}
+/** Read a file from a workdir-relative path. */
+export async function readWorkdirFile(workdir, filePath, fs = new NodeFileSystem()) {
+    return await fs.readFile(resolve(workdir, filePath));
+}
+/** Ensure a path is workdir-relative for findings. */
+export function relativeToWorkdir(workdir, path) {
+    return relative(workdir, resolve(path));
+}
+/** Return parent directory for a workdir-relative path. */
+export function relativeParent(path) {
+    const parent = dirname(path);
+    return parent === '.' ? '' : parent;
+}
+/** Return true when a path matches any supplied fragment or suffix. */
+export function matchesAny(path, patterns) {
+    if (patterns === undefined || patterns.length === 0)
+        return true;
+    return patterns.some((pattern) => {
+        const clean = pattern.replaceAll('\\', '/').replaceAll('**/', '').replaceAll('*', '');
+        return clean.length === 0 || path.includes(clean) || path.endsWith(clean);
+    });
+}

package/dist/evaluators/forbidden-import-evaluator.d.ts

@@ -0,0 +1,8 @@
+import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type RuleEvaluator } from '../types';
+/** Detects imports matching forbidden package or path prefixes. */
+export declare class ForbiddenImportEvaluator implements RuleEvaluator {
+    constructor();
+    /** Evaluate import declarations against configured forbidden prefixes. */
+    evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
+}
+//# sourceMappingURL=forbidden-import-evaluator.d.ts.map

package/dist/evaluators/forbidden-import-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden-import-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/forbidden-import-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB,mEAAmE;AACnE,qBAAa,wBAAyB,YAAW,aAAa;;IAG1D,0EAA0E;IACpE,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA4B5F"}

package/dist/evaluators/forbidden-import-evaluator.js

@@ -0,0 +1,42 @@
+import { createFinding, } from '../types.js';
+import { discoverFiles, readWorkdirFile } from './file-utils.js';
+/** Detects imports matching forbidden package or path prefixes. */
+export class ForbiddenImportEvaluator {
+    constructor() { }
+    /** Evaluate import declarations against configured forbidden prefixes. */
+    async evaluate(rule, context) {
+        const config = rule.evaluator.config ?? {};
+        const forbidden = arrayConfig(config, 'patterns');
+        const files = await discoverFiles({
+            workdir: context.workdir,
+            include: rule.include ?? ['.ts', '.tsx', '.js', '.jsx'],
+            exclude: rule.exclude,
+        });
+        const findings = [];
+        for (const file of files) {
+            const lines = (await readWorkdirFile(context.workdir, file)).split('\n');
+            for (const [index, line] of lines.entries()) {
+                const imported = /(?:from\s+|import\s*\(|^\s*import\s*)['"](?<specifier>[^'"]+)['"]/.exec(line)?.groups
+                    ?.specifier;
+                if (imported === undefined)
+                    continue;
+                const matched = forbidden.find((pattern) => imported.includes(pattern));
+                if (matched !== undefined) {
+                    findings.push(createFinding(rule, `Forbidden import "${imported}" matched "${matched}"`, file, {
+                        line: index + 1,
+                        code: 'import:forbidden',
+                    }));
+                }
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}
+function arrayConfig(config, key) {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    if (typeof value === 'string')
+        return [value];
+    throw new Error(`forbidden-import evaluator requires string[] config "${key}"`);
+}

package/dist/evaluators/path-evaluator.d.ts

@@ -0,0 +1,9 @@
+import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type RuleEvaluator } from '../types';
+/** Evaluates file or directory existence constraints. */
+export declare class PathEvaluator implements RuleEvaluator {
+    private readonly fs;
+    constructor();
+    /** Evaluate required or forbidden paths. */
+    evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
+}
+//# sourceMappingURL=path-evaluator.d.ts.map

package/dist/evaluators/path-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/path-evaluator.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAElB,yDAAyD;AACzD,qBAAa,aAAc,YAAW,aAAa;IAC/C,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAiB;;IAMpC,4CAA4C;IACtC,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAgB5F"}

package/dist/evaluators/path-evaluator.js

@@ -0,0 +1,39 @@
+import { resolve } from 'node:path';
+import { NodeFileSystem } from '@gobing-ai/ts-runtime';
+import { createFinding, } from '../types.js';
+/** Evaluates file or directory existence constraints. */
+export class PathEvaluator {
+    fs;
+    constructor() {
+        this.fs = new NodeFileSystem();
+    }
+    /** Evaluate required or forbidden paths. */
+    async evaluate(rule, context) {
+        const config = rule.evaluator.config ?? {};
+        const paths = arrayConfig(config, 'paths');
+        const mode = stringConfig(config, 'mode', 'require');
+        const findings = [];
+        for (const path of paths) {
+            const exists = await this.fs.exists(resolve(context.workdir, path));
+            if (mode === 'forbid' && exists) {
+                findings.push(createFinding(rule, `Forbidden path exists: ${path}`, path, { code: 'path:forbidden' }));
+            }
+            if (mode !== 'forbid' && !exists) {
+                findings.push(createFinding(rule, `Required path missing: ${path}`, path, { code: 'path:missing' }));
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}
+function arrayConfig(config, key) {
+    const value = config[key];
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    if (typeof value === 'string')
+        return [value];
+    throw new Error(`path evaluator requires string[] config "${key}"`);
+}
+function stringConfig(config, key, fallback) {
+    const value = config[key];
+    return typeof value === 'string' ? value : fallback;
+}

package/dist/evaluators/regex-evaluator.d.ts

@@ -0,0 +1,8 @@
+import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type RuleEvaluator } from '../types';
+/** Evaluates whether source files match or avoid a regex pattern. */
+export declare class RegexEvaluator implements RuleEvaluator {
+    constructor();
+    /** Evaluate regex-based presence or absence constraints. */
+    evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
+}
+//# sourceMappingURL=regex-evaluator.d.ts.map

package/dist/evaluators/regex-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/regex-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB,qEAAqE;AACrE,qBAAa,cAAe,YAAW,aAAa;;IAGhD,4DAA4D;IACtD,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CA2B5F"}

package/dist/evaluators/regex-evaluator.js

@@ -0,0 +1,36 @@
+import { createFinding, } from '../types.js';
+import { discoverFiles, readWorkdirFile } from './file-utils.js';
+/** Evaluates whether source files match or avoid a regex pattern. */
+export class RegexEvaluator {
+    constructor() { }
+    /** Evaluate regex-based presence or absence constraints. */
+    async evaluate(rule, context) {
+        const config = rule.evaluator.config ?? {};
+        const pattern = stringConfig(config, 'pattern');
+        const mode = stringConfig(config, 'mode', 'forbid');
+        const flags = stringConfig(config, 'flags', 'm');
+        const regex = new RegExp(pattern, flags);
+        const files = await discoverFiles({ workdir: context.workdir, include: rule.include, exclude: rule.exclude });
+        const findings = [];
+        for (const file of files) {
+            const content = await readWorkdirFile(context.workdir, file);
+            regex.lastIndex = 0;
+            const match = regex.exec(content);
+            if (mode === 'require' && match === null) {
+                findings.push(createFinding(rule, `Required pattern not found: ${pattern}`, file, { code: 'regex:missing' }));
+            }
+            if (mode !== 'require' && match !== null) {
+                findings.push(createFinding(rule, `Forbidden pattern found: ${pattern}`, file, { code: 'regex:found' }));
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}
+function stringConfig(config, key, fallback) {
+    const value = config[key];
+    if (typeof value === 'string')
+        return value;
+    if (fallback !== undefined)
+        return fallback;
+    throw new Error(`regex evaluator requires string config "${key}"`);
+}

package/dist/evaluators/secrets-scanner-evaluator.d.ts

@@ -0,0 +1,8 @@
+import { type ConstraintRule, type RuleContext, type RuleEvaluationResult, type RuleEvaluator } from '../types';
+/** Scans text files for high-confidence secret-like tokens. */
+export declare class SecretsScannerEvaluator implements RuleEvaluator {
+    constructor();
+    /** Evaluate source files against bundled secret patterns. */
+    evaluate(rule: ConstraintRule, context: RuleContext): Promise<RuleEvaluationResult>;
+}
+//# sourceMappingURL=secrets-scanner-evaluator.d.ts.map

package/dist/evaluators/secrets-scanner-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets-scanner-evaluator.d.ts","sourceRoot":"","sources":["../../src/evaluators/secrets-scanner-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,cAAc,EAEnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EACrB,MAAM,UAAU,CAAC;AAGlB,+DAA+D;AAC/D,qBAAa,uBAAwB,YAAW,aAAa;;IAGzD,6DAA6D;IACvD,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAmB5F"}

package/dist/evaluators/secrets-scanner-evaluator.js

@@ -0,0 +1,24 @@
+import { createFinding, } from '../types.js';
+import { discoverFiles, readWorkdirFile } from './file-utils.js';
+/** Scans text files for high-confidence secret-like tokens. */
+export class SecretsScannerEvaluator {
+    constructor() { }
+    /** Evaluate source files against bundled secret patterns. */
+    async evaluate(rule, context) {
+        const files = await discoverFiles({ workdir: context.workdir, include: rule.include, exclude: rule.exclude });
+        const findings = [];
+        const secretPattern = /(sk-[A-Za-z0-9_-]{20,}|AKIA[0-9A-Z]{16}|BEGIN (?:RSA |OPENSSH )?PRIVATE KEY)/;
+        for (const file of files) {
+            const lines = (await readWorkdirFile(context.workdir, file)).split('\n');
+            for (const [index, line] of lines.entries()) {
+                if (secretPattern.test(line)) {
+                    findings.push(createFinding(rule, 'Potential secret token found', file, {
+                        line: index + 1,
+                        code: 'secret:token',
+                    }));
+                }
+            }
+        }
+        return { findings, fixes: [] };
+    }
+}

package/dist/formatters/json.d.ts

@@ -0,0 +1,8 @@
+import type { ResultFormatter, RuleEngineResult } from '../types';
+/** JSON formatter for rule-engine results. */
+export declare class JsonFormatter implements ResultFormatter {
+    constructor();
+    /** Format the full result as pretty JSON. */
+    format(result: RuleEngineResult): string;
+}
+//# sourceMappingURL=json.d.ts.map

package/dist/formatters/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/formatters/json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAElE,8CAA8C;AAC9C,qBAAa,aAAc,YAAW,eAAe;;IAGjD,6CAA6C;IAC7C,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM;CAG3C"}

package/dist/formatters/json.js

@@ -0,0 +1,8 @@
+/** JSON formatter for rule-engine results. */
+export class JsonFormatter {
+    constructor() { }
+    /** Format the full result as pretty JSON. */
+    format(result) {
+        return JSON.stringify(result, null, 2);
+    }
+}

package/dist/formatters/text.d.ts

@@ -0,0 +1,8 @@
+import type { ResultFormatter, RuleEngineResult } from '../types';
+/** Text formatter for human CLI output. */
+export declare class TextFormatter implements ResultFormatter {
+    constructor();
+    /** Format findings as concise path-prefixed lines. */
+    format(result: RuleEngineResult): string;
+}
+//# sourceMappingURL=text.d.ts.map

package/dist/formatters/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/formatters/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAElE,2CAA2C;AAC3C,qBAAa,aAAc,YAAW,eAAe;;IAGjD,sDAAsD;IACtD,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM;CAY3C"}

package/dist/formatters/text.js

@@ -0,0 +1,17 @@
+/** Text formatter for human CLI output. */
+export class TextFormatter {
+    constructor() { }
+    /** Format findings as concise path-prefixed lines. */
+    format(result) {
+        if (result.findings.length === 0)
+            return 'No rule findings.';
+        return result.findings
+            .map((finding) => {
+            const location = finding.filePath === null
+                ? '<workspace>'
+                : `${finding.filePath}${finding.line ? `:${finding.line}` : ''}`;
+            return `${finding.severity.toUpperCase()} ${finding.ruleId} ${location} ${finding.message}`;
+        })
+            .join('\n');
+    }
+}

package/dist/host/builtins.d.ts

@@ -0,0 +1,5 @@
+import type { ProcessExecutor } from '@gobing-ai/ts-runtime';
+import type { RuleEngineHost } from './rule-engine-host';
+/** Register bundled evaluators and formatters on a host. */
+export declare function registerBuiltins(host: RuleEngineHost, executor?: ProcessExecutor): void;
+//# sourceMappingURL=builtins.d.ts.map

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

@@ -0,0 +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"}