prism-pr 1.0.0-alpha.47

package/dist/persistence/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/persistence/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBzB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B1B,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB3B,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc1B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI1B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B,CAAC"}

package/dist/persistence/schema.js

@@ -0,0 +1,92 @@
+import { sqliteTable, text, integer, real, index, uniqueIndex, primaryKey } from 'drizzle-orm/sqlite-core';
+export const reviewSessions = sqliteTable('review_sessions', {
+    id: text('id').primaryKey(),
+    workspace: text('workspace').notNull(),
+    repo: text('repo').notNull(),
+    prId: integer('pr_id').notNull(),
+    prTitle: text('pr_title'),
+    prUrl: text('pr_url'),
+    status: text('status').notNull().default('pending'),
+    agentIds: text('agent_ids').notNull(),
+    model: text('model').notNull(),
+    findingsCount: integer('findings_count').notNull().default(0),
+    publishedCount: integer('published_count').notNull().default(0),
+    inputTokens: integer('input_tokens'),
+    outputTokens: integer('output_tokens'),
+    costUsd: real('cost_usd'),
+    memorySaved: integer('memory_saved').notNull().default(0),
+    createdAt: text('created_at').notNull(),
+    completedAt: text('completed_at'),
+});
+export const reviewFindings = sqliteTable('review_findings', {
+    id: text('id').primaryKey(),
+    sessionId: text('session_id')
+        .notNull()
+        .references(() => reviewSessions.id),
+    filePath: text('file_path').notNull(),
+    lineNumber: integer('line_number').notNull(),
+    severity: text('severity').notNull(),
+    category: text('category').notNull(),
+    title: text('title').notNull(),
+    problem: text('problem').notNull(),
+    rationale: text('rationale').notNull(),
+    suggestion: text('suggestion').notNull(),
+    agentId: text('agent_id').notNull(),
+    dedupHash: text('dedup_hash').notNull(),
+    status: text('status').notNull().default('pending'),
+    skipReason: text('skip_reason'),
+    bitbucketCommentId: integer('bitbucket_comment_id'),
+    createdAt: text('created_at').notNull(),
+}, (table) => [
+    index('idx_findings_session').on(table.sessionId),
+    index('idx_findings_hash').on(table.dedupHash),
+]);
+export const agentResults = sqliteTable('agent_results', {
+    id: text('id').primaryKey(),
+    sessionId: text('session_id')
+        .notNull()
+        .references(() => reviewSessions.id),
+    agentId: text('agent_id').notNull(),
+    status: text('status').notNull(),
+    errorMessage: text('error_message'),
+    inputTokens: integer('input_tokens').notNull().default(0),
+    outputTokens: integer('output_tokens').notNull().default(0),
+    findingsCount: integer('findings_count').notNull().default(0),
+    createdAt: text('created_at').notNull(),
+});
+export const projectProfiles = sqliteTable('project_profiles', {
+    id: text('id').primaryKey(),
+    workspace: text('workspace').notNull(),
+    repo: text('repo').notNull(),
+    defaultModel: text('default_model'),
+    agentIds: text('agent_ids'),
+    conventions: text('conventions'),
+    detectedLanguages: text('detected_languages'),
+    stackProfile: text('stack_profile'),
+    lastReviewedAt: text('last_reviewed_at'),
+    createdAt: text('created_at').notNull(),
+    updatedAt: text('updated_at').notNull(),
+}, (table) => [uniqueIndex('idx_profiles_workspace_repo').on(table.workspace, table.repo)]);
+export const falsePositives = sqliteTable('false_positives', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    filePath: text('file_path').notNull(),
+    lineNumber: integer('line_number'),
+    category: text('category').notNull(),
+    agentId: text('agent_id'),
+    workspace: text('workspace').notNull(),
+    repo: text('repo').notNull(),
+    reason: text('reason'),
+    createdAt: text('created_at').notNull(),
+}, (table) => [index('idx_false_positives_workspace_repo').on(table.workspace, table.repo)]);
+export const knownWorkspaces = sqliteTable('known_workspaces', {
+    slug: text('slug').primaryKey(),
+    name: text('name').notNull(),
+    addedAt: text('added_at').notNull(),
+});
+export const projectContexts = sqliteTable('project_contexts', {
+    workspace: text('workspace').notNull(),
+    repo: text('repo').notNull(),
+    context: text('context').notNull(),
+    updatedAt: text('updated_at').notNull(),
+}, (table) => [primaryKey({ columns: [table.workspace, table.repo] })]);
+//# sourceMappingURL=schema.js.map

package/dist/persistence/schema.js.map

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

package/dist/persistence/workspace-repository.d.ts

@@ -0,0 +1,14 @@
+import type { DrizzleDb } from './database.js';
+export interface KnownWorkspace {
+    slug: string;
+    name: string;
+    addedAt: string;
+}
+export declare class WorkspaceRepository {
+    private readonly db;
+    constructor(db: DrizzleDb);
+    getAll(): KnownWorkspace[];
+    upsert(slug: string, name: string): void;
+    remove(slug: string): void;
+}
+//# sourceMappingURL=workspace-repository.d.ts.map

package/dist/persistence/workspace-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-repository.d.ts","sourceRoot":"","sources":["../../src/persistence/workspace-repository.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,mBAAmB;IAClB,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,SAAS;IAE1C,MAAM,IAAI,cAAc,EAAE;IAQ1B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAYxC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAG3B"}

package/dist/persistence/workspace-repository.js

@@ -0,0 +1,30 @@
+import { eq, asc } from 'drizzle-orm';
+import { knownWorkspaces } from './schema.js';
+export class WorkspaceRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getAll() {
+        return this.db
+            .select()
+            .from(knownWorkspaces)
+            .orderBy(asc(knownWorkspaces.name))
+            .all();
+    }
+    upsert(slug, name) {
+        const addedAt = new Date().toISOString();
+        this.db
+            .insert(knownWorkspaces)
+            .values({ slug, name, addedAt })
+            .onConflictDoUpdate({
+            target: knownWorkspaces.slug,
+            set: { name },
+        })
+            .run();
+    }
+    remove(slug) {
+        this.db.delete(knownWorkspaces).where(eq(knownWorkspaces.slug, slug)).run();
+    }
+}
+//# sourceMappingURL=workspace-repository.js.map

package/dist/persistence/workspace-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-repository.js","sourceRoot":"","sources":["../../src/persistence/workspace-repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAS9C,MAAM,OAAO,mBAAmB;IACD;IAA7B,YAA6B,EAAa;QAAb,OAAE,GAAF,EAAE,CAAW;IAAG,CAAC;IAE9C,MAAM;QACJ,OAAO,IAAI,CAAC,EAAE;aACX,MAAM,EAAE;aACR,IAAI,CAAC,eAAe,CAAC;aACrB,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;aAClC,GAAG,EAAE,CAAC;IACX,CAAC;IAED,MAAM,CAAC,IAAY,EAAE,IAAY;QAC/B,MAAM,OAAO,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACzC,IAAI,CAAC,EAAE;aACJ,MAAM,CAAC,eAAe,CAAC;aACvB,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;aAC/B,kBAAkB,CAAC;YAClB,MAAM,EAAE,eAAe,CAAC,IAAI;YAC5B,GAAG,EAAE,EAAE,IAAI,EAAE;SACd,CAAC;aACD,GAAG,EAAE,CAAC;IACX,CAAC;IAED,MAAM,CAAC,IAAY;QACjB,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;IAC9E,CAAC;CACF"}

package/dist/rules-engine/finding-aggregator.d.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from '../persistence/database.js';
+import type { AggregateOptions, AggregationResult } from './types.js';
+/**
+ * Normalize a finding title into a stable slug for grouping.
+ * Lowercase → replace non-alphanumeric with `-` → collapse → trim → truncate to 60.
+ */
+export declare function normalizeTitle(title: string): string;
+export declare class FindingAggregator {
+    private readonly db;
+    constructor(db: DrizzleDb);
+    aggregate(opts: AggregateOptions): AggregationResult;
+}
+//# sourceMappingURL=finding-aggregator.d.ts.map

package/dist/rules-engine/finding-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finding-aggregator.d.ts","sourceRoot":"","sources":["../../src/rules-engine/finding-aggregator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,KAAK,EAAE,gBAAgB,EAAqB,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAMzF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOpD;AAED,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,SAAS;IAE1C,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,iBAAiB;CA4HrD"}

package/dist/rules-engine/finding-aggregator.js

@@ -0,0 +1,135 @@
+import path from 'node:path';
+import { eq, and, desc, inArray } from 'drizzle-orm';
+import { reviewSessions, reviewFindings } from '../persistence/schema.js';
+import { SEVERITY_WEIGHTS } from './types.js';
+const VALID_SESSION_STATUSES = ['complete', 'draft', 'clean'];
+const DEFAULT_SESSION_LIMIT = 10;
+/**
+ * Normalize a finding title into a stable slug for grouping.
+ * Lowercase → replace non-alphanumeric with `-` → collapse → trim → truncate to 60.
+ */
+export function normalizeTitle(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 60);
+}
+export class FindingAggregator {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    aggregate(opts) {
+        const limit = opts.sessionLimit ?? DEFAULT_SESSION_LIMIT;
+        // Step 1: Find valid sessions for this workspace/repo
+        const sessions = this.db
+            .select({ id: reviewSessions.id })
+            .from(reviewSessions)
+            .where(and(eq(reviewSessions.workspace, opts.workspace), eq(reviewSessions.repo, opts.repo), inArray(reviewSessions.status, VALID_SESSION_STATUSES)))
+            .orderBy(desc(reviewSessions.createdAt))
+            .limit(limit)
+            .all();
+        if (sessions.length === 0) {
+            return { patterns: [], totalFindings: 0, sessionCount: 0 };
+        }
+        const sessionIds = sessions.map((s) => s.id);
+        // Step 2: Fetch all findings for those sessions
+        const findings = this.db
+            .select({
+            filePath: reviewFindings.filePath,
+            severity: reviewFindings.severity,
+            category: reviewFindings.category,
+            title: reviewFindings.title,
+            suggestion: reviewFindings.suggestion,
+            agentId: reviewFindings.agentId,
+        })
+            .from(reviewFindings)
+            .where(inArray(reviewFindings.sessionId, sessionIds))
+            .all();
+        if (findings.length === 0) {
+            return { patterns: [], totalFindings: 0, sessionCount: sessions.length };
+        }
+        // Step 3: Group in-memory by (agentId, category, normalizedTitle)
+        const groups = new Map();
+        for (const f of findings) {
+            const patternKey = normalizeTitle(f.title);
+            const groupKey = `${f.agentId}|${f.category}|${patternKey}`;
+            let group = groups.get(groupKey);
+            if (!group) {
+                group = {
+                    agentId: f.agentId,
+                    category: f.category,
+                    patternKey,
+                    titles: [],
+                    suggestions: [],
+                    severities: [],
+                    filePaths: new Set(),
+                };
+                groups.set(groupKey, group);
+            }
+            group.titles.push(f.title);
+            group.suggestions.push(f.suggestion);
+            group.severities.push(f.severity);
+            group.filePaths.add(f.filePath);
+        }
+        // Step 4: Build AggregatedPattern array
+        const patterns = [];
+        for (const group of groups.values()) {
+            const occurrences = group.titles.length;
+            // Pick highest severity
+            let severity = group.severities[0];
+            for (const s of group.severities) {
+                if (SEVERITY_WEIGHTS[s] > SEVERITY_WEIGHTS[severity])
+                    severity = s;
+            }
+            const score = occurrences * SEVERITY_WEIGHTS[severity];
+            // Most frequent title
+            const title = mostFrequent(group.titles);
+            const description = mostFrequent(group.suggestions);
+            // Derive fileGlobs from extensions
+            const exts = new Set();
+            for (const fp of group.filePaths) {
+                const ext = path.extname(fp);
+                if (ext)
+                    exts.add(`*${ext}`);
+            }
+            const fileGlobs = [...exts].sort();
+            patterns.push({
+                agentId: group.agentId,
+                category: group.category,
+                patternKey: group.patternKey,
+                title,
+                description,
+                severity,
+                occurrences,
+                score,
+                fileGlobs,
+            });
+        }
+        // Sort by score desc
+        patterns.sort((a, b) => b.score - a.score);
+        return {
+            patterns,
+            totalFindings: findings.length,
+            sessionCount: sessions.length,
+        };
+    }
+}
+/** Return the most frequent string in an array */
+function mostFrequent(arr) {
+    const counts = new Map();
+    let best = arr[0];
+    let bestCount = 0;
+    for (const s of arr) {
+        const c = (counts.get(s) ?? 0) + 1;
+        counts.set(s, c);
+        if (c > bestCount) {
+            bestCount = c;
+            best = s;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=finding-aggregator.js.map

package/dist/rules-engine/finding-aggregator.js.map

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

package/dist/rules-engine/pattern-generator.d.ts

@@ -0,0 +1,26 @@
+import type { AggregatedPattern } from './types.js';
+export interface LLMProvider {
+    analyze: (systemPrompt: string, userContent: string, options?: {
+        toolName?: string;
+        maxTokens?: number;
+    }) => Promise<string>;
+}
+export interface GenerateOptions {
+    workspace: string;
+    repo: string;
+    outputPath: string;
+    provider?: LLMProvider;
+    skipRuleGeneration?: boolean;
+}
+export interface GenerateResult {
+    patternsCount: number;
+    outputPath: string;
+    generatedAt: string;
+    rulesGenerated: number;
+    rulesSkipped: number;
+}
+export declare class PatternGenerator {
+    generate(patterns: AggregatedPattern[], opts: GenerateOptions): Promise<GenerateResult>;
+    private mergeWithExisting;
+}
+//# sourceMappingURL=pattern-generator.d.ts.map

package/dist/rules-engine/pattern-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-generator.d.ts","sourceRoot":"","sources":["../../src/rules-engine/pattern-generator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAmC,MAAM,YAAY,CAAC;AAGrF,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,CACP,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,KAChD,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,gBAAgB;IACrB,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,EAAE,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAwF7F,OAAO,CAAC,iBAAiB;CAqC1B"}

package/dist/rules-engine/pattern-generator.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildRuleGenerationPrompt, parseGeneratedRule, validateGeneratedRule } from './rule-prompt-builder.js';
+export class PatternGenerator {
+    async generate(patterns, opts) {
+        const generatedAt = new Date().toISOString();
+        const newPatterns = patterns.map((p) => ({
+            id: `${p.agentId}--${p.category}--${p.patternKey}`,
+            agentId: p.agentId,
+            category: p.category,
+            patternKey: p.patternKey,
+            title: p.title,
+            description: p.description,
+            severity: p.severity,
+            occurrences: p.occurrences,
+            score: p.score,
+            fileGlobs: p.fileGlobs,
+        }));
+        let rulesGenerated = 0;
+        let rulesSkipped = 0;
+        const shouldGenerateRules = opts.provider !== undefined && opts.skipRuleGeneration !== true;
+        if (shouldGenerateRules && opts.provider !== undefined) {
+            for (let i = 0; i < newPatterns.length; i++) {
+                const pattern = patterns[i];
+                const prismPattern = newPatterns[i];
+                if (pattern === undefined || prismPattern === undefined) {
+                    rulesSkipped++;
+                    continue;
+                }
+                try {
+                    const { systemPrompt, userContent } = buildRuleGenerationPrompt(pattern);
+                    const response = await opts.provider.analyze(systemPrompt, userContent, {
+                        toolName: 'generate_ast_grep_rule',
+                        maxTokens: 1024,
+                    });
+                    const parsed = parseGeneratedRule(response);
+                    if (parsed === null) {
+                        rulesSkipped++;
+                        continue;
+                    }
+                    const valid = await validateGeneratedRule(parsed);
+                    if (!valid) {
+                        rulesSkipped++;
+                        continue;
+                    }
+                    const confidence = parsed.confidence ?? 1.0;
+                    if (confidence < 0.3) {
+                        rulesSkipped++;
+                        continue;
+                    }
+                    prismPattern.language = parsed.language;
+                    prismPattern.rule = parsed.rule;
+                    rulesGenerated++;
+                }
+                catch {
+                    rulesSkipped++;
+                }
+            }
+        }
+        // Merge with existing file if present
+        const merged = this.mergeWithExisting(opts.outputPath, newPatterns);
+        const file = {
+            version: 2,
+            generatedAt,
+            source: { workspace: opts.workspace, repo: opts.repo },
+            patterns: merged,
+        };
+        // Ensure parent dir exists
+        fs.mkdirSync(path.dirname(opts.outputPath), { recursive: true });
+        fs.writeFileSync(opts.outputPath, JSON.stringify(file, null, 2), 'utf-8');
+        return {
+            patternsCount: merged.length,
+            outputPath: opts.outputPath,
+            generatedAt,
+            rulesGenerated,
+            rulesSkipped,
+        };
+    }
+    mergeWithExisting(outputPath, newPatterns) {
+        let existing = [];
+        try {
+            const raw = fs.readFileSync(outputPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if ((parsed.version === 1 || parsed.version === 2) && Array.isArray(parsed.patterns)) {
+                existing = parsed.patterns;
+            }
+        }
+        catch {
+            // File doesn't exist or is invalid — start fresh
+        }
+        // Build map: existing first, then upsert with new
+        const byId = new Map();
+        for (const p of existing) {
+            byId.set(p.id, p);
+        }
+        for (const p of newPatterns) {
+            const existingPattern = byId.get(p.id);
+            if (existingPattern !== undefined) {
+                // Preserve existing rule/language if the new pattern doesn't have them
+                const merged = { ...p };
+                if (merged.rule === undefined && existingPattern.rule !== undefined) {
+                    merged.rule = existingPattern.rule;
+                }
+                if (merged.language === undefined && existingPattern.language !== undefined) {
+                    merged.language = existingPattern.language;
+                }
+                byId.set(p.id, merged);
+            }
+            else {
+                byId.set(p.id, p);
+            }
+        }
+        return [...byId.values()];
+    }
+}
+//# sourceMappingURL=pattern-generator.js.map

package/dist/rules-engine/pattern-generator.js.map

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

package/dist/rules-engine/rule-prompt-builder.d.ts

@@ -0,0 +1,32 @@
+import type { AggregatedPattern, AstGrepRule, AstGrepLanguage } from './types.js';
+export interface RuleGenerationPrompt {
+    systemPrompt: string;
+    userContent: string;
+}
+export interface GeneratedRule {
+    language: AstGrepLanguage;
+    rule: AstGrepRule;
+    confidence?: number;
+}
+/** All supported AstGrepLanguage values as strings for runtime validation. */
+export declare const SUPPORTED_LANGUAGES: Set<string>;
+/**
+ * Build the system prompt and user content for asking an LLM to generate
+ * an ast-grep rule from an aggregated pattern.
+ */
+export declare function buildRuleGenerationPrompt(pattern: AggregatedPattern): RuleGenerationPrompt;
+/**
+ * Parse the raw LLM response into a GeneratedRule.
+ * Strips markdown code fences, validates language and rule fields.
+ * Returns null if parsing or validation fails.
+ */
+export declare function parseGeneratedRule(raw: string): GeneratedRule | null;
+/**
+ * Validate a generated rule by running it through ast-grep parse against
+ * a trivial TypeScript snippet. Returns true if no exception is thrown.
+ *
+ * Uses a minimal local LANG_MAP to avoid circular dependencies with
+ * ast-grep-strategy.
+ */
+export declare function validateGeneratedRule(generated: GeneratedRule): Promise<boolean>;
+//# sourceMappingURL=rule-prompt-builder.d.ts.map

package/dist/rules-engine/rule-prompt-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-prompt-builder.d.ts","sourceRoot":"","sources":["../../src/rules-engine/rule-prompt-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElF,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,eAAe,CAAC;IAC1B,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAI1C,CAAC;AAEH;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAoC1F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAwCpE;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAgCtF"}

package/dist/rules-engine/rule-prompt-builder.js

@@ -0,0 +1,124 @@
+/** All supported AstGrepLanguage values as strings for runtime validation. */
+export const SUPPORTED_LANGUAGES = new Set([
+    'typescript', 'javascript', 'tsx', 'jsx',
+    'php', 'python', 'css', 'html',
+    'go', 'java', 'c-sharp', 'rust', 'c', 'cpp',
+]);
+/**
+ * Build the system prompt and user content for asking an LLM to generate
+ * an ast-grep rule from an aggregated pattern.
+ */
+export function buildRuleGenerationPrompt(pattern) {
+    const systemPrompt = `You are an expert at writing ast-grep structural search rules.
+ast-grep uses a YAML rule schema for structural code search. You must output a single JSON object.
+
+Rule syntax examples:
+
+Example 1 — selectSnapshot followed by map:
+{ "pattern": "$X.selectSnapshot($$$).map($$$)" }
+
+Example 2 — console.log left in production:
+{ "any": [{ "pattern": "console.log($$$)" }, { "pattern": "console.warn($$$)" }, { "pattern": "console.error($$$)" }] }
+
+Example 3 — TODO/FIXME comments:
+{ "kind": "comment", "regex": "TODO|FIXME|HACK|XXX" }
+
+Available rule operators: pattern, kind, regex, any, all, not, has, inside, follows, precedes.
+Wildcards: $X matches one node, $$$ matches zero or more nodes.
+
+Return ONLY valid JSON in this exact shape — no markdown, no explanation:
+{ "language": "<lang>", "rule": <rule-object>, "confidence": <0.0-1.0> }
+
+Supported languages: typescript, javascript, tsx, jsx, php, python, css, html, go, java, c-sharp, rust, c, cpp.`;
+    const globsText = pattern.fileGlobs.length > 0
+        ? pattern.fileGlobs.join(', ')
+        : '(no globs specified)';
+    const userContent = `Generate an ast-grep rule for the following code pattern:
+
+Title: ${pattern.title}
+Category: ${pattern.category}
+Severity: ${pattern.severity}
+File globs: ${globsText}
+Description: ${pattern.description}`;
+    return { systemPrompt, userContent };
+}
+/**
+ * Parse the raw LLM response into a GeneratedRule.
+ * Strips markdown code fences, validates language and rule fields.
+ * Returns null if parsing or validation fails.
+ */
+export function parseGeneratedRule(raw) {
+    // Extract JSON from markdown code fences or raw text
+    // Handles: ```json\n{...}\n```\n...extra text...
+    const fenceMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/i);
+    const stripped = fenceMatch !== null
+        ? fenceMatch[1].trim()
+        : raw.trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(stripped);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        return null;
+    }
+    const obj = parsed;
+    // Validate language
+    const language = obj['language'];
+    if (typeof language !== 'string' || !SUPPORTED_LANGUAGES.has(language)) {
+        return null;
+    }
+    // Validate rule is a non-null object
+    const rule = obj['rule'];
+    if (rule === null || rule === undefined || typeof rule !== 'object') {
+        return null;
+    }
+    const confidence = typeof obj['confidence'] === 'number' ? obj['confidence'] : undefined;
+    return {
+        language: language,
+        rule: rule,
+        ...(confidence !== undefined ? { confidence } : {}),
+    };
+}
+/**
+ * Validate a generated rule by running it through ast-grep parse against
+ * a trivial TypeScript snippet. Returns true if no exception is thrown.
+ *
+ * Uses a minimal local LANG_MAP to avoid circular dependencies with
+ * ast-grep-strategy.
+ */
+export async function validateGeneratedRule(generated) {
+    // Minimal lang map — only the subset ast-grep/napi exposes as Lang enum
+    const LANG_MAP = {
+        typescript: 'TypeScript',
+        javascript: 'JavaScript',
+        tsx: 'Tsx',
+        jsx: 'JavaScript',
+        css: 'Css',
+        html: 'Html',
+        python: 'Python',
+        go: 'Go',
+        java: 'Java',
+        rust: 'Rust',
+        c: 'C',
+        cpp: 'Cpp',
+        php: 'Php',
+        'c-sharp': 'CSharp',
+    };
+    const nativeLang = LANG_MAP[generated.language];
+    if (nativeLang === undefined) {
+        return false;
+    }
+    try {
+        const { parse } = await import('@ast-grep/napi');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        parse(nativeLang, 'const x = 1;').root().findAll({ rule: generated.rule });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=rule-prompt-builder.js.map

package/dist/rules-engine/rule-prompt-builder.js.map

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