nuclie 1.0.0

package/dist/ai/reporter/generator.js

@@ -0,0 +1,42 @@
+export class ReportGenerator {
+    static generate(session) {
+        const status = session.success ? '✅ SUCCESS' : '❌ FAILED';
+        const duration = (session.duration / 1000).toFixed(2);
+        const date = new Date(session.timestamp).toLocaleString();
+        let report = `# Build Report\n\n`;
+        report += `**Status**: ${status}\n`;
+        report += `**Date**: ${date}\n`;
+        report += `**Duration**: ${duration}s\n\n`;
+        // Metrics
+        if (session.metrics) {
+            report += `## Metrics\n`;
+            if (session.metrics.modules)
+                report += `- **Modules**: ${session.metrics.modules}\n`;
+            if (session.metrics.bundleSize)
+                report += `- **Bundle Size**: ${(session.metrics.bundleSize / 1024).toFixed(2)} KB\n`;
+            if (session.metrics.cacheHits)
+                report += `- **Cache Hits**: ${session.metrics.cacheHits}\n`;
+            report += `\n`;
+        }
+        // Errors
+        if (session.errors && session.errors.length > 0) {
+            report += `## Errors\n`;
+            session.errors.forEach(err => {
+                report += `> 🔴 ${err}\n`;
+            });
+            report += `\n`;
+        }
+        // Insights (Simple heuristics for now, LLM later)
+        report += `## Insights\n`;
+        if (session.duration > 5000) {
+            report += `- 🐢 Build took longer than 5s. Consider enabling code splitting or caching.\n`;
+        }
+        else {
+            report += `- ⚡ Fast build! Keep it up.\n`;
+        }
+        if (session.metrics?.bundleSize && session.metrics.bundleSize > 1024 * 1024) {
+            report += `- 📦 Bundle is large (>1MB). Run \`nuclie optimize\` to analyze.\n`;
+        }
+        return report;
+    }
+}

package/dist/ai/reporter/narrator.d.ts

@@ -0,0 +1,8 @@
+import { FullBuildReport } from './assembler.js';
+import { AIConfig } from '../config.js';
+export declare class LLMNarrator {
+    private config;
+    constructor(config: AIConfig);
+    narrate(report: FullBuildReport): Promise<string>;
+    private generateLocalSummary;
+}

package/dist/ai/reporter/narrator.js

@@ -0,0 +1,29 @@
+export class LLMNarrator {
+    constructor(config) {
+        this.config = config;
+    }
+    async narrate(report) {
+        if (!this.config.enabled || this.config.provider === 'local') {
+            return this.generateLocalSummary(report);
+        }
+        // TODO: Call Cloud LLM
+        return this.generateLocalSummary(report);
+    }
+    generateLocalSummary(report) {
+        const { session, trends, audits } = report;
+        let summary = `Build ${session.success ? 'Succeeded' : 'Failed'} in ${(session.duration / 1000).toFixed(2)}s.`;
+        if (trends) {
+            if (trends.durationDelta < 0)
+                summary += ` 🚀 Faster by ${Math.abs(trends.durationDelta / 1000).toFixed(2)}s.`;
+            if (trends.sizeDelta < 0)
+                summary += ` 📉 Bundle size decreased by ${(Math.abs(trends.sizeDelta) / 1024).toFixed(2)}KB.`;
+        }
+        if (audits) {
+            const score = ((audits.groups.a11y?.score || 0) +
+                (audits.groups.perf?.score || 0) +
+                (audits.groups.seo?.score || 0)) / 3;
+            summary += `\nAudit Score: ${score.toFixed(0)}/100.`;
+        }
+        return summary;
+    }
+}

package/dist/ai/schema.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+export declare const ProjectProfileSchema: z.ZodObject<{
+    framework: z.ZodOptional<z.ZodString>;
+    cssFramework: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodEnum<{
+        typescript: "typescript";
+        javascript: "javascript";
+    }>>;
+    packageManager: z.ZodOptional<z.ZodEnum<{
+        bun: "bun";
+        npm: "npm";
+        yarn: "yarn";
+        pnpm: "pnpm";
+    }>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    configSummary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    size: z.ZodOptional<z.ZodObject<{
+        totalJs: z.ZodOptional<z.ZodNumber>;
+        vendorChunk: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    entries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        hitRate: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ProjectProfile = z.infer<typeof ProjectProfileSchema>;
+export declare const BuildSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    duration: z.ZodNumber;
+    success: z.ZodBoolean;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        modules: z.ZodOptional<z.ZodNumber>;
+        bundleSize: z.ZodOptional<z.ZodNumber>;
+        cacheHits: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BuildSession = z.infer<typeof BuildSessionSchema>;
+export declare const AIRequestSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        optimize: "optimize";
+        fix: "fix";
+        report: "report";
+        chat: "chat";
+    }>;
+    context: z.ZodObject<{
+        project: z.ZodOptional<z.ZodObject<{
+            framework: z.ZodOptional<z.ZodString>;
+            cssFramework: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodEnum<{
+                typescript: "typescript";
+                javascript: "javascript";
+            }>>;
+            packageManager: z.ZodOptional<z.ZodEnum<{
+                bun: "bun";
+                npm: "npm";
+                yarn: "yarn";
+                pnpm: "pnpm";
+            }>>;
+            dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            configSummary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            size: z.ZodOptional<z.ZodObject<{
+                totalJs: z.ZodOptional<z.ZodNumber>;
+                vendorChunk: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            entries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            cache: z.ZodOptional<z.ZodObject<{
+                hitRate: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        session: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            timestamp: z.ZodNumber;
+            duration: z.ZodNumber;
+            success: z.ZodBoolean;
+            errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            metrics: z.ZodOptional<z.ZodObject<{
+                modules: z.ZodOptional<z.ZodNumber>;
+                bundleSize: z.ZodOptional<z.ZodNumber>;
+                cacheHits: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        query: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    preferences: z.ZodOptional<z.ZodObject<{
+        model: z.ZodDefault<z.ZodEnum<{
+            cloud: "cloud";
+            local: "local";
+        }>>;
+        privacy: z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            high: "high";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AIRequest = z.infer<typeof AIRequestSchema>;

package/dist/ai/schema.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export const ProjectProfileSchema = z.object({
+    framework: z.string().optional(),
+    cssFramework: z.string().optional(),
+    language: z.enum(['typescript', 'javascript']).optional(),
+    packageManager: z.enum(['npm', 'yarn', 'pnpm', 'bun']).optional(),
+    dependencies: z.record(z.string(), z.string()).optional(),
+    devDependencies: z.record(z.string(), z.string()).optional(),
+    configSummary: z.record(z.string(), z.any()).optional(),
+    size: z.object({
+        totalJs: z.number().optional(),
+        vendorChunk: z.number().optional(),
+    }).optional(),
+    entries: z.array(z.string()).optional(),
+    cache: z.object({
+        hitRate: z.number().optional(),
+    }).optional(),
+    warnings: z.array(z.string()).optional(),
+});
+export const BuildSessionSchema = z.object({
+    id: z.string(),
+    timestamp: z.number(),
+    duration: z.number(),
+    success: z.boolean(),
+    errors: z.array(z.string()).optional(),
+    warnings: z.array(z.string()).optional(),
+    metrics: z.object({
+        modules: z.number().optional(),
+        bundleSize: z.number().optional(),
+        cacheHits: z.number().optional(),
+    }).optional(),
+});
+export const AIRequestSchema = z.object({
+    type: z.enum(['fix', 'optimize', 'report', 'chat']),
+    context: z.object({
+        project: ProjectProfileSchema.optional(),
+        session: BuildSessionSchema.optional(),
+        files: z.record(z.string(), z.string()).optional(), // filename -> content snippet
+        query: z.string().optional(),
+    }),
+    preferences: z.object({
+        model: z.enum(['cloud', 'local']).default('cloud'),
+        privacy: z.enum(['high', 'low']).default('high'),
+    }).optional(),
+});

package/dist/ai/telemetry.d.ts

@@ -0,0 +1,14 @@
+import { BuildSession } from './schema.js';
+export declare class Telemetry {
+    private session;
+    private telemetryDir;
+    constructor(rootDir: string);
+    init(): Promise<void>;
+    start(): void;
+    stop(success: boolean, metrics?: BuildSession['metrics'], errors?: string[]): Promise<void>;
+    private save;
+    static anonymize(text: string, root: string): string;
+    static getLatestSession(rootDir: string): Promise<BuildSession | null>;
+    static getSessions(rootDir: string, limit?: number): Promise<BuildSession[]>;
+    static getTrends(rootDir: string, currentSession: BuildSession): Promise<any>;
+}

package/dist/ai/telemetry.js

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { log } from '../utils/logger.js';
+export class Telemetry {
+    constructor(rootDir) {
+        this.telemetryDir = path.join(rootDir, '.nuclie', 'telemetry');
+        this.session = {
+            id: crypto.randomUUID(),
+            timestamp: Date.now(),
+            duration: 0,
+            success: false,
+            metrics: {}
+        };
+    }
+    async init() {
+        await fs.mkdir(this.telemetryDir, { recursive: true });
+    }
+    start() {
+        this.session.timestamp = Date.now();
+    }
+    async stop(success, metrics = {}, errors = []) {
+        this.session.duration = Date.now() - this.session.timestamp;
+        this.session.success = success;
+        this.session.metrics = metrics;
+        this.session.errors = errors;
+        await this.save();
+    }
+    async save() {
+        try {
+            const filename = `session-${this.session.timestamp}.json`;
+            const filePath = path.join(this.telemetryDir, filename);
+            await fs.writeFile(filePath, JSON.stringify(this.session, null, 2));
+            log.debug(`Telemetry saved to ${filename}`, { category: 'ai' });
+        }
+        catch (e) {
+            log.warn('Failed to save telemetry', { error: e });
+        }
+    }
+    // Helper to anonymize paths
+    static anonymize(text, root) {
+        return text.replace(new RegExp(root, 'g'), '<PROJECT_ROOT>');
+    }
+    static async getLatestSession(rootDir) {
+        const telemetryDir = path.join(rootDir, '.nuclie', 'telemetry');
+        try {
+            const files = await fs.readdir(telemetryDir);
+            if (files.length === 0)
+                return null;
+            // Sort by timestamp (filename has timestamp)
+            files.sort().reverse();
+            const latest = files[0];
+            const content = await fs.readFile(path.join(telemetryDir, latest), 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    static async getSessions(rootDir, limit = 10) {
+        const telemetryDir = path.join(rootDir, '.nuclie', 'telemetry');
+        try {
+            const files = await fs.readdir(telemetryDir);
+            if (files.length === 0)
+                return [];
+            // Sort by timestamp (filename has timestamp)
+            files.sort().reverse();
+            const recent = files.slice(0, limit);
+            const sessions = [];
+            for (const file of recent) {
+                const content = await fs.readFile(path.join(telemetryDir, file), 'utf-8');
+                sessions.push(JSON.parse(content));
+            }
+            return sessions;
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    static async getTrends(rootDir, currentSession) {
+        const sessions = await Telemetry.getSessions(rootDir, 5);
+        if (sessions.length === 0)
+            return null;
+        // Filter out the current session if it's in the list (unlikely if we just started, but good safety)
+        const previousSessions = sessions.filter(s => s.id !== currentSession.id);
+        if (previousSessions.length === 0)
+            return null;
+        const last = previousSessions[0];
+        return {
+            durationDelta: currentSession.duration - last.duration,
+            sizeDelta: (currentSession.metrics?.bundleSize || 0) - (last.metrics?.bundleSize || 0),
+            modulesDelta: (currentSession.metrics?.modules || 0) - (last.metrics?.modules || 0),
+            successRate: previousSessions.filter(s => s.success).length / previousSessions.length
+        };
+    }
+}

package/dist/audit/a11y.d.ts

@@ -0,0 +1,5 @@
+import { Page } from 'puppeteer';
+import { AuditGroup, AuditContext } from './types.js';
+export declare class AccessibilityAudit {
+    static run(page: Page, context?: AuditContext): Promise<AuditGroup>;
+}

package/dist/audit/a11y.js

@@ -0,0 +1,123 @@
+import axe from 'axe-core';
+import path from 'path';
+export class AccessibilityAudit {
+    static async run(page, context) {
+        const results = [];
+        // Inject axe-core into the page
+        try {
+            await page.addScriptTag({
+                path: path.join(process.cwd(), 'node_modules/axe-core/axe.min.js')
+            });
+            // Run axe-core automated tests
+            const axeResults = await page.evaluate(async () => {
+                // @ts-ignore - axe is injected
+                return await axe.run({
+                    runOnly: {
+                        type: 'tag',
+                        values: ['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa', 'best-practice']
+                    }
+                });
+            });
+            // Process axe-core violations
+            for (const violation of axeResults.violations) {
+                const severity = violation.impact === 'critical' || violation.impact === 'serious' ? 'FAIL' : 'WARN';
+                const score = severity === 'FAIL' ? 0 : 50;
+                results.push({
+                    id: `axe-${violation.id}`,
+                    title: violation.help,
+                    status: severity,
+                    score,
+                    details: `${violation.description}\nAffected elements: ${violation.nodes.length}\n${violation.nodes.slice(0, 3).map((n) => n.html).join('\n')}`,
+                    fix: violation.helpUrl
+                });
+            }
+        }
+        catch (error) {
+            // If axe-core fails, continue with basic checks
+            console.warn('axe-core integration failed:', error.message);
+        }
+        // 1. HTML Lang Attribute
+        const lang = await page.$eval('html', el => el.getAttribute('lang')).catch(() => null);
+        results.push({
+            id: 'html-lang',
+            title: 'HTML has lang attribute',
+            status: lang ? 'PASS' : 'FAIL',
+            score: lang ? 100 : 0,
+            details: lang ? `Lang attribute found: "${lang}"` : 'Missing lang attribute on <html>',
+            fix: 'Add lang="en" (or appropriate language code) to <html> tag'
+        });
+        // 2. Images have alt text
+        const failingImages = await page.$$eval('img', els => {
+            return els
+                .filter(el => !el.hasAttribute('alt') || el.getAttribute('alt') === '')
+                .map(el => {
+                const src = el.getAttribute('src') || 'unknown';
+                const snippet = el.outerHTML.substring(0, 50) + '...';
+                return `Image: ${src} (Snippet: ${snippet})`;
+            })
+                .slice(0, 5);
+        });
+        results.push({
+            id: 'img-alt',
+            title: 'Images have alt text',
+            status: failingImages.length === 0 ? 'PASS' : 'WARN',
+            score: failingImages.length === 0 ? 100 : 50,
+            details: failingImages.length === 0
+                ? 'All images have alt text'
+                : `Found images missing alt text:\n      ` + failingImages.join('\n      '),
+            fix: 'Add descriptive alt="" attributes to all <img> tags'
+        });
+        // 3. Buttons have name/label
+        const failingButtons = await page.$$eval('button', els => {
+            return els.filter(el => {
+                const text = el.innerText.trim();
+                const ariaLabel = el.getAttribute('aria-label');
+                const ariaLabelledBy = el.getAttribute('aria-labelledby');
+                return !text && !ariaLabel && !ariaLabelledBy;
+            }).map(el => {
+                const id = el.id ? `#${el.id}` : '';
+                const cls = el.className ? `.${el.className.split(' ').join('.')}` : '';
+                return `Button: ${el.tagName.toLowerCase()}${id}${cls} (Snippet: ${el.outerHTML.substring(0, 50)}...)`;
+            }).slice(0, 5);
+        });
+        results.push({
+            id: 'button-name',
+            title: 'Buttons have discernible text',
+            status: failingButtons.length === 0 ? 'PASS' : 'FAIL',
+            score: failingButtons.length === 0 ? 100 : 0,
+            details: failingButtons.length === 0
+                ? 'All buttons have text or aria-labels'
+                : `Found buttons missing text/label:\n      ` + failingButtons.join('\n      '),
+            fix: 'Add text content or aria-label to all <button> elements'
+        });
+        // 4. Form inputs have labels
+        const failingInputs = await page.evaluate(() => {
+            const inputs = Array.from(document.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"])'));
+            return inputs.filter(input => {
+                const id = input.id;
+                const hasLabel = id && document.querySelector(`label[for="${id}"]`);
+                const hasAria = input.hasAttribute('aria-label') || input.hasAttribute('aria-labelledby');
+                return !hasLabel && !hasAria;
+            }).map(input => {
+                const i = input;
+                return `Input: type="${i.type}" name="${i.name}" id="${i.id}"`;
+            }).slice(0, 5);
+        });
+        results.push({
+            id: 'input-label',
+            title: 'Form elements have labels',
+            status: failingInputs.length === 0 ? 'PASS' : 'WARN',
+            score: failingInputs.length === 0 ? 100 : 50,
+            details: failingInputs.length === 0
+                ? 'All inputs have associated labels'
+                : `Found inputs missing labels:\n      ` + failingInputs.join('\n      '),
+            fix: 'Add <label for="input-id"> or aria-label to all form inputs'
+        });
+        const score = Math.round(results.reduce((acc, r) => acc + r.score, 0) / results.length);
+        return {
+            name: 'Accessibility',
+            results,
+            score
+        };
+    }
+}

package/dist/audit/best-practices.d.ts

@@ -0,0 +1,5 @@
+import { Page } from 'puppeteer';
+import { AuditGroup, AuditContext } from './types.js';
+export declare class BestPracticesAudit {
+    static run(page: Page, context?: AuditContext): Promise<AuditGroup>;
+}

package/dist/audit/best-practices.js

@@ -0,0 +1,68 @@
+export class BestPracticesAudit {
+    static async run(page, context) {
+        const results = [];
+        // 1. Doctype
+        const hasDoctype = await page.evaluate(() => document.doctype !== null);
+        results.push({
+            id: 'doctype',
+            title: 'Uses HTML5 Doctype',
+            status: hasDoctype ? 'PASS' : 'FAIL',
+            score: hasDoctype ? 100 : 0,
+            details: hasDoctype ? 'Page has a DOCTYPE' : 'Missing DOCTYPE'
+        });
+        // 2. HTTPS (Skip for localhost)
+        const url = page.url();
+        const isLocal = url.includes('localhost') || url.includes('127.0.0.1');
+        const isHttps = url.startsWith('https:');
+        results.push({
+            id: 'https',
+            title: 'Uses HTTPS',
+            status: isHttps || isLocal ? 'PASS' : 'WARN',
+            score: isHttps || isLocal ? 100 : 50,
+            details: isHttps ? 'Secure (HTTPS)' : isLocal ? 'Localhost (HTTP allowed)' : 'Insecure (HTTP)'
+        });
+        // 3. Safe External Links
+        // Check a[target="_blank"] for rel="noopener" or "noreferrer"
+        const unsafeLinks = await page.$$eval('a[target="_blank"]', els => {
+            return els.filter(el => {
+                const rel = el.getAttribute('rel') || '';
+                return !rel.includes('noopener') && !rel.includes('noreferrer');
+            }).map(el => {
+                return `Link: ${el.innerText.substring(0, 20)} -> ${el.getAttribute('href')}`;
+            }).slice(0, 5);
+        });
+        results.push({
+            id: 'safe-links',
+            title: 'Safe External Links',
+            status: unsafeLinks.length === 0 ? 'PASS' : 'WARN',
+            score: unsafeLinks.length === 0 ? 100 : 50,
+            details: unsafeLinks.length === 0
+                ? 'All external links are safe'
+                : `Unsafe links (missing rel="noopener"):\n      ` + unsafeLinks.join('\n      ')
+        });
+        // 4. Image Aspect Ratio
+        const invalidImages = await page.$$eval('img', els => {
+            return els.filter(el => !el.hasAttribute('width') || !el.hasAttribute('height'))
+                .map(el => {
+                const src = el.getAttribute('src');
+                return `Image: ${src}`;
+            })
+                .slice(0, 5);
+        });
+        results.push({
+            id: 'image-dimensions',
+            title: 'Image Dimensions',
+            status: invalidImages.length === 0 ? 'PASS' : 'WARN',
+            score: invalidImages.length === 0 ? 100 : 70,
+            details: invalidImages.length === 0
+                ? 'All images have width/height'
+                : `Images missing dimensions:\n      ` + invalidImages.join('\n      ')
+        });
+        const score = Math.round(results.reduce((acc, r) => acc + r.score, 0) / results.length);
+        return {
+            name: 'Best Practices',
+            results,
+            score
+        };
+    }
+}

package/dist/audit/build-integration.d.ts

@@ -0,0 +1,59 @@
+import type { BuildContext } from '../core/engine/types.js';
+import type { Warning } from '../ui/types.js';
+/**
+ * Build-Time Integration
+ * Integrates auditing, warnings, and auto-fixes into the build pipeline
+ */
+export interface BuildIntegrationConfig {
+    enableWarnings: boolean;
+    enableAutoFix: boolean;
+    enableIncrementalAudit: boolean;
+    autoFixThreshold: number;
+    ciThresholds?: {
+        criticalMax: number;
+        warningMax: number;
+        failOnCritical: boolean;
+    };
+    skipAudit?: boolean;
+    forceAudit?: boolean;
+}
+export interface AuditResult {
+    warnings: Warning[];
+    fixesApplied: number;
+    buildTime: number;
+    cacheHits: number;
+}
+export declare class BuildIntegration {
+    private config;
+    private warningDetector;
+    private autoFixEngine;
+    private auditCache;
+    constructor(config?: Partial<BuildIntegrationConfig>);
+    /**
+     * Run audit pipeline hook
+     */
+    runAuditPipeline(ctx: BuildContext): Promise<AuditResult>;
+    /**
+     * Check if warnings exceed CI thresholds
+     */
+    private checkCIThresholds;
+    /**
+     * Incremental audit for changed files
+     */
+    incrementalAudit(ctx: BuildContext, changedFiles: string[]): Promise<AuditResult>;
+    /**
+     * Generate cache key for audit results
+     */
+    private generateCacheKey;
+    /**
+     * Clear audit cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        hitRate: number;
+    };
+}