@mmnto/totem 0.17.0 → 0.19.0

package/dist/compiler.d.ts

@@ -0,0 +1,158 @@
+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 — only 'regex' for MVP */
+    engine: z.ZodLiteral<"regex">;
+    /** ISO timestamp of when this rule was compiled */
+    compiledAt: z.ZodString;
+    /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
+    fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    lessonHash: string;
+    lessonHeading: string;
+    pattern: string;
+    message: string;
+    engine: "regex";
+    compiledAt: string;
+    fileGlobs?: string[] | undefined;
+}, {
+    lessonHash: string;
+    lessonHeading: string;
+    pattern: string;
+    message: string;
+    engine: "regex";
+    compiledAt: string;
+    fileGlobs?: string[] | 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 — only 'regex' for MVP */
+        engine: z.ZodLiteral<"regex">;
+        /** ISO timestamp of when this rule was compiled */
+        compiledAt: z.ZodString;
+        /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
+        fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex";
+        compiledAt: string;
+        fileGlobs?: string[] | undefined;
+    }, {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex";
+        compiledAt: string;
+        fileGlobs?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    rules: {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex";
+        compiledAt: string;
+        fileGlobs?: string[] | undefined;
+    }[];
+}, {
+    version: 1;
+    rules: {
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        message: string;
+        engine: "regex";
+        compiledAt: string;
+        fileGlobs?: 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;
+}
+/** 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;
+interface DiffAddition {
+    file: string;
+    line: string;
+    lineNumber: number;
+}
+/**
+ * Extract added lines from a unified diff.
+ * Returns only lines that start with `+` (excluding `+++` file headers).
+ */
+export declare function extractAddedLines(diff: string): DiffAddition[];
+/**
+ * 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 or invalid. */
+export declare function loadCompiledRules(rulesPath: string): CompiledRule[];
+/** Save compiled rules to a JSON file. */
+export declare function saveCompiledRules(rulesPath: string, rules: CompiledRule[]): 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">>;
+}, "strip", z.ZodTypeAny, {
+    compilable: boolean;
+    pattern?: string | undefined;
+    message?: string | undefined;
+    fileGlobs?: string[] | undefined;
+}, {
+    compilable: boolean;
+    pattern?: string | undefined;
+    message?: string | 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.
+ */
+export declare function parseCompilerResponse(response: string): CompilerOutput | null;
+export {};
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,kBAAkB;IAC7B,0EAA0E;;IAE1E,+DAA+D;;IAE/D,sDAAsD;;IAEtD,sEAAsE;;IAEtE,yCAAyC;;IAEzC,mDAAmD;;IAEnD,kGAAkG;;;;;;;;;;;;;;;;;;EAElG,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,uBAAuB;;;QAlBlC,0EAA0E;;QAE1E,+DAA+D;;QAE/D,sDAAsD;;QAEtD,sEAAsE;;QAEtE,yCAAyC;;QAEzC,mDAAmD;;QAEnD,kGAAkG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASlG,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAIxE,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;AAMD,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMhE;AAID,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAY9D;AAID,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CA8C9D;AA+BD;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,YAAY,EAAE,EACrB,IAAI,EAAE,MAAM,EACZ,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB,SAAS,EAAE,CAsCb;AAID,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,EAAE,CAUnE;AAED,0CAA0C;AAC1C,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI,CAMhF;AAID,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAa7E"}

package/dist/compiler.js

@@ -0,0 +1,213 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import safeRegex from 'safe-regex2';
+import { z } from 'zod';
+// ─── 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 — only 'regex' for MVP */
+    engine: z.literal('regex'),
+    /** ISO timestamp of when this rule was compiled */
+    compiledAt: z.string(),
+    /** Optional file glob patterns — rule only applies to matching files (e.g., ["*.sh", "*.yml"]) */
+    fileGlobs: z.array(z.string()).optional(),
+});
+export const CompiledRulesFileSchema = z.object({
+    version: z.literal(1),
+    rules: z.array(CompiledRuleSchema),
+});
+// ─── Hashing ─────────────────────────────────────────
+const HASH_SLICE_LEN = 16;
+/** Hash a lesson's heading + body to detect changes since compilation. */
+export function hashLesson(heading, body) {
+    return crypto
+        .createHash('sha256')
+        .update(`${heading}\n${body}`)
+        .digest('hex')
+        .slice(0, HASH_SLICE_LEN);
+}
+/**
+ * Validate that a pattern string is a syntactically valid RegExp
+ * and is not vulnerable to ReDoS (catastrophic backtracking).
+ */
+export function validateRegex(pattern) {
+    try {
+        new RegExp(pattern);
+    }
+    catch {
+        return { valid: false, reason: 'invalid syntax' };
+    }
+    if (!safeRegex(pattern)) {
+        return { valid: false, reason: 'ReDoS vulnerability detected' };
+    }
+    return { valid: true };
+}
+/**
+ * Extract added lines from a unified diff.
+ * Returns only lines that start with `+` (excluding `+++` file headers).
+ */
+export function extractAddedLines(diff) {
+    const additions = [];
+    let currentFile = '';
+    let lineNum = 0;
+    for (const rawLine of diff.split('\n')) {
+        // Track current file from diff headers
+        // git quotes paths containing spaces: +++ "b/path with spaces/file.ts"
+        if (rawLine.startsWith('+++')) {
+            let pathPart = rawLine.slice(4); // strip "+++ "
+            // Strip surrounding quotes (git adds them for paths with spaces)
+            if (pathPart.startsWith('"') && pathPart.endsWith('"')) {
+                pathPart = pathPart.slice(1, -1);
+            }
+            // Strip the "b/" prefix git uses for the destination file
+            currentFile = pathPart.startsWith('b/') ? pathPart.slice(2) : pathPart;
+            continue;
+        }
+        // Parse hunk header for line numbers: @@ -X,Y +Z,W @@
+        const hunkMatch = rawLine.match(/^@@ -\d+(?:,\d+)? \+(\d+)/);
+        if (hunkMatch) {
+            lineNum = parseInt(hunkMatch[1], 10) - 1; // will be incremented on first line
+            continue;
+        }
+        // Skip diff metadata lines
+        if (rawLine.startsWith('---') || rawLine.startsWith('diff ') || rawLine.startsWith('index ')) {
+            continue;
+        }
+        // Count lines for position tracking
+        if (rawLine.startsWith('+')) {
+            lineNum++;
+            additions.push({
+                file: currentFile,
+                line: rawLine.slice(1), // strip the leading +
+                lineNumber: lineNum,
+            });
+        }
+        else if (!rawLine.startsWith('-')) {
+            // Context line (no prefix or space prefix) — increment line counter
+            lineNum++;
+        }
+    }
+    return additions;
+}
+// ─── Rule execution ──────────────────────────────────
+// ─── File glob matching ─────────────────────────────
+/**
+ * Check if a file path matches any of the given glob patterns.
+ * Supports simple patterns: `*.ext`, `**\/*.ext`, literal filenames.
+ */
+function matchesGlob(filePath, glob) {
+    // Normalize separators
+    const normalized = filePath.replace(/\\/g, '/');
+    // *.ext — match file extension anywhere
+    if (glob.startsWith('*.')) {
+        return normalized.endsWith(glob.slice(1));
+    }
+    // **/*.ext — same as *.ext (match extension anywhere in path)
+    if (glob.startsWith('**/')) {
+        return matchesGlob(normalized, glob.slice(3));
+    }
+    // Literal filename match (e.g., "Dockerfile")
+    return normalized === glob || normalized.endsWith('/' + glob);
+}
+function fileMatchesGlobs(filePath, globs) {
+    return globs.some((g) => matchesGlob(filePath, g));
+}
+// ─── Rule execution ──────────────────────────────────
+/**
+ * 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 function applyRules(rules, diff, excludeFiles) {
+    let additions = extractAddedLines(diff);
+    if (additions.length === 0 || rules.length === 0)
+        return [];
+    if (excludeFiles && excludeFiles.length > 0) {
+        const excluded = new Set(excludeFiles);
+        additions = additions.filter((a) => !excluded.has(a.file));
+    }
+    const violations = [];
+    for (const rule of rules) {
+        let re;
+        try {
+            re = new RegExp(rule.pattern);
+        }
+        catch {
+            // Skip invalid patterns (shouldn't happen if validation gate works)
+            continue;
+        }
+        for (const addition of additions) {
+            // Skip if rule has fileGlobs and this file doesn't match
+            if (rule.fileGlobs && rule.fileGlobs.length > 0) {
+                if (!fileMatchesGlobs(addition.file, rule.fileGlobs))
+                    continue;
+            }
+            if (re.test(addition.line)) {
+                violations.push({
+                    rule,
+                    file: addition.file,
+                    line: addition.line,
+                    lineNumber: addition.lineNumber,
+                });
+            }
+        }
+    }
+    return violations;
+}
+// ─── File I/O ────────────────────────────────────────
+/** Load compiled rules from a JSON file. Returns empty array if file missing or invalid. */
+export function loadCompiledRules(rulesPath) {
+    if (!fs.existsSync(rulesPath))
+        return [];
+    try {
+        const raw = fs.readFileSync(rulesPath, 'utf-8');
+        const parsed = CompiledRulesFileSchema.parse(JSON.parse(raw));
+        return parsed.rules;
+    }
+    catch {
+        return [];
+    }
+}
+/** Save compiled rules to a JSON file. */
+export function saveCompiledRules(rulesPath, rules) {
+    const data = { version: 1, rules };
+    fs.writeFileSync(rulesPath, JSON.stringify(data, null, 2) + '\n', {
+        encoding: 'utf-8',
+        mode: 0o644,
+    });
+}
+// ─── LLM response parsing ───────────────────────────
+/** 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(),
+});
+/**
+ * Parse the LLM's compilation response. Extracts JSON from the response text,
+ * validates it, and returns the structured output or null if unparseable.
+ */
+export function parseCompilerResponse(response) {
+    // Try to extract JSON from the response (LLMs often wrap in ```json blocks)
+    const jsonMatch = response.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    const jsonStr = jsonMatch ? jsonMatch[1] : response.trim();
+    try {
+        const parsed = JSON.parse(jsonStr);
+        const result = CompilerOutputSchema.safeParse(parsed);
+        if (!result.success)
+            return null;
+        return result.data;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=compiler.js.map

package/dist/compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"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"}

package/dist/compiler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compiler.test.d.ts.map

package/dist/compiler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.test.d.ts","sourceRoot":"","sources":["../src/compiler.test.ts"],"names":[],"mappings":""}