@mmnto/totem 1.2.0 → 1.3.1

package/dist/compiler-schema.d.ts

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+export declare const CompiledRuleSchema: z.ZodObject<{
+    /** SHA-256 hash (first 16 hex chars) of heading + body — detects edits */
+    lessonHash: z.ZodString;
+    /** Human-readable heading from the lesson (for diagnostics) */
+    lessonHeading: z.ZodString;
+    /** Regex pattern to match against added diff lines */
+    pattern: z.ZodString;
+    /** Human-readable violation message shown when the pattern matches */
+    message: z.ZodString;
+    /** Engine type — 'regex' for line-level matching, 'ast' for Tree-sitter S-expression queries, 'ast-grep' for ast-grep structural patterns */
+    engine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
+    /** Tree-sitter S-expression query (required when engine is 'ast') */
+    astQuery: z.ZodOptional<z.ZodString>;
+    /** ast-grep pattern — string for simple patterns, object for compound rules (has/inside/not) */
+    astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    /** ISO timestamp of when this rule was compiled */
+    compiledAt: z.ZodString;
+    /** ISO timestamp of when this rule was first created (survives recompilation) */
+    createdAt: z.ZodOptional<z.ZodString>;
+    /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
+    fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Rule category for Trap Ledger classification */
+    category: z.ZodOptional<z.ZodEnum<["security", "architecture", "style", "performance"]>>;
+    /** Severity level — error blocks CI, warning reports but doesn't fail */
+    severity: z.ZodOptional<z.ZodEnum<["error", "warning"]>>;
+}, "strip", z.ZodTypeAny, {
+    lessonHash: string;
+    lessonHeading: string;
+    pattern: string;
+    message: string;
+    engine: "regex" | "ast" | "ast-grep";
+    compiledAt: string;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | Record<string, unknown> | undefined;
+    createdAt?: string | undefined;
+    fileGlobs?: string[] | undefined;
+    category?: "security" | "architecture" | "style" | "performance" | undefined;
+    severity?: "error" | "warning" | undefined;
+}, {
+    lessonHash: string;
+    lessonHeading: string;
+    pattern: string;
+    message: string;
+    engine: "regex" | "ast" | "ast-grep";
+    compiledAt: string;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | Record<string, unknown> | undefined;
+    createdAt?: string | undefined;
+    fileGlobs?: string[] | undefined;
+    category?: "security" | "architecture" | "style" | "performance" | undefined;
+    severity?: "error" | "warning" | undefined;
+}>;
+export type CompiledRule = z.infer<typeof CompiledRuleSchema>;
+export declare const CompiledRulesFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    rules: z.ZodArray<z.ZodObject<{
+        /** SHA-256 hash (first 16 hex chars) of heading + body — detects edits */
+        lessonHash: z.ZodString;
+        /** Human-readable heading from the lesson (for diagnostics) */
+        lessonHeading: z.ZodString;
+        /** Regex pattern to match against added diff lines */
+        pattern: z.ZodString;
+        /** Human-readable violation message shown when the pattern matches */
+        message: z.ZodString;
+        /** Engine type — 'regex' for line-level matching, 'ast' for Tree-sitter S-expression queries, 'ast-grep' for ast-grep structural patterns */
+        engine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
+        /** Tree-sitter S-expression query (required when engine is 'ast') */
+        astQuery: z.ZodOptional<z.ZodString>;
+        /** ast-grep pattern — string for simple patterns, object for compound rules (has/inside/not) */
+        astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        /** ISO timestamp of when this rule was compiled */
+        compiledAt: z.ZodString;
+        /** ISO timestamp of when this rule was first created (survives recompilation) */
+        createdAt: z.ZodOptional<z.ZodString>;
+        /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
+        fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Rule category for Trap Ledger classification */
+        category: z.ZodOptional<z.ZodEnum<["security", "architecture", "style", "performance"]>>;
+        /** Severity level — error blocks CI, warning reports but doesn't fail */
+        severity: z.ZodOptional<z.ZodEnum<["error", "warning"]>>;
+    }, "strip", z.ZodTypeAny, {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex" | "ast" | "ast-grep";
+        compiledAt: string;
+        astQuery?: string | undefined;
+        astGrepPattern?: string | Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        fileGlobs?: string[] | undefined;
+        category?: "security" | "architecture" | "style" | "performance" | undefined;
+        severity?: "error" | "warning" | undefined;
+    }, {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex" | "ast" | "ast-grep";
+        compiledAt: string;
+        astQuery?: string | undefined;
+        astGrepPattern?: string | Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        fileGlobs?: string[] | undefined;
+        category?: "security" | "architecture" | "style" | "performance" | undefined;
+        severity?: "error" | "warning" | undefined;
+    }>, "many">;
+    /** Lesson hashes that the LLM determined cannot be compiled (conceptual/architectural). */
+    nonCompilable: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    rules: {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex" | "ast" | "ast-grep";
+        compiledAt: string;
+        astQuery?: string | undefined;
+        astGrepPattern?: string | Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        fileGlobs?: string[] | undefined;
+        category?: "security" | "architecture" | "style" | "performance" | undefined;
+        severity?: "error" | "warning" | undefined;
+    }[];
+    nonCompilable?: string[] | undefined;
+}, {
+    version: 1;
+    rules: {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex" | "ast" | "ast-grep";
+        compiledAt: string;
+        astQuery?: string | undefined;
+        astGrepPattern?: string | Record<string, unknown> | undefined;
+        createdAt?: string | undefined;
+        fileGlobs?: string[] | undefined;
+        category?: "security" | "architecture" | "style" | "performance" | undefined;
+        severity?: "error" | "warning" | undefined;
+    }[];
+    nonCompilable?: string[] | undefined;
+}>;
+export type CompiledRulesFile = z.infer<typeof CompiledRulesFileSchema>;
+/** Schema for the structured JSON the LLM returns when compiling a lesson. */
+export declare const CompilerOutputSchema: z.ZodObject<{
+    compilable: z.ZodBoolean;
+    pattern: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    engine: z.ZodOptional<z.ZodEnum<["regex", "ast", "ast-grep"]>>;
+    astQuery: z.ZodOptional<z.ZodString>;
+    astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+}, "strip", z.ZodTypeAny, {
+    compilable: boolean;
+    pattern?: string | undefined;
+    message?: string | undefined;
+    engine?: "regex" | "ast" | "ast-grep" | undefined;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | Record<string, unknown> | undefined;
+    fileGlobs?: string[] | undefined;
+}, {
+    compilable: boolean;
+    pattern?: string | undefined;
+    message?: string | undefined;
+    engine?: "regex" | "ast" | "ast-grep" | undefined;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | Record<string, unknown> | undefined;
+    fileGlobs?: string[] | undefined;
+}>;
+export type CompilerOutput = z.infer<typeof CompilerOutputSchema>;
+export interface Violation {
+    /** The rule that was violated */
+    rule: CompiledRule;
+    /** The file path from the diff where the violation occurred */
+    file: string;
+    /** The matching line content */
+    line: string;
+    /** 1-based line number within the diff hunk (approximate) */
+    lineNumber: number;
+}
+/** Syntactic context of a diff line, determined by AST analysis. */
+export type AstContext = 'code' | 'string' | 'comment' | 'regex';
+export interface DiffAddition {
+    file: string;
+    line: string;
+    lineNumber: number;
+    /** Content of the preceding line in the new file (context or added), null if first in hunk */
+    precedingLine: string | null;
+    /** Syntactic context from AST analysis — undefined means not classified (fail-open as code) */
+    astContext?: AstContext;
+}
+export interface RegexValidation {
+    valid: boolean;
+    reason?: string;
+}
+/** Callback for observability — invoked when a rule is suppressed or triggered. */
+export type RuleEventCallback = (event: 'trigger' | 'suppress', lessonHash: string) => void;
+//# sourceMappingURL=compiler-schema.d.ts.map

package/dist/compiler-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-schema.d.ts","sourceRoot":"","sources":["../src/compiler-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,kBAAkB;IAC7B,0EAA0E;;IAE1E,+DAA+D;;IAE/D,sDAAsD;;IAEtD,sEAAsE;;IAEtE,6IAA6I;;IAE7I,qEAAqE;;IAErE,gGAAgG;;IAEhG,mDAAmD;;IAEnD,iFAAiF;;IAEjF,kGAAkG;;IAElG,mDAAmD;;IAEnD,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,uBAAuB;;;QA5BlC,0EAA0E;;QAE1E,+DAA+D;;QAE/D,sDAAsD;;QAEtD,sEAAsE;;QAEtE,6IAA6I;;QAE7I,qEAAqE;;QAErE,gGAAgG;;QAEhG,mDAAmD;;QAEnD,iFAAiF;;QAEjF,kGAAkG;;QAElG,mDAAmD;;QAEnD,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASzE,2FAA2F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3F,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAIxE,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAQ/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAIlE,MAAM,WAAW,SAAS;IACxB,iCAAiC;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,oEAAoE;AACpE,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AAEjE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,+FAA+F;IAC/F,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAID,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,mFAAmF;AACnF,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC"}

package/dist/compiler-schema.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+// ─── Compiled rule schemas ──────────────────────────
+export const CompiledRuleSchema = z.object({
+    /** SHA-256 hash (first 16 hex chars) of heading + body — detects edits */
+    lessonHash: z.string(),
+    /** Human-readable heading from the lesson (for diagnostics) */
+    lessonHeading: z.string(),
+    /** Regex pattern to match against added diff lines */
+    pattern: z.string(),
+    /** Human-readable violation message shown when the pattern matches */
+    message: z.string(),
+    /** Engine type — 'regex' for line-level matching, 'ast' for Tree-sitter S-expression queries, 'ast-grep' for ast-grep structural patterns */
+    engine: z.enum(['regex', 'ast', 'ast-grep']),
+    /** Tree-sitter S-expression query (required when engine is 'ast') */
+    astQuery: z.string().optional(),
+    /** ast-grep pattern — string for simple patterns, object for compound rules (has/inside/not) */
+    astGrepPattern: z.union([z.string(), z.record(z.unknown())]).optional(),
+    /** ISO timestamp of when this rule was compiled */
+    compiledAt: z.string(),
+    /** ISO timestamp of when this rule was first created (survives recompilation) */
+    createdAt: z.string().optional(),
+    /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
+    fileGlobs: z.array(z.string()).optional(),
+    /** Rule category for Trap Ledger classification */
+    category: z.enum(['security', 'architecture', 'style', 'performance']).optional(),
+    /** Severity level — error blocks CI, warning reports but doesn't fail */
+    severity: z.enum(['error', 'warning']).optional(),
+});
+export const CompiledRulesFileSchema = z.object({
+    version: z.literal(1),
+    rules: z.array(CompiledRuleSchema),
+    /** Lesson hashes that the LLM determined cannot be compiled (conceptual/architectural). */
+    nonCompilable: z.array(z.string()).optional(),
+});
+// ─── Compiler output schema ─────────────────────────
+/** Schema for the structured JSON the LLM returns when compiling a lesson. */
+export const CompilerOutputSchema = z.object({
+    compilable: z.boolean(),
+    pattern: z.string().optional(),
+    message: z.string().optional(),
+    fileGlobs: z.array(z.string()).optional(),
+    engine: z.enum(['regex', 'ast', 'ast-grep']).optional(),
+    astQuery: z.string().optional(),
+    astGrepPattern: z.union([z.string(), z.record(z.unknown())]).optional(),
+});
+//# sourceMappingURL=compiler-schema.js.map

package/dist/compiler-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-schema.js","sourceRoot":"","sources":["../src/compiler-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,uDAAuD;AAEvD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,0EAA0E;IAC1E,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,+DAA+D;IAC/D,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,sDAAsD;IACtD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,sEAAsE;IACtE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,6IAA6I;IAC7I,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;IAC5C,qEAAqE;IACrE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,gGAAgG;IAChG,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACvE,mDAAmD;IACnD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,iFAAiF;IACjF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,kGAAkG;IAClG,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACzC,mDAAmD;IACnD,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,QAAQ,EAAE;IACjF,yEAAyE;IACzE,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,QAAQ,EAAE;CAClD,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IACrB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;IAClC,2FAA2F;IAC3F,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC9C,CAAC,CAAC;AAIH,uDAAuD;AAEvD,8EAA8E;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE;IACvB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACzC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,QAAQ,EAAE;IACvD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CACxE,CAAC,CAAC"}

package/dist/compiler.d.ts

@@ -1,213 +1,24 @@
-import { z } from 'zod';
-export declare const CompiledRuleSchema: z.ZodObject<{
-    /** SHA-256 hash (first 16 hex chars) of heading + body — detects edits */
-    lessonHash: z.ZodString;
-    /** Human-readable heading from the lesson (for diagnostics) */
-    lessonHeading: z.ZodString;
-    /** Regex pattern to match against added diff lines */
-    pattern: z.ZodString;
-    /** Human-readable violation message shown when the pattern matches */
-    message: z.ZodString;
-    /** Engine type — 'regex' for line-level matching, 'ast' for Tree-sitter S-expression queries, 'ast-grep' for ast-grep structural patterns */
-    engine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
-    /** Tree-sitter S-expression query (required when engine is 'ast') */
-    astQuery: z.ZodOptional<z.ZodString>;
-    /** ast-grep pattern — string for simple patterns, object for compound rules (has/inside/not) */
-    astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    /** ISO timestamp of when this rule was compiled */
-    compiledAt: z.ZodString;
-    /** ISO timestamp of when this rule was first created (survives recompilation) */
-    createdAt: z.ZodOptional<z.ZodString>;
-    /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
-    fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Rule category for Trap Ledger classification */
-    category: z.ZodOptional<z.ZodEnum<["security", "architecture", "style", "performance"]>>;
-    /** Severity level — error blocks CI, warning reports but doesn't fail */
-    severity: z.ZodOptional<z.ZodEnum<["error", "warning"]>>;
-}, "strip", z.ZodTypeAny, {
-    lessonHash: string;
-    lessonHeading: string;
-    pattern: string;
-    message: string;
-    engine: "regex" | "ast" | "ast-grep";
-    compiledAt: string;
-    astQuery?: string | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
-    createdAt?: string | undefined;
-    fileGlobs?: string[] | undefined;
-    category?: "security" | "architecture" | "style" | "performance" | undefined;
-    severity?: "error" | "warning" | undefined;
-}, {
-    lessonHash: string;
-    lessonHeading: string;
-    pattern: string;
-    message: string;
-    engine: "regex" | "ast" | "ast-grep";
-    compiledAt: string;
-    astQuery?: string | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
-    createdAt?: string | undefined;
-    fileGlobs?: string[] | undefined;
-    category?: "security" | "architecture" | "style" | "performance" | undefined;
-    severity?: "error" | "warning" | undefined;
-}>;
-export type CompiledRule = z.infer<typeof CompiledRuleSchema>;
-export declare const CompiledRulesFileSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    rules: z.ZodArray<z.ZodObject<{
-        /** SHA-256 hash (first 16 hex chars) of heading + body — detects edits */
-        lessonHash: z.ZodString;
-        /** Human-readable heading from the lesson (for diagnostics) */
-        lessonHeading: z.ZodString;
-        /** Regex pattern to match against added diff lines */
-        pattern: z.ZodString;
-        /** Human-readable violation message shown when the pattern matches */
-        message: z.ZodString;
-        /** Engine type — 'regex' for line-level matching, 'ast' for Tree-sitter S-expression queries, 'ast-grep' for ast-grep structural patterns */
-        engine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
-        /** Tree-sitter S-expression query (required when engine is 'ast') */
-        astQuery: z.ZodOptional<z.ZodString>;
-        /** ast-grep pattern — string for simple patterns, object for compound rules (has/inside/not) */
-        astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-        /** ISO timestamp of when this rule was compiled */
-        compiledAt: z.ZodString;
-        /** ISO timestamp of when this rule was first created (survives recompilation) */
-        createdAt: z.ZodOptional<z.ZodString>;
-        /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
-        fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Rule category for Trap Ledger classification */
-        category: z.ZodOptional<z.ZodEnum<["security", "architecture", "style", "performance"]>>;
-        /** Severity level — error blocks CI, warning reports but doesn't fail */
-        severity: z.ZodOptional<z.ZodEnum<["error", "warning"]>>;
-    }, "strip", z.ZodTypeAny, {
-        lessonHash: string;
-        lessonHeading: string;
-        pattern: string;
-        message: string;
-        engine: "regex" | "ast" | "ast-grep";
-        compiledAt: string;
-        astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
-        createdAt?: string | undefined;
-        fileGlobs?: string[] | undefined;
-        category?: "security" | "architecture" | "style" | "performance" | undefined;
-        severity?: "error" | "warning" | undefined;
-    }, {
-        lessonHash: string;
-        lessonHeading: string;
-        pattern: string;
-        message: string;
-        engine: "regex" | "ast" | "ast-grep";
-        compiledAt: string;
-        astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
-        createdAt?: string | undefined;
-        fileGlobs?: string[] | undefined;
-        category?: "security" | "architecture" | "style" | "performance" | undefined;
-        severity?: "error" | "warning" | undefined;
-    }>, "many">;
-    /** Lesson hashes that the LLM determined cannot be compiled (conceptual/architectural). */
-    nonCompilable: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    rules: {
-        lessonHash: string;
-        lessonHeading: string;
-        pattern: string;
-        message: string;
-        engine: "regex" | "ast" | "ast-grep";
-        compiledAt: string;
-        astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
-        createdAt?: string | undefined;
-        fileGlobs?: string[] | undefined;
-        category?: "security" | "architecture" | "style" | "performance" | undefined;
-        severity?: "error" | "warning" | undefined;
-    }[];
-    nonCompilable?: string[] | undefined;
-}, {
-    version: 1;
-    rules: {
-        lessonHash: string;
-        lessonHeading: string;
-        pattern: string;
-        message: string;
-        engine: "regex" | "ast" | "ast-grep";
-        compiledAt: string;
-        astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
-        createdAt?: string | undefined;
-        fileGlobs?: string[] | undefined;
-        category?: "security" | "architecture" | "style" | "performance" | undefined;
-        severity?: "error" | "warning" | undefined;
-    }[];
-    nonCompilable?: string[] | undefined;
-}>;
-export type CompiledRulesFile = z.infer<typeof CompiledRulesFileSchema>;
-export interface Violation {
-    /** The rule that was violated */
-    rule: CompiledRule;
-    /** The file path from the diff where the violation occurred */
-    file: string;
-    /** The matching line content */
-    line: string;
-    /** 1-based line number within the diff hunk (approximate) */
-    lineNumber: number;
-}
+/**
+ * Compiler facade — re-exports from focused modules.
+ *
+ * Schemas and types:  ./compiler-schema.ts
+ * Diff parsing:       ./diff-parser.ts
+ * Rule execution:     ./rule-engine.ts
+ *
+ * This file retains: hashing, regex validation, file I/O, and LLM response parsing.
+ */
+import type { CompiledRule, CompiledRulesFile, CompilerOutput, RegexValidation } from './compiler-schema.js';
+export type { AstContext, CompiledRule, CompiledRulesFile, CompilerOutput, DiffAddition, RegexValidation, RuleEventCallback, Violation, } from './compiler-schema.js';
+export { CompiledRuleSchema, CompiledRulesFileSchema, CompilerOutputSchema, } from './compiler-schema.js';
+export { extractAddedLines } from './diff-parser.js';
+export { applyAstRulesToAdditions, applyRules, applyRulesToAdditions, matchesGlob, } from './rule-engine.js';
 /** Hash a lesson's heading + body to detect changes since compilation. */
 export declare function hashLesson(heading: string, body: string): string;
-export interface RegexValidation {
-    valid: boolean;
-    reason?: string;
-}
 /**
  * Validate that a pattern string is a syntactically valid RegExp
  * and is not vulnerable to ReDoS (catastrophic backtracking).
  */
 export declare function validateRegex(pattern: string): RegexValidation;
-/** Syntactic context of a diff line, determined by AST analysis. */
-export type AstContext = 'code' | 'string' | 'comment' | 'regex';
-export interface DiffAddition {
-    file: string;
-    line: string;
-    lineNumber: number;
-    /** Content of the preceding line in the new file (context or added), null if first in hunk */
-    precedingLine: string | null;
-    /** Syntactic context from AST analysis — undefined means not classified (fail-open as code) */
-    astContext?: AstContext;
-}
-/**
- * Extract added lines from a unified diff.
- * Returns only lines that start with `+` (excluding `+++` file headers).
- * Tracks the preceding line content (context or added) for suppression support.
- */
-export declare function extractAddedLines(diff: string): DiffAddition[];
-/**
- * Check if a file path matches a single glob pattern.
- * Supports: `*.ext`, `**\/*.ext`, `dir/**\/*.ext`, `dir/**`, literal filenames.
- */
-export declare function matchesGlob(filePath: string, glob: string): boolean;
-/** Callback for observability — invoked when a rule is suppressed or triggered. */
-export type RuleEventCallback = (event: 'trigger' | 'suppress', lessonHash: string) => void;
-/**
- * Apply compiled rules against pre-extracted diff additions.
- * Skips additions with non-code AST context (strings, comments, regex).
- * Optional `onRuleEvent` callback enables observability metrics collection.
- */
-export declare function applyRulesToAdditions(rules: CompiledRule[], additions: DiffAddition[], onRuleEvent?: RuleEventCallback): Violation[];
-/**
- * Apply AST-engine compiled rules against pre-extracted diff additions.
- * Handles both Tree-sitter S-expression ('ast') and ast-grep ('ast-grep') engines.
- * Async because it reads files and runs Tree-sitter queries.
- * Handles fileGlobs filtering and suppression same as regex rules.
- */
-export declare function applyAstRulesToAdditions(rules: CompiledRule[], additions: DiffAddition[], cwd: string, onRuleEvent?: RuleEventCallback): Promise<Violation[]>;
-/**
- * Apply compiled rules against added lines from a diff.
- * Returns all violations found.
- * @param excludeFiles — file paths to skip (e.g., compiled-rules.json to avoid self-matches)
- */
-export declare function applyRules(rules: CompiledRule[], diff: string, excludeFiles?: string[]): Violation[];
 /** Load compiled rules from a JSON file. Returns empty array if file missing. */
 export declare function loadCompiledRules(rulesPath: string, onWarn?: (msg: string) => void): CompiledRule[];
 /** Load the full compiled rules file (rules + non-compilable cache). */
@@ -216,33 +27,6 @@ export declare function loadCompiledRulesFile(rulesPath: string, onWarn?: (msg:
 export declare function saveCompiledRules(rulesPath: string, rules: CompiledRule[]): void;
 /** Save the full compiled rules file (rules + non-compilable cache). */
 export declare function saveCompiledRulesFile(rulesPath: string, data: CompiledRulesFile): void;
-/** Schema for the structured JSON the LLM returns when compiling a lesson. */
-export declare const CompilerOutputSchema: z.ZodObject<{
-    compilable: z.ZodBoolean;
-    pattern: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-    fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    engine: z.ZodOptional<z.ZodEnum<["regex", "ast", "ast-grep"]>>;
-    astQuery: z.ZodOptional<z.ZodString>;
-    astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-}, "strip", z.ZodTypeAny, {
-    compilable: boolean;
-    astQuery?: string | undefined;
-    pattern?: string | undefined;
-    message?: string | undefined;
-    engine?: "regex" | "ast" | "ast-grep" | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
-    fileGlobs?: string[] | undefined;
-}, {
-    compilable: boolean;
-    astQuery?: string | undefined;
-    pattern?: string | undefined;
-    message?: string | undefined;
-    engine?: "regex" | "ast" | "ast-grep" | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
-    fileGlobs?: string[] | undefined;
-}>;
-export type CompilerOutput = z.infer<typeof CompilerOutputSchema>;
 /**
  * Parse the LLM's compilation response. Extracts JSON from the response text,
  * validates it, and returns the structured output or null if unparseable.

package/dist/compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAM9B,YAAY,EACV,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,SAAS,GACV,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EACL,wBAAwB,EACxB,UAAU,EACV,qBAAqB,EACrB,WAAW,GACZ,MAAM,kBAAkB,CAAC;AAM1B,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMhE;AAID;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAY9D;AAID,iFAAiF;AACjF,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC7B,YAAY,EAAE,CAmBhB;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC7B,iBAAiB,CAoBnB;AAED,0CAA0C;AAC1C,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI,CAMhF;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAKtF;AAID;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAa7E"}