@rigour-labs/core 6.2.5 → 6.3.1

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);
+}

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

@@ -0,0 +1,468 @@
+/**
+ * Rules learned from a fix: a before/after pair turned into a check.
+ *
+ * A learned rule is data (`.rigour/rules/<id>.json`), reviewed in pull
+ * requests like code. It is kept only when it fires on the code before the
+ * fix, is silent on the fixed code, and fires on few other places in the
+ * repository; the validation that proved this is stored with it.
+ */
+import { z } from 'zod';
+/** How a call is recognised: by its name, the declaration it resolves to, or its exact text. */
+export declare const CalleeMatcherSchema: z.ZodObject<{
+    level: z.ZodEnum<["name", "declaration", "text"]>;
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    level: "name" | "text" | "declaration";
+}, {
+    key: string;
+    level: "name" | "text" | "declaration";
+}>;
+/** Narrows a rule to one function in one file: a regression guard for the fixed code. */
+export declare const ScopeSchema: z.ZodObject<{
+    file: z.ZodString;
+    fn: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    file: string;
+    fn: string;
+}, {
+    file: string;
+    fn: string;
+}>;
+export declare const RequireOptionSchema: z.ZodObject<{
+    template: z.ZodLiteral<"require-option">;
+    callee: z.ZodObject<{
+        level: z.ZodEnum<["name", "declaration", "text"]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }>;
+    argIndex: z.ZodNumber;
+    property: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        fn: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        fn: string;
+    }, {
+        file: string;
+        fn: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    template: "require-option";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    argIndex: number;
+    property: string;
+    value?: string | undefined;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}, {
+    template: "require-option";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    argIndex: number;
+    property: string;
+    value?: string | undefined;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}>;
+export declare const RequireGuardSchema: z.ZodObject<{
+    template: z.ZodLiteral<"require-guard">;
+    callee: z.ZodObject<{
+        level: z.ZodEnum<["name", "declaration", "text"]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }>;
+    property: z.ZodString;
+    guard: z.ZodString;
+    /** Apply only where the call's other arguments mention `guard` (e.g. the body carries it). */
+    appliesWhenArgsMention: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        fn: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        fn: string;
+    }, {
+        file: string;
+        fn: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    template: "require-guard";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    property: string;
+    guard: string;
+    appliesWhenArgsMention: boolean;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}, {
+    template: "require-guard";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    property: string;
+    guard: string;
+    appliesWhenArgsMention: boolean;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}>;
+export declare const LearnedPatternSchema: z.ZodDiscriminatedUnion<"template", [z.ZodObject<{
+    template: z.ZodLiteral<"require-option">;
+    callee: z.ZodObject<{
+        level: z.ZodEnum<["name", "declaration", "text"]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }>;
+    argIndex: z.ZodNumber;
+    property: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        fn: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        fn: string;
+    }, {
+        file: string;
+        fn: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    template: "require-option";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    argIndex: number;
+    property: string;
+    value?: string | undefined;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}, {
+    template: "require-option";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    argIndex: number;
+    property: string;
+    value?: string | undefined;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}>, z.ZodObject<{
+    template: z.ZodLiteral<"require-guard">;
+    callee: z.ZodObject<{
+        level: z.ZodEnum<["name", "declaration", "text"]>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }, {
+        key: string;
+        level: "name" | "text" | "declaration";
+    }>;
+    property: z.ZodString;
+    guard: z.ZodString;
+    /** Apply only where the call's other arguments mention `guard` (e.g. the body carries it). */
+    appliesWhenArgsMention: z.ZodBoolean;
+    scope: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        fn: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        fn: string;
+    }, {
+        file: string;
+        fn: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    template: "require-guard";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    property: string;
+    guard: string;
+    appliesWhenArgsMention: boolean;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}, {
+    template: "require-guard";
+    callee: {
+        key: string;
+        level: "name" | "text" | "declaration";
+    };
+    property: string;
+    guard: string;
+    appliesWhenArgsMention: boolean;
+    scope?: {
+        file: string;
+        fn: string;
+    } | undefined;
+}>]>;
+export declare const LearnedRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodLiteral<1>;
+    pattern: z.ZodDiscriminatedUnion<"template", [z.ZodObject<{
+        template: z.ZodLiteral<"require-option">;
+        callee: z.ZodObject<{
+            level: z.ZodEnum<["name", "declaration", "text"]>;
+            key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            level: "name" | "text" | "declaration";
+        }, {
+            key: string;
+            level: "name" | "text" | "declaration";
+        }>;
+        argIndex: z.ZodNumber;
+        property: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            fn: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            fn: string;
+        }, {
+            file: string;
+            fn: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        template: "require-option";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        argIndex: number;
+        property: string;
+        value?: string | undefined;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    }, {
+        template: "require-option";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        argIndex: number;
+        property: string;
+        value?: string | undefined;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    }>, z.ZodObject<{
+        template: z.ZodLiteral<"require-guard">;
+        callee: z.ZodObject<{
+            level: z.ZodEnum<["name", "declaration", "text"]>;
+            key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            level: "name" | "text" | "declaration";
+        }, {
+            key: string;
+            level: "name" | "text" | "declaration";
+        }>;
+        property: z.ZodString;
+        guard: z.ZodString;
+        /** Apply only where the call's other arguments mention `guard` (e.g. the body carries it). */
+        appliesWhenArgsMention: z.ZodBoolean;
+        scope: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            fn: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            fn: string;
+        }, {
+            file: string;
+            fn: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        template: "require-guard";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        property: string;
+        guard: string;
+        appliesWhenArgsMention: boolean;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    }, {
+        template: "require-guard";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        property: string;
+        guard: string;
+        appliesWhenArgsMention: boolean;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    }>]>;
+    message: z.ZodString;
+    severity: z.ZodEnum<["low", "medium", "high"]>;
+    source: z.ZodObject<{
+        commit: z.ZodOptional<z.ZodString>;
+        file: z.ZodString;
+        function: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        function: string;
+        file: string;
+        commit?: string | undefined;
+    }, {
+        function: string;
+        file: string;
+        commit?: string | undefined;
+    }>;
+    validation: z.ZodObject<{
+        firesBefore: z.ZodNumber;
+        firesAfter: z.ZodNumber;
+        maxHits: z.ZodNumber;
+        repoHits: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        firesBefore: number;
+        firesAfter: number;
+        maxHits: number;
+        repoHits: string[];
+    }, {
+        firesBefore: number;
+        firesAfter: number;
+        maxHits: number;
+        repoHits: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    validation: {
+        firesBefore: number;
+        firesAfter: number;
+        maxHits: number;
+        repoHits: string[];
+    };
+    version: 1;
+    id: string;
+    severity: "high" | "medium" | "low";
+    source: {
+        function: string;
+        file: string;
+        commit?: string | undefined;
+    };
+    pattern: {
+        template: "require-option";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        argIndex: number;
+        property: string;
+        value?: string | undefined;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    } | {
+        template: "require-guard";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        property: string;
+        guard: string;
+        appliesWhenArgsMention: boolean;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    };
+}, {
+    message: string;
+    validation: {
+        firesBefore: number;
+        firesAfter: number;
+        maxHits: number;
+        repoHits: string[];
+    };
+    version: 1;
+    id: string;
+    severity: "high" | "medium" | "low";
+    source: {
+        function: string;
+        file: string;
+        commit?: string | undefined;
+    };
+    pattern: {
+        template: "require-option";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        argIndex: number;
+        property: string;
+        value?: string | undefined;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    } | {
+        template: "require-guard";
+        callee: {
+            key: string;
+            level: "name" | "text" | "declaration";
+        };
+        property: string;
+        guard: string;
+        appliesWhenArgsMention: boolean;
+        scope?: {
+            file: string;
+            fn: string;
+        } | undefined;
+    };
+}>;
+export type CalleeMatcher = z.infer<typeof CalleeMatcherSchema>;
+export type LearnedPattern = z.infer<typeof LearnedPatternSchema>;
+export type LearnedRule = z.infer<typeof LearnedRuleSchema>;