@rigour-labs/core 6.2.5 → 6.3.0

package/dist/semantic/learn/extract.js

@@ -0,0 +1,122 @@
+/**
+ * Finds the edit a fix made and proposes rules that would have caught it.
+ *
+ * Functions are aligned by name path, calls inside them by callee text and
+ * order. Two edit shapes are generalised (Getafix-style templates):
+ *  - require-option: an argument gains a property (`init` -> `{ ...init, redirect: 'manual' }`);
+ *  - require-guard: a property's value gains a condition (`max-age` only when `stepsAvailable`).
+ * Each edit yields candidates from most general (callee name) to most
+ * specific (this call in this function); validation picks the first that holds.
+ */
+import ts from 'typescript';
+import { forEachNode, isFunctionLike } from '../ast.js';
+import { guardsOf, literalPropertyNames, namesIn, propertiesNamed } from './conditions.js';
+import { calleeDeclarationOf, calleeNameOf, calleeTextOf, functionKeyOf, functionName, invocationArgs, isInvocation, } from './identity.js';
+export function extractEdits(file, before, after) {
+    const beforeFns = functionTexts(before.sourceFile);
+    const afterFns = functionTexts(after.sourceFile);
+    const changed = [...new Set([...beforeFns.keys(), ...afterFns.keys()])]
+        .filter(fn => beforeFns.get(fn) !== afterFns.get(fn));
+    const beforeCalls = callsByFunction(before.sourceFile);
+    const afterCalls = callsByFunction(after.sourceFile);
+    const edits = [];
+    const withEdit = new Set();
+    for (const [slot, afterCall] of afterCalls) {
+        const beforeCall = beforeCalls.get(slot);
+        if (!beforeCall || beforeCall.getText() === afterCall.getText())
+            continue;
+        const fn = functionKeyOf(afterCall);
+        const found = [...optionEdits(file, fn, before, beforeCall, afterCall), ...guardEdits(file, fn, before, beforeCall, afterCall)];
+        if (found.length > 0)
+            withEdit.add(fn);
+        edits.push(...found);
+    }
+    // A function whose only change is inside a nested function that yielded an edit is covered by it.
+    const covered = (fn) => [...withEdit].some(key => key === fn || key.startsWith(`${fn}>`));
+    return { edits, unsupported: changed.filter(fn => !covered(fn)) };
+}
+/** Text of each named function, keyed by name path. */
+function functionTexts(sf) {
+    const texts = new Map();
+    forEachNode(sf, (node) => {
+        if (isFunctionLike(node) && functionName(node))
+            texts.set(functionKeyOf(node), node.getText(sf));
+    });
+    return texts;
+}
+/** Calls keyed by `<function>|<callee text>|<ordinal>`, so a call pairs with its counterpart. */
+function callsByFunction(sf) {
+    const calls = new Map();
+    const counts = new Map();
+    forEachNode(sf, (node) => {
+        if (!isInvocation(node))
+            return;
+        const base = `${functionKeyOf(node)}|${calleeTextOf(node)}`;
+        const ordinal = counts.get(base) ?? 0;
+        counts.set(base, ordinal + 1);
+        calls.set(`${base}|${ordinal}`, node);
+    });
+    return calls;
+}
+function optionEdits(file, fn, before, beforeCall, afterCall) {
+    const edits = [];
+    const afterArgs = invocationArgs(afterCall);
+    afterArgs.forEach((arg, argIndex) => {
+        const had = new Set(literalPropertyNames(invocationArgs(beforeCall)[argIndex]).map(n => n.toLowerCase()));
+        for (const property of literalPropertyNames(arg)) {
+            if (had.has(property.toLowerCase()))
+                continue;
+            const value = literalValue(arg, property);
+            const candidates = calleeLevels(before, beforeCall).map(({ callee, scoped }) => ({
+                template: 'require-option', callee, argIndex, property, ...(value ? { value } : {}), ...(scoped ? { scope: { file, fn } } : {}),
+            }));
+            edits.push({ file, fn, description: `${calleeTextOf(afterCall)}(...) gained \`${property}\``, candidates });
+        }
+    });
+    return edits;
+}
+function guardEdits(file, fn, before, beforeCall, afterCall) {
+    const edits = [];
+    const seen = new Map();
+    for (const afterProp of invocationArgs(afterCall).flatMap(arg => allProperties(arg))) {
+        const key = afterProp.name.getText().replace(/^['"`]|['"`]$/g, '');
+        const ordinal = seen.get(key.toLowerCase()) ?? 0;
+        seen.set(key.toLowerCase(), ordinal + 1);
+        const beforeProp = invocationArgs(beforeCall).flatMap(arg => propertiesNamed(arg, key))[ordinal];
+        if (!beforeProp)
+            continue;
+        const had = new Set(namesIn(guardsOf(beforeProp, beforeCall)));
+        const guard = namesIn(guardsOf(afterProp, afterCall)).find(n => !had.has(n));
+        if (!guard)
+            continue;
+        const candidates = calleeLevels(before, beforeCall).map(({ callee, scoped }) => ({
+            template: 'require-guard', callee, property: key, guard, appliesWhenArgsMention: !scoped, ...(scoped ? { scope: { file, fn } } : {}),
+        }));
+        edits.push({ file, fn, description: `\`${key}\` in ${calleeTextOf(afterCall)}(...) gained a condition on \`${guard}\``, candidates });
+    }
+    return edits;
+}
+/** Callee matchers from most to least general, ending with this exact call in this function. */
+function calleeLevels(tree, call) {
+    const levels = [];
+    const name = calleeNameOf(call);
+    if (name)
+        levels.push({ callee: { level: 'name', key: name }, scoped: false });
+    const declaration = calleeDeclarationOf(tree.checker, tree.cwd, call);
+    if (declaration)
+        levels.push({ callee: { level: 'declaration', key: declaration }, scoped: false });
+    const text = calleeTextOf(call);
+    levels.push({ callee: { level: 'text', key: text }, scoped: false });
+    levels.push({ callee: { level: 'text', key: text }, scoped: true });
+    return levels;
+}
+function allProperties(root) {
+    const found = [];
+    forEachNode(root, (node) => { if (ts.isPropertyAssignment(node))
+        found.push(node); });
+    return found;
+}
+function literalValue(arg, property) {
+    const prop = propertiesNamed(arg, property)[0];
+    return prop && ts.isStringLiteralLike(prop.initializer) ? prop.initializer.text : undefined;
+}

package/dist/semantic/learn/git-trees.d.ts

@@ -0,0 +1,8 @@
+export interface FixTrees {
+    commit: string;
+    beforeDir: string;
+    afterDir: string;
+    files: string[];
+    dispose(): void;
+}
+export declare function extractFixTrees(repoDir: string, rev: string): FixTrees;

package/dist/semantic/learn/git-trees.js

@@ -0,0 +1,32 @@
+/**
+ * The trees before and after a fix commit, extracted with `git archive` into
+ * a temporary folder. Read-only against the repository: no checkout, no
+ * worktree, no change to its index or refs.
+ */
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+export function extractFixTrees(repoDir, rev) {
+    const git = (...args) => execFileSync('git', ['-C', repoDir, ...args], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).trim();
+    const commit = git('rev-parse', '--verify', `${rev}^{commit}`);
+    const parent = git('rev-parse', '--verify', `${commit}^`);
+    const files = git('diff', '--name-only', '--diff-filter=M', parent, commit).split('\n').filter(Boolean);
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-learn-'));
+    const unpack = (sha, name) => {
+        const dir = path.join(root, name);
+        const archive = path.join(root, `${name}.tar`);
+        fs.mkdirSync(dir);
+        git('archive', '--format=tar', '-o', archive, sha);
+        execFileSync('tar', ['-xf', archive, '-C', dir]);
+        fs.rmSync(archive);
+        return dir;
+    };
+    return {
+        commit,
+        beforeDir: unpack(parent, 'before'),
+        afterDir: unpack(commit, 'after'),
+        files,
+        dispose: () => fs.rmSync(root, { recursive: true, force: true }),
+    };
+}

package/dist/semantic/learn/identity.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+import type { CalleeMatcher } from './types.js';
+export type Invocation = ts.CallExpression | ts.NewExpression;
+export declare function isInvocation(node: ts.Node): node is Invocation;
+export declare function invocationArgs(call: Invocation): readonly ts.Expression[];
+/** Last name of the callee: `fetch` for `deps.fetch(...)`, `Response` for `new Response(...)`. */
+export declare function calleeNameOf(call: Invocation): string | undefined;
+export declare function calleeTextOf(call: Invocation): string;
+/**
+ * `<file>#<qualified name>` of the declaration the callee resolves to: a
+ * cwd-relative path inside the project, `lib:<file>` for a library.
+ */
+export declare function calleeDeclarationOf(checker: ts.TypeChecker, cwd: string, call: Invocation): string | undefined;
+export declare function calleeKey(checker: ts.TypeChecker, cwd: string, call: Invocation, level: CalleeMatcher['level']): string | undefined;
+/** A function-like node with a name: declared, a method, or assigned to a variable or property. */
+export declare function functionName(fn: ts.Node): string | undefined;
+/** `outer>inner` path of the named functions around `node`, or `<module>` at the top level. */
+export declare function functionKeyOf(node: ts.Node): string;

package/dist/semantic/learn/identity.js

@@ -0,0 +1,97 @@
+/**
+ * Stable identities for calls and functions, shared by learning and scanning.
+ *
+ * The same identity must come out of the code before a fix, the fixed code
+ * and the rest of the repository, so declaration keys are cwd-relative and
+ * function keys are name paths (`Class.method`, `outer>inner`), not positions.
+ */
+import path from 'path';
+import ts from 'typescript';
+import { isFunctionLike, propertyNameText, symbolOf, unwrap } from '../ast.js';
+export function isInvocation(node) {
+    return ts.isCallExpression(node) || ts.isNewExpression(node);
+}
+export function invocationArgs(call) {
+    return call.arguments ?? [];
+}
+/** Last name of the callee: `fetch` for `deps.fetch(...)`, `Response` for `new Response(...)`. */
+export function calleeNameOf(call) {
+    const callee = unwrap(call.expression);
+    if (ts.isIdentifier(callee))
+        return callee.text;
+    if (ts.isPropertyAccessExpression(callee))
+        return callee.name.text;
+    return undefined;
+}
+export function calleeTextOf(call) {
+    return call.expression.getText(call.getSourceFile()).replace(/\s+/g, '');
+}
+/**
+ * `<file>#<qualified name>` of the declaration the callee resolves to: a
+ * cwd-relative path inside the project, `lib:<file>` for a library.
+ */
+export function calleeDeclarationOf(checker, cwd, call) {
+    const decl = symbolOf(checker, call.expression)?.declarations?.[0];
+    if (!decl)
+        return undefined;
+    const file = decl.getSourceFile().fileName;
+    const relative = path.relative(cwd, file).replace(/\\/g, '/');
+    const where = relative.startsWith('..') || relative.includes('node_modules/') ? `lib:${path.basename(file)}` : relative;
+    return `${where}#${qualifiedName(decl)}`;
+}
+export function calleeKey(checker, cwd, call, level) {
+    if (level === 'name')
+        return calleeNameOf(call);
+    if (level === 'text')
+        return calleeTextOf(call);
+    return calleeDeclarationOf(checker, cwd, call);
+}
+/** Name path of a named declaration: `HttpDeps.fetch`, `Client.send`, `load`. */
+function qualifiedName(decl) {
+    const names = [];
+    for (let node = decl; node && !ts.isSourceFile(node); node = node.parent) {
+        const name = declarationName(node);
+        if (name)
+            names.unshift(name);
+    }
+    return names.join('.') || '<anonymous>';
+}
+const NAMED_DECLARATIONS = new Set([
+    ts.SyntaxKind.VariableDeclaration, ts.SyntaxKind.FunctionDeclaration, ts.SyntaxKind.ClassDeclaration,
+    ts.SyntaxKind.InterfaceDeclaration, ts.SyntaxKind.TypeAliasDeclaration, ts.SyntaxKind.MethodDeclaration,
+    ts.SyntaxKind.MethodSignature, ts.SyntaxKind.PropertySignature, ts.SyntaxKind.PropertyDeclaration,
+    ts.SyntaxKind.ModuleDeclaration, ts.SyntaxKind.PropertyAssignment,
+]);
+function declarationName(node) {
+    if (!NAMED_DECLARATIONS.has(node.kind))
+        return undefined;
+    const name = node.name;
+    if (!name || ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name))
+        return undefined;
+    return propertyNameText(name);
+}
+/** A function-like node with a name: declared, a method, or assigned to a variable or property. */
+export function functionName(fn) {
+    if (!isFunctionLike(fn))
+        return undefined;
+    if ((ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) && fn.name)
+        return propertyNameText(fn.name);
+    const parent = fn.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name))
+        return parent.name.text;
+    if (ts.isPropertyAssignment(parent))
+        return propertyNameText(parent.name);
+    return undefined;
+}
+/** `outer>inner` path of the named functions around `node`, or `<module>` at the top level. */
+export function functionKeyOf(node) {
+    const names = [];
+    for (let current = node; current && !ts.isSourceFile(current); current = current.parent) {
+        const name = functionName(current);
+        if (!name)
+            continue;
+        const owner = ts.isMethodDeclaration(current) && ts.isClassLike(current.parent) ? current.parent.name?.text : undefined;
+        names.unshift(owner ? `${owner}.${name}` : name);
+    }
+    return names.join('>') || '<module>';
+}

package/dist/semantic/learn/learn.d.ts

@@ -0,0 +1,25 @@
+import { type ProposedEdit } from './extract.js';
+import type { LearnedRule } from './types.js';
+export interface LearnInput {
+    beforeDir: string;
+    afterDir: string;
+    /** Repository the rules will guard; hits here are listed for review. */
+    repoDir: string;
+    /** Changed files, relative to both trees. */
+    files: string[];
+    commit?: string;
+    maxHits?: number;
+}
+export interface Rejection {
+    edit: ProposedEdit;
+    reason: string;
+}
+export interface LearnReport {
+    learned: LearnedRule[];
+    rejected: Rejection[];
+    unsupported: Array<{
+        file: string;
+        fn: string;
+    }>;
+}
+export declare function learnFromFix(input: LearnInput): Promise<LearnReport>;

package/dist/semantic/learn/learn.js

@@ -0,0 +1,109 @@
+/**
+ * `rigour learn`: from a fix (before and after trees) to validated rules.
+ *
+ * For each supported edit, candidates are tried from most general to most
+ * specific. The first one that fires on the code before the fix, is silent on
+ * the fixed code, and fires on at most `maxHits` places in the repository is
+ * kept. Nothing is kept on a guess: an edit whose candidates all fail is
+ * reported with the reason the most specific one failed.
+ */
+import crypto from 'crypto';
+import path from 'path';
+import { globby } from 'globby';
+import { analyzeFiles } from '../engine.js';
+import { programBatches, loadProjectConfig } from '../program.js';
+import { compileLearnedRule, LEARNED_PREFIX } from './compile.js';
+import { extractEdits } from './extract.js';
+const DEFAULT_MAX_HITS = 3;
+const SOURCE = /\.(?:[cm]?[jt]s|[jt]sx)$/i;
+const NOT_SOURCE = /\.d\.[cm]?ts$|(?:^|\/)(?:__tests__|__mocks__|tests?)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/;
+export async function learnFromFix(input) {
+    const maxHits = input.maxHits ?? DEFAULT_MAX_HITS;
+    const files = input.files.filter(f => SOURCE.test(f) && !NOT_SOURCE.test(f));
+    const report = { learned: [], rejected: [], unsupported: [] };
+    const edits = [];
+    for (const file of files) {
+        const extraction = extractEdits(file, openTree(input.beforeDir, file), openTree(input.afterDir, file));
+        edits.push(...extraction.edits);
+        report.unsupported.push(...extraction.unsupported.map(fn => ({ file, fn })));
+    }
+    if (edits.length === 0)
+        return report;
+    const candidates = edits.flatMap(edit => edit.candidates.map(pattern => toRule(edit, pattern, input.commit, maxHits)));
+    const repoFiles = await sourceFiles(input.repoDir);
+    const counts = countFindings(input, candidates, files, repoFiles);
+    const seen = new Set();
+    for (const edit of edits) {
+        const tried = candidates.filter(rule => rule.source.file === edit.file && rule.source.function === edit.fn && edit.candidates.includes(rule.pattern));
+        const kept = tried.find(rule => failure(counts.get(rule.id), maxHits) === null);
+        if (kept && !seen.has(kept.id)) {
+            seen.add(kept.id);
+            const { before, after, hits } = counts.get(kept.id);
+            report.learned.push({ ...kept, validation: { firesBefore: before, firesAfter: after, maxHits, repoHits: hits } });
+        }
+        else if (!kept) {
+            report.rejected.push({ edit, reason: failure(counts.get(tried[tried.length - 1].id), maxHits) ?? 'no candidate' });
+        }
+    }
+    return report;
+}
+function openTree(cwd, file) {
+    const root = path.join(cwd, file);
+    const [program] = [...programBatches([root], loadProjectConfig(cwd).options)];
+    const sourceFile = program.getSourceFile(root);
+    if (!sourceFile)
+        throw new Error(`Cannot parse ${file} in ${cwd}`);
+    return { cwd, checker: program.getTypeChecker(), sourceFile };
+}
+function countFindings(input, rules, files, repoFiles) {
+    const compiled = rules.map(compileLearnedRule);
+    const tally = (dir, scan) => analyzeFiles(dir, scan, { rules: compiled });
+    const byRule = (findings, id) => findings.filter(f => f.rule === `${LEARNED_PREFIX}${id}`);
+    const before = tally(input.beforeDir, files);
+    const after = tally(input.afterDir, files);
+    const repo = tally(input.repoDir, repoFiles);
+    return new Map(rules.map(rule => [rule.id, {
+            before: byRule(before, rule.id).length,
+            after: byRule(after, rule.id).length,
+            hits: byRule(repo, rule.id).map(f => `${f.file}:${f.line}`),
+        }]));
+}
+function failure(counts, maxHits) {
+    if (counts.before === 0)
+        return 'does not fire on the code before the fix';
+    if (counts.after > 0)
+        return `still fires ${counts.after} time(s) on the fixed code`;
+    if (counts.hits.length > maxHits)
+        return `fires on ${counts.hits.length} places in the repository (max ${maxHits})`;
+    return null;
+}
+async function sourceFiles(cwd) {
+    const files = await globby('**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}', {
+        cwd, gitignore: true, ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**', '**/coverage/**'],
+    });
+    return files.filter(f => !NOT_SOURCE.test(f));
+}
+function toRule(edit, pattern, commit, maxHits) {
+    return {
+        id: ruleId(pattern),
+        version: 1,
+        pattern,
+        message: messageFor(pattern, edit.file),
+        severity: 'medium',
+        source: { ...(commit ? { commit } : {}), file: edit.file, function: edit.fn },
+        validation: { firesBefore: 0, firesAfter: 0, maxHits, repoHits: [] },
+    };
+}
+function messageFor(pattern, file) {
+    const callee = pattern.callee.key.split('#').pop();
+    if (pattern.template === 'require-option') {
+        const value = pattern.value ? ` (e.g. '${pattern.value}')` : '';
+        return `${callee}(...) does not set \`${pattern.property}\`${value} in argument ${pattern.argIndex + 1}; a fix in ${file} added it to the same call.`;
+    }
+    return `\`${pattern.property}\` in ${callee}(...) is not conditional on \`${pattern.guard}\`; a fix in ${file} added that condition.`;
+}
+function ruleId(pattern) {
+    const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 24);
+    const hash = crypto.createHash('sha256').update(JSON.stringify(pattern)).digest('hex').slice(0, 8);
+    return `${pattern.template}-${slug(pattern.property)}-${hash}`;
+}

package/dist/semantic/learn/learn.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/semantic/learn/learn.test.js

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import ts from 'typescript';
+import { afterEach, describe, expect, it } from 'vitest';
+import { fileURLToPath } from 'url';
+import { forEachNode } from '../ast.js';
+import { loadLearnCases, runLearnCase } from './benchmark.js';
+import { guardsOf, namesIn, propertiesNamed } from './conditions.js';
+import { functionKeyOf, isInvocation } from './identity.js';
+import { loadLearnedRules, saveLearnedRule } from './store.js';
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../benchmarks/learn');
+describe('learn benchmark', () => {
+    for (const bench of loadLearnCases(ROOT)) {
+        it(`${bench.name}: ${bench.note}`, async () => {
+            const result = await runLearnCase(ROOT, bench);
+            expect(result.problems).toEqual([]);
+        });
+    }
+});
+function parse(text) {
+    return ts.createSourceFile('x.ts', text, ts.ScriptTarget.Latest, true);
+}
+function firstCall(sf) {
+    let call;
+    forEachNode(sf, (n) => { if (!call && isInvocation(n))
+        call = n; });
+    return call;
+}
+describe('guardsOf', () => {
+    it('collects the spread condition and the value condition', () => {
+        const sf = parse("h({ ...(ok ? { 'cache-control': fresh ? 'max-age=1' : 'no-store' } : {}) });");
+        const [prop] = propertiesNamed(sf, 'cache-control');
+        expect(namesIn(guardsOf(prop, firstCall(sf)))).toEqual(['fresh', 'ok']);
+    });
+    it('lists property names before receivers', () => {
+        const sf = parse("h({ c: status === 200 && body.stepsAvailable !== false ? 'a' : 'b' });");
+        const [prop] = propertiesNamed(sf, 'c');
+        expect(namesIn(guardsOf(prop, firstCall(sf)))[0]).toBe('stepsAvailable');
+    });
+});
+describe('functionKeyOf', () => {
+    it('names nested arrows, methods and the module level', () => {
+        const sf = parse('class A { run() { const inner = () => f(); } }\ng();\n');
+        const keys = [];
+        forEachNode(sf, (n) => { if (isInvocation(n))
+            keys.push(functionKeyOf(n)); });
+        expect(keys).toEqual(['A.run>inner', '<module>']);
+    });
+});
+describe('learned rule store', () => {
+    let dir;
+    afterEach(() => { if (dir)
+        fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
+    it('round-trips a rule and skips files that are not rules', () => {
+        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'learned-'));
+        const rule = {
+            id: 'require-option-redirect-abcd1234', version: 1,
+            pattern: { template: 'require-option', callee: { level: 'name', key: 'fetch' }, argIndex: 1, property: 'redirect' },
+            message: 'm', severity: 'medium', source: { file: 'http.ts', function: 'post' },
+            validation: { firesBefore: 1, firesAfter: 0, maxHits: 3, repoHits: [] },
+        };
+        saveLearnedRule(dir, rule);
+        fs.writeFileSync(path.join(dir, '.rigour', 'rules', 'broken.json'), '{"id": 1}');
+        expect(loadLearnedRules(dir)).toEqual([rule]);
+    });
+});

package/dist/semantic/learn/store.d.ts

@@ -0,0 +1,4 @@
+import { type LearnedRule } from './types.js';
+export declare const LEARNED_RULES_DIR: string;
+export declare function saveLearnedRule(cwd: string, rule: LearnedRule): string;
+export declare function loadLearnedRules(cwd: string): LearnedRule[];

package/dist/semantic/learn/store.js

@@ -0,0 +1,39 @@
+/**
+ * Learned rules live in `.rigour/rules/<id>.json`, committed and reviewed
+ * like code. A file that does not parse as a rule is skipped with a warning.
+ */
+import fs from 'fs';
+import path from 'path';
+import { Logger } from '../../utils/logger.js';
+import { ZodError } from 'zod';
+import { LearnedRuleSchema } from './types.js';
+export const LEARNED_RULES_DIR = path.join('.rigour', 'rules');
+export function saveLearnedRule(cwd, rule) {
+    const dir = path.join(cwd, LEARNED_RULES_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${rule.id}.json`);
+    fs.writeFileSync(file, `${JSON.stringify(LearnedRuleSchema.parse(rule), null, 2)}\n`);
+    return file;
+}
+export function loadLearnedRules(cwd) {
+    const dir = path.join(cwd, LEARNED_RULES_DIR);
+    if (!fs.existsSync(dir))
+        return [];
+    const rules = [];
+    for (const name of fs.readdirSync(dir).filter(n => n.endsWith('.json')).sort()) {
+        try {
+            rules.push(LearnedRuleSchema.parse(JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'))));
+        }
+        catch (error) {
+            Logger.warn(`Skipping ${path.join(LEARNED_RULES_DIR, name)}: not a valid learned rule (${reasonOf(error)})`);
+        }
+    }
+    return rules;
+}
+function reasonOf(error) {
+    if (error instanceof ZodError) {
+        const [issue] = error.issues;
+        return `${issue.path.join('.') || 'rule'}: ${issue.message}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}