nuclie 1.0.0

package/dist/ai/local/fixStore.js

@@ -0,0 +1,105 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs';
+export class FixStore {
+    constructor(rootDir) {
+        const dbDir = path.join(rootDir, '.nuclie');
+        if (!fs.existsSync(dbDir)) {
+            fs.mkdirSync(dbDir, { recursive: true });
+        }
+        this.db = new Database(path.join(dbDir, 'ai-fixes.db'));
+        this.init();
+    }
+    init() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS errors (
+                id TEXT PRIMARY KEY,
+                signature TEXT,
+                type TEXT,
+                context TEXT,
+                timestamp INTEGER
+            );
+            CREATE TABLE IF NOT EXISTS fixes (
+                id TEXT PRIMARY KEY,
+                error_id TEXT,
+                recipe TEXT,
+                success_count INTEGER DEFAULT 0,
+                fail_count INTEGER DEFAULT 0,
+                last_used INTEGER,
+                FOREIGN KEY(error_id) REFERENCES errors(id)
+            );
+        `);
+    }
+    saveError(error) {
+        const stmt = this.db.prepare(`
+            INSERT OR IGNORE INTO errors (id, signature, type, context, timestamp)
+            VALUES (?, ?, ?, ?, ?)
+        `);
+        stmt.run(error.id, error.signature, error.type, JSON.stringify(error.context), error.timestamp);
+    }
+    saveFix(errorId, fix) {
+        const fixId = this.generateFixId(errorId, fix);
+        const stmt = this.db.prepare(`
+            INSERT OR IGNORE INTO fixes (id, error_id, recipe, last_used)
+            VALUES (?, ?, ?, ?)
+        `);
+        stmt.run(fixId, errorId, JSON.stringify(fix), Date.now());
+        return fixId;
+    }
+    findFixes(errorId) {
+        // Score = (success / (success + fail + 1)) * log(last_used)
+        // This favors successful fixes, but also gives a slight boost to recently used ones
+        const stmt = this.db.prepare(`
+            SELECT recipe, success_count, fail_count 
+            FROM fixes 
+            WHERE error_id = ? 
+        `);
+        const rows = stmt.all(errorId);
+        return rows.sort((a, b) => {
+            const scoreA = this.calculateScore(a.success_count, a.fail_count);
+            const scoreB = this.calculateScore(b.success_count, b.fail_count);
+            return scoreB - scoreA;
+        }).map(row => JSON.parse(row.recipe));
+    }
+    calculateScore(success, fail) {
+        const total = success + fail;
+        if (total === 0)
+            return 0;
+        return success / total; // Simple ratio for now
+    }
+    recordOutcome(fixId, success) {
+        const stmt = this.db.prepare(`
+            UPDATE fixes 
+            SET success_count = success_count + ?,
+                fail_count = fail_count + ?,
+                last_used = ?
+            WHERE id = ?
+        `);
+        stmt.run(success ? 1 : 0, success ? 0 : 1, Date.now(), fixId);
+    }
+    generateFixId(errorId, fix) {
+        // Simple hash of errorId + fix content
+        const content = errorId + JSON.stringify(fix);
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return Math.abs(hash).toString(16);
+    }
+    getStats() {
+        const errorCount = this.db.prepare('SELECT COUNT(*) as c FROM errors').get();
+        const fixCount = this.db.prepare('SELECT COUNT(*) as c FROM fixes').get();
+        const successCount = this.db.prepare('SELECT SUM(success_count) as c FROM fixes').get();
+        return {
+            errors: errorCount.c,
+            fixes: fixCount.c,
+            successfulFixes: successCount.c || 0
+        };
+    }
+    deleteError(errorId) {
+        this.db.prepare('DELETE FROM fixes WHERE error_id = ?').run(errorId);
+        this.db.prepare('DELETE FROM errors WHERE id = ?').run(errorId);
+    }
+}

package/dist/ai/optimizer/analyzer.d.ts

@@ -0,0 +1,9 @@
+import { ProjectProfile } from '../schema.js';
+export declare class Analyzer {
+    private root;
+    constructor(root: string);
+    analyze(): Promise<ProjectProfile>;
+    private detectFramework;
+    private detectLanguage;
+    private detectPackageManager;
+}

package/dist/ai/optimizer/analyzer.js

@@ -0,0 +1,65 @@
+import fs from 'fs/promises';
+import path from 'path';
+export class Analyzer {
+    constructor(root) {
+        this.root = root;
+    }
+    async analyze() {
+        const pkgPath = path.join(this.root, 'package.json');
+        let pkg = {};
+        try {
+            const content = await fs.readFile(pkgPath, 'utf-8');
+            pkg = JSON.parse(content);
+        }
+        catch (e) {
+            // Ignore missing package.json
+        }
+        return {
+            framework: this.detectFramework(pkg),
+            language: await this.detectLanguage(),
+            packageManager: await this.detectPackageManager(),
+            dependencies: pkg.dependencies || {},
+            devDependencies: pkg.devDependencies || {},
+            configSummary: {} // TODO: Parse nuclie.config.ts
+        };
+    }
+    detectFramework(pkg) {
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['react'])
+            return 'react';
+        if (deps['vue'])
+            return 'vue';
+        if (deps['svelte'])
+            return 'svelte';
+        if (deps['@angular/core'])
+            return 'angular';
+        return 'unknown';
+    }
+    async detectLanguage() {
+        try {
+            await fs.access(path.join(this.root, 'tsconfig.json'));
+            return 'typescript';
+        }
+        catch {
+            return 'javascript';
+        }
+    }
+    async detectPackageManager() {
+        try {
+            await fs.access(path.join(this.root, 'yarn.lock'));
+            return 'yarn';
+        }
+        catch { }
+        try {
+            await fs.access(path.join(this.root, 'pnpm-lock.yaml'));
+            return 'pnpm';
+        }
+        catch { }
+        try {
+            await fs.access(path.join(this.root, 'bun.lockb'));
+            return 'bun';
+        }
+        catch { }
+        return 'npm';
+    }
+}

package/dist/ai/optimizer/engine.d.ts

@@ -0,0 +1,16 @@
+import { ProjectProfile } from '../schema.js';
+export interface Suggestion {
+    id: string;
+    title: string;
+    description: string;
+    impact: 'HIGH' | 'MEDIUM' | 'LOW';
+    confidence: number;
+    action: {
+        type: 'CONFIG_UPDATE';
+        path: string;
+        value: any;
+    };
+}
+export declare class OptimizerEngine {
+    static suggest(profile: ProjectProfile): Suggestion[];
+}

package/dist/ai/optimizer/engine.js

@@ -0,0 +1,51 @@
+export class OptimizerEngine {
+    static suggest(profile) {
+        const suggestions = [];
+        // Rule 1: Code Splitting for React
+        if (profile.framework === 'react') {
+            suggestions.push({
+                id: 'react-split',
+                title: 'Enable React Code Splitting',
+                description: 'Split vendor chunks for better caching.',
+                impact: 'HIGH',
+                confidence: 0.9,
+                action: {
+                    type: 'CONFIG_UPDATE',
+                    path: 'build.splitting',
+                    value: true
+                }
+            });
+        }
+        // Rule 2: CSS Purging (Tailwind)
+        if (profile.devDependencies && profile.devDependencies['tailwindcss']) {
+            suggestions.push({
+                id: 'tailwind-purge',
+                title: 'Enable CSS Purging',
+                description: 'Remove unused Tailwind classes.',
+                impact: 'HIGH',
+                confidence: 0.95,
+                action: {
+                    type: 'CONFIG_UPDATE',
+                    path: 'css.purge',
+                    value: true
+                }
+            });
+        }
+        // Rule 3: TypeScript Strict Mode
+        if (profile.language === 'typescript') {
+            suggestions.push({
+                id: 'ts-strict',
+                title: 'Enable Strict Mode',
+                description: 'Catch more errors at compile time.',
+                impact: 'MEDIUM',
+                confidence: 0.8,
+                action: {
+                    type: 'CONFIG_UPDATE',
+                    path: 'typescript.strict',
+                    value: true
+                }
+            });
+        }
+        return suggestions;
+    }
+}

package/dist/ai/optimizer/llm.d.ts

@@ -0,0 +1,8 @@
+import { ProjectProfile } from '../schema.js';
+import { OptimizationSuggestion } from './rules.js';
+import { AIConfig } from '../config.js';
+export declare class LLMAdapter {
+    private config;
+    constructor(config: AIConfig);
+    refine(profile: ProjectProfile, suggestions: OptimizationSuggestion[]): Promise<OptimizationSuggestion[]>;
+}

package/dist/ai/optimizer/llm.js

@@ -0,0 +1,14 @@
+export class LLMAdapter {
+    constructor(config) {
+        this.config = config;
+    }
+    async refine(profile, suggestions) {
+        if (!this.config.enabled || this.config.provider === 'local') {
+            // Local mode: just return static suggestions for now
+            // In a real local LLM setup, we would call the local model here
+            return suggestions;
+        }
+        // TODO: Implement cloud provider call
+        return suggestions;
+    }
+}

package/dist/ai/optimizer/profiler.d.ts

@@ -0,0 +1,11 @@
+import { ProjectProfile } from '../schema.js';
+export declare class ProjectProfiler {
+    private root;
+    constructor(root: string);
+    profile(): Promise<ProjectProfile>;
+    private detectFramework;
+    private detectCssFramework;
+    private detectLanguage;
+    private detectPackageManager;
+    private detectEntries;
+}

package/dist/ai/optimizer/profiler.js

@@ -0,0 +1,111 @@
+import fs from 'fs/promises';
+import path from 'path';
+export class ProjectProfiler {
+    constructor(root) {
+        this.root = root;
+    }
+    async profile() {
+        const pkgPath = path.join(this.root, 'package.json');
+        let pkg = {};
+        try {
+            const content = await fs.readFile(pkgPath, 'utf-8');
+            pkg = JSON.parse(content);
+        }
+        catch (e) {
+            // Ignore missing package.json
+        }
+        const framework = this.detectFramework(pkg);
+        const cssFramework = this.detectCssFramework(pkg);
+        const language = await this.detectLanguage();
+        const packageManager = await this.detectPackageManager();
+        return {
+            framework,
+            cssFramework,
+            language,
+            packageManager,
+            dependencies: pkg.dependencies || {},
+            devDependencies: pkg.devDependencies || {},
+            configSummary: {}, // TODO: Parse nuclie.config.ts
+            entries: await this.detectEntries(),
+            size: {
+                totalJs: 0, // Placeholder: would need actual build stats
+                vendorChunk: 0
+            },
+            cache: {
+                hitRate: 0 // Placeholder
+            },
+            warnings: []
+        };
+    }
+    detectFramework(pkg) {
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['react'])
+            return 'react';
+        if (deps['vue'])
+            return 'vue';
+        if (deps['svelte'])
+            return 'svelte';
+        if (deps['@angular/core'])
+            return 'angular';
+        if (deps['solid-js'])
+            return 'solid';
+        if (deps['preact'])
+            return 'preact';
+        return 'unknown';
+    }
+    detectCssFramework(pkg) {
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['tailwindcss'])
+            return 'tailwind';
+        if (deps['bootstrap'])
+            return 'bootstrap';
+        if (deps['bulma'])
+            return 'bulma';
+        if (deps['@mui/material'])
+            return 'material';
+        return undefined;
+    }
+    async detectLanguage() {
+        try {
+            await fs.access(path.join(this.root, 'tsconfig.json'));
+            return 'typescript';
+        }
+        catch {
+            return 'javascript';
+        }
+    }
+    async detectPackageManager() {
+        try {
+            await fs.access(path.join(this.root, 'yarn.lock'));
+            return 'yarn';
+        }
+        catch { }
+        try {
+            await fs.access(path.join(this.root, 'pnpm-lock.yaml'));
+            return 'pnpm';
+        }
+        catch { }
+        try {
+            await fs.access(path.join(this.root, 'bun.lockb'));
+            return 'bun';
+        }
+        catch { }
+        return 'npm';
+    }
+    async detectEntries() {
+        // Simple heuristic for now
+        const candidates = [
+            'src/main.tsx', 'src/main.ts', 'src/index.tsx', 'src/index.ts',
+            'src/App.tsx', 'src/App.vue', 'src/main.js', 'src/index.js'
+        ];
+        const found = [];
+        for (const c of candidates) {
+            try {
+                await fs.access(path.join(this.root, c));
+                found.push(c);
+            }
+            catch { }
+        }
+        return found;
+    }
+}

package/dist/ai/optimizer/rules.d.ts

@@ -0,0 +1,12 @@
+import { ProjectProfile } from '../schema.js';
+export interface OptimizationSuggestion {
+    id: string;
+    title: string;
+    description: string;
+    impact: 'HIGH' | 'MEDIUM' | 'LOW';
+    risk: 'low' | 'medium' | 'high';
+    configPatch?: string;
+}
+export declare class RulesEngine {
+    static analyze(profile: ProjectProfile): OptimizationSuggestion[];
+}

package/dist/ai/optimizer/rules.js

@@ -0,0 +1,37 @@
+export class RulesEngine {
+    static analyze(profile) {
+        const suggestions = [];
+        // Rule 1: Tailwind Purge
+        if (profile.cssFramework === 'tailwind') {
+            // Check if we can infer it's unoptimized (mock logic for now)
+            suggestions.push({
+                id: 'tailwind-purge',
+                title: 'Enable Tailwind Purge',
+                description: 'Configure content globs to remove unused CSS.',
+                impact: 'HIGH',
+                risk: 'low',
+                configPatch: 'css: { tailwind: { purge: ["./src/**/*.{ts,tsx,vue}"] } }'
+            });
+        }
+        // Rule 2: Vendor Chunk Splitting
+        if (profile.dependencies && Object.keys(profile.dependencies).length > 10) {
+            suggestions.push({
+                id: 'vendor-split',
+                title: 'Split Vendor Chunk',
+                description: 'Separate third-party dependencies into a vendor chunk for better caching.',
+                impact: 'HIGH',
+                risk: 'low',
+                configPatch: 'build: { splitChunks: true }'
+            });
+        }
+        // Rule 3: Image Optimization
+        suggestions.push({
+            id: 'image-opt',
+            title: 'Enable Image Optimization',
+            description: 'Compress images at build time.',
+            impact: 'MEDIUM',
+            risk: 'low'
+        });
+        return suggestions;
+    }
+}

package/dist/ai/patterns/common.d.ts

@@ -0,0 +1,8 @@
+import { FixAction } from '../healer/fixer.js';
+export interface ErrorPattern {
+    id: string;
+    name: string;
+    regex: RegExp;
+    generator: (match: RegExpMatchArray) => FixAction;
+}
+export declare const CommonPatterns: ErrorPattern[];

package/dist/ai/patterns/common.js

@@ -0,0 +1,181 @@
+export const CommonPatterns = [
+    {
+        id: 'missing-dep',
+        name: 'Missing Dependency',
+        regex: /Cannot find module '(@?[\w-]+(?:\/[\w-]+)*)'|Can't resolve '(@?[\w-]+(?:\/[\w-]+)*)'/i,
+        generator: (match) => {
+            const pkg = match[1] || match[2];
+            return {
+                type: 'SHELL_COMMAND',
+                description: `Install missing dependency: ${pkg}`,
+                command: `npm install ${pkg}`,
+                confidence: 0.95
+            };
+        }
+    },
+    {
+        id: 'react-peer-dep',
+        name: 'React Peer Dependency Mismatch',
+        regex: /conflicting peer dependency|peer dependency .* detected/i,
+        generator: () => ({
+            type: 'SHELL_COMMAND',
+            description: 'Install with legacy peer deps',
+            command: 'npm install --legacy-peer-deps',
+            confidence: 0.8
+        })
+    },
+    {
+        id: 'tailwind-purge',
+        name: 'Tailwind Purge Warning',
+        regex: /Tailwind CSS: .*purge.* content/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Configure Tailwind purge content paths',
+            confidence: 0.9
+        })
+    },
+    {
+        id: 'ts-config-error',
+        name: 'TypeScript Config Error',
+        regex: /error TS\d+: .*tsconfig\.json/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Check tsconfig.json configuration',
+            confidence: 0.7
+        })
+    },
+    {
+        id: 'missing-types',
+        name: 'Missing Type Definitions',
+        regex: /Could not find a declaration file for module '(@?[\w-]+(?:\/[\w-]+)*)'/i,
+        generator: (match) => {
+            const pkg = match[1];
+            return {
+                type: 'SHELL_COMMAND',
+                description: `Install type definitions for ${pkg}`,
+                command: `npm install -D @types/${pkg.replace('@', '').replace('/', '__')}`,
+                confidence: 0.85
+            };
+        }
+    },
+    {
+        id: 'port-in-use',
+        name: 'Port Already in Use',
+        regex: /EADDRINUSE.*:(\d+)|Port (\d+) is already in use/i,
+        generator: (match) => {
+            const port = match[1] || match[2];
+            return {
+                type: 'MANUAL_INSTRUCTION',
+                description: `Port ${port} is in use. Kill the process or use a different port.`,
+                confidence: 0.9
+            };
+        }
+    },
+    {
+        id: 'node-version',
+        name: 'Node Version Mismatch',
+        regex: /The engine "node" is incompatible|requires node version/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Update Node.js version or use nvm to switch versions',
+            confidence: 0.8
+        })
+    },
+    {
+        id: 'eslint-error',
+        name: 'ESLint Error',
+        regex: /ESLint.*error|Parsing error.*eslint/i,
+        generator: () => ({
+            type: 'SHELL_COMMAND',
+            description: 'Run ESLint fix',
+            command: 'npm run lint -- --fix',
+            confidence: 0.7
+        })
+    },
+    {
+        id: 'cors-error',
+        name: 'CORS Error',
+        regex: /CORS|Cross-Origin Request Blocked/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Configure CORS headers in your server or use a proxy',
+            confidence: 0.75
+        })
+    },
+    {
+        id: 'memory-limit',
+        name: 'JavaScript Heap Out of Memory',
+        regex: /JavaScript heap out of memory|FATAL ERROR.*heap/i,
+        generator: () => ({
+            type: 'SHELL_COMMAND',
+            description: 'Increase Node.js memory limit',
+            command: 'export NODE_OPTIONS="--max-old-space-size=4096"',
+            confidence: 0.85
+        })
+    },
+    {
+        id: 'git-conflict',
+        name: 'Git Merge Conflict',
+        regex: /CONFLICT.*Merge conflict|<<<<<<< HEAD/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Resolve merge conflicts manually',
+            confidence: 0.6
+        })
+    },
+    {
+        id: 'permission-denied',
+        name: 'Permission Denied',
+        regex: /EACCES|Permission denied/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Run with sudo or fix file permissions',
+            confidence: 0.7
+        })
+    },
+    {
+        id: 'webpack-loader',
+        name: 'Missing Webpack Loader',
+        regex: /You may need an appropriate loader|Module parse failed/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Install appropriate webpack loader for this file type',
+            confidence: 0.75
+        })
+    },
+    {
+        id: 'react-hooks',
+        name: 'Invalid React Hook Call',
+        regex: /Invalid hook call|Hooks can only be called inside/i,
+        generator: () => ({
+            type: 'MANUAL_INSTRUCTION',
+            description: 'Check for multiple React versions or hook usage outside components',
+            confidence: 0.8
+        })
+    },
+    {
+        id: 'env-variable',
+        name: 'Missing Environment Variable',
+        regex: /process\.env\.(\w+) is not defined|Missing environment variable/i,
+        generator: (match) => {
+            const varName = match[1] || 'VARIABLE';
+            return {
+                type: 'MANUAL_INSTRUCTION',
+                description: `Set environment variable ${varName} in .env file`,
+                confidence: 0.85
+            };
+        }
+    },
+    {
+        id: 'nuclie-config-error',
+        name: 'Nuclie Config Validation Error',
+        regex: /Invalid config file/i,
+        generator: () => {
+            return {
+                type: 'MANUAL_INSTRUCTION',
+                description: 'Fix nuclie.config configuration - check for type mismatches or missing fields.',
+                confidence: 0.95
+            };
+        }
+    }
+];

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

@@ -0,0 +1,11 @@
+import { BuildSession } from '../schema.js';
+import { AuditReport } from '../../audit/types.js';
+export interface FullBuildReport {
+    session: BuildSession;
+    trends?: any;
+    audits?: AuditReport;
+    summary: string;
+}
+export declare class ReportAssembler {
+    static assemble(session: BuildSession, trends?: any, audits?: AuditReport): FullBuildReport;
+}

package/dist/ai/reporter/assembler.js

@@ -0,0 +1,10 @@
+export class ReportAssembler {
+    static assemble(session, trends, audits) {
+        return {
+            session,
+            trends,
+            audits,
+            summary: '' // To be filled by Narrator
+        };
+    }
+}

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

@@ -0,0 +1,4 @@
+import { BuildSession } from '../schema.js';
+export declare class ReportGenerator {
+    static generate(session: BuildSession): string;
+}