nuclie 1.0.0

package/dist/repro/dashboard.d.ts

@@ -0,0 +1,83 @@
+import type { BuildContext } from '../core/engine/types.js';
+import type { RootCauseIssue } from '../visual/root-cause.js';
+import { type GitHubConfig } from './github.js';
+/**
+ * Repro Dashboard
+ * Bug reproduction analysis and storage system
+ */
+export interface ReproCase {
+    id: string;
+    title: string;
+    description: string;
+    code: string;
+    error?: string;
+    stackTrace?: string;
+    buildConfig?: any;
+    analysis?: ReproAnalysis;
+    createdAt: number;
+    shareableLink?: string;
+    githubIssueUrl?: string;
+}
+export interface ReproAnalysis {
+    issues: RootCauseIssue[];
+    suggestedFixes: string[];
+    affectedModules: string[];
+    analysisTime: number;
+}
+export declare class ReproDashboard {
+    private db;
+    private dbPath;
+    private github;
+    constructor(dbPath?: string, githubConfig?: GitHubConfig);
+    /**
+     * Initialize database
+     */
+    init(): void;
+    /**
+     * Submit a bug repro to GitHub
+     */
+    submitToGitHub(reproId: string): Promise<string>;
+    /**
+     * Submit a bug repro
+     */
+    submitRepro(repro: Omit<ReproCase, 'id' | 'createdAt' | 'shareableLink'>): string;
+    /**
+     * Analyze a repro case
+     */
+    analyzeRepro(reproId: string, ctx?: BuildContext): Promise<ReproAnalysis>;
+    /**
+     * Get a repro case
+     */
+    getRepro(id: string): ReproCase | null;
+    /**
+     * Get all repros
+     */
+    getAllRepros(): ReproCase[];
+    /**
+     * Update repro analysis
+     */
+    private updateReproAnalysis;
+    /**
+     * Generate repro ID
+     */
+    private generateReproId;
+    /**
+     * Generate shareable link
+     */
+    private generateShareableLink;
+    /**
+     * Generate repro template
+     */
+    generateTemplate(framework?: string): string;
+    /**
+     * Replay a repro
+     */
+    replayRepro(id: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Close database connection
+     */
+    close(): void;
+}

package/dist/repro/dashboard.js

@@ -0,0 +1,251 @@
+import Database from 'better-sqlite3';
+import { createHash } from 'crypto';
+import { GitHubIntegration } from './github.js';
+export class ReproDashboard {
+    constructor(dbPath = ':memory:', githubConfig) {
+        this.db = null;
+        this.github = null;
+        this.dbPath = dbPath;
+        if (githubConfig) {
+            this.github = new GitHubIntegration(githubConfig);
+        }
+    }
+    /**
+     * Initialize database
+     */
+    init() {
+        this.db = new Database(this.dbPath);
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS repros (
+                id TEXT PRIMARY KEY,
+                title TEXT NOT NULL,
+                description TEXT,
+                code TEXT NOT NULL,
+                error TEXT,
+                stack_trace TEXT,
+                build_config TEXT,
+                analysis TEXT,
+                created_at INTEGER NOT NULL,
+                shareable_link TEXT,
+                github_issue_url TEXT
+            )
+        `);
+    }
+    /**
+     * Submit a bug repro to GitHub
+     */
+    async submitToGitHub(reproId) {
+        if (!this.github) {
+            throw new Error('GitHub integration not configured');
+        }
+        const repro = this.getRepro(reproId);
+        if (!repro) {
+            throw new Error('Repro not found');
+        }
+        const body = this.github.formatIssueBody(repro.description, repro.code, { os: process.platform, node: process.version });
+        const result = await this.github.createIssue(repro.title, body);
+        if (!result.success || !result.url) {
+            throw new Error(result.error || 'Failed to create GitHub issue');
+        }
+        // Update database with issue URL
+        const stmt = this.db.prepare('UPDATE repros SET github_issue_url = ? WHERE id = ?');
+        stmt.run(result.url, reproId);
+        return result.url;
+    }
+    /**
+     * Submit a bug repro
+     */
+    submitRepro(repro) {
+        if (!this.db)
+            this.init();
+        const id = this.generateReproId(repro.code);
+        const createdAt = Date.now();
+        const shareableLink = this.generateShareableLink(id);
+        const stmt = this.db.prepare(`
+            INSERT INTO repros (id, title, description, code, error, stack_trace, build_config, analysis, created_at, shareable_link)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+        stmt.run(id, repro.title, repro.description || '', repro.code, repro.error || null, repro.stackTrace || null, repro.buildConfig ? JSON.stringify(repro.buildConfig) : null, repro.analysis ? JSON.stringify(repro.analysis) : null, createdAt, shareableLink);
+        return id;
+    }
+    /**
+     * Analyze a repro case
+     */
+    async analyzeRepro(reproId, ctx) {
+        const startTime = Date.now();
+        const repro = this.getRepro(reproId);
+        if (!repro) {
+            throw new Error(`Repro ${reproId} not found`);
+        }
+        // Analyze the code for issues
+        const issues = [];
+        const suggestedFixes = [];
+        const affectedModules = [];
+        // Parse error and suggest fixes
+        if (repro.error) {
+            if (repro.error.includes('Cannot find module')) {
+                issues.push({
+                    type: 'unused-dep',
+                    severity: 'critical',
+                    message: 'Module not found',
+                    fix: 'Install the missing dependency or check the import path',
+                    affectedNodes: []
+                });
+                suggestedFixes.push('npm install <missing-module>');
+            }
+            if (repro.error.includes('Unexpected token')) {
+                issues.push({
+                    type: 'dead-code',
+                    severity: 'critical',
+                    message: 'Syntax error detected',
+                    fix: 'Check for syntax errors in the code',
+                    affectedNodes: []
+                });
+                suggestedFixes.push('Review code syntax');
+            }
+            if (repro.error.includes('circular dependency')) {
+                issues.push({
+                    type: 'circular-dep',
+                    severity: 'warning',
+                    message: 'Circular dependency detected',
+                    fix: 'Refactor to remove circular dependency',
+                    affectedNodes: []
+                });
+                suggestedFixes.push('Refactor module structure');
+            }
+        }
+        const analysisTime = Date.now() - startTime;
+        const analysis = {
+            issues,
+            suggestedFixes,
+            affectedModules,
+            analysisTime
+        };
+        // Store analysis
+        this.updateReproAnalysis(reproId, analysis);
+        return analysis;
+    }
+    /**
+     * Get a repro case
+     */
+    getRepro(id) {
+        if (!this.db)
+            this.init();
+        const stmt = this.db.prepare('SELECT * FROM repros WHERE id = ?');
+        const row = stmt.get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            title: row.title,
+            description: row.description,
+            code: row.code,
+            error: row.error,
+            stackTrace: row.stack_trace,
+            buildConfig: row.build_config ? JSON.parse(row.build_config) : undefined,
+            analysis: row.analysis ? JSON.parse(row.analysis) : undefined,
+            createdAt: row.created_at,
+            shareableLink: row.shareable_link,
+            githubIssueUrl: row.github_issue_url
+        };
+    }
+    /**
+     * Get all repros
+     */
+    getAllRepros() {
+        if (!this.db)
+            this.init();
+        const stmt = this.db.prepare('SELECT * FROM repros ORDER BY created_at DESC');
+        const rows = stmt.all();
+        return rows.map(row => ({
+            id: row.id,
+            title: row.title,
+            description: row.description,
+            code: row.code,
+            error: row.error,
+            stackTrace: row.stack_trace,
+            buildConfig: row.build_config ? JSON.parse(row.build_config) : undefined,
+            analysis: row.analysis ? JSON.parse(row.analysis) : undefined,
+            createdAt: row.created_at,
+            shareableLink: row.shareable_link,
+            githubIssueUrl: row.github_issue_url
+        }));
+    }
+    /**
+     * Update repro analysis
+     */
+    updateReproAnalysis(id, analysis) {
+        if (!this.db)
+            return;
+        const stmt = this.db.prepare('UPDATE repros SET analysis = ? WHERE id = ?');
+        stmt.run(JSON.stringify(analysis), id);
+    }
+    /**
+     * Generate repro ID
+     */
+    generateReproId(code) {
+        const hash = createHash('sha256').update(code).digest('hex');
+        return `repro-${hash.substring(0, 12)}`;
+    }
+    /**
+     * Generate shareable link
+     */
+    generateShareableLink(id) {
+        return `https://nuclie.dev/repro/${id}`;
+    }
+    /**
+     * Generate repro template
+     */
+    generateTemplate(framework = 'react') {
+        const templates = {
+            // Tier 1: Core Frameworks
+            react: `import React from 'react';\nexport default function App() { return <div>Repro</div>; }`,
+            vue: `<template><div>Repro</div></template>\n<script>export default { name: 'App' }</script>`,
+            svelte: `<script>let name = 'Repro';</script>\n<div>{name}</div>`,
+            // Tier 2: Performance
+            solid: `import { createSignal } from 'solid-js';\nexport default function App() { return <div>Repro</div>; }`,
+            preact: `import { h } from 'preact';\nexport default function App() { return <div>Repro</div>; }`,
+            qwik: `import { component$ } from '@builder.io/qwik';\nexport default component$(() => <div>Repro</div>);`,
+            // Tier 3: Enterprise
+            angular: `@Component({ selector: 'app-root', template: '<div>Repro</div>' }) export class AppComponent {}`,
+            // Tier 4: Native/Lightweight
+            lit: `import { html, LitElement } from 'lit';\n@customElement('my-repro') class MyRepro extends LitElement { render() { return html\`<div>Repro</div>\`; } }`,
+            alpine: `<div x-data="{ count: 0 }">Repro</div>`,
+            astro: `--- \nconst name = "Repro"; \n---\n<div>{name}</div>`,
+            stencil: `@Component({ tag: 'my-repro' }) export class MyRepro { render() { return <div>Repro</div>; } }`,
+            // Fallback
+            vanilla: `document.body.innerHTML = '<div>Repro</div>';`
+        };
+        return templates[framework] || templates.react;
+    }
+    /**
+     * Replay a repro
+     */
+    async replayRepro(id) {
+        const repro = this.getRepro(id);
+        if (!repro) {
+            return { success: false, error: 'Repro not found' };
+        }
+        try {
+            // Simulate build with repro code
+            // In production, this would actually run the build
+            await new Promise(resolve => setTimeout(resolve, 100));
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+}

package/dist/repro/github.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GitHub Integration for Repro Dashboard
+ * Handles creating issues from repro cases
+ */
+export interface GitHubConfig {
+    token: string;
+    owner: string;
+    repo: string;
+}
+export interface IssueResult {
+    success: boolean;
+    url?: string;
+    error?: string;
+}
+export declare class GitHubIntegration {
+    private config;
+    constructor(config: GitHubConfig);
+    /**
+     * Create a GitHub issue from a repro case
+     */
+    createIssue(title: string, body: string, labels?: string[]): Promise<IssueResult>;
+    /**
+     * Format repro case into issue markdown body
+     */
+    formatIssueBody(description: string, code: string, envInfo: any): string;
+}

package/dist/repro/github.js

@@ -0,0 +1,73 @@
+/**
+ * GitHub Integration for Repro Dashboard
+ * Handles creating issues from repro cases
+ */
+export class GitHubIntegration {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Create a GitHub issue from a repro case
+     */
+    async createIssue(title, body, labels = []) {
+        if (!this.config.token) {
+            return { success: false, error: 'GitHub token not configured' };
+        }
+        try {
+            const response = await fetch(`https://api.github.com/repos/${this.config.owner}/${this.config.repo}/issues`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `token ${this.config.token}`,
+                    'Accept': 'application/vnd.github.v3+json',
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'Nuclie-Build-Tool'
+                },
+                body: JSON.stringify({
+                    title,
+                    body,
+                    labels: ['bug', 'repro', ...labels]
+                })
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return {
+                    success: false,
+                    error: `GitHub API Error: ${error.message || response.statusText}`
+                };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                url: data.html_url
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown network error'
+            };
+        }
+    }
+    /**
+     * Format repro case into issue markdown body
+     */
+    formatIssueBody(description, code, envInfo) {
+        return `
+## Description
+${description}
+
+## Reproduction Code
+\`\`\`js
+${code}
+\`\`\`
+
+## Environment
+- **OS**: ${envInfo.os || 'Unknown'}
+- **Node**: ${envInfo.node || 'Unknown'}
+- **Build Tool**: Nuclie
+
+---
+*Auto-generated by Nuclie Repro Dashboard*
+        `.trim();
+    }
+}

package/dist/resolve/css-precedence.d.ts

@@ -0,0 +1,16 @@
+import { GraphEdge } from './graph.js';
+export interface ExplainEvent {
+    stage: string;
+    subjectId?: string;
+    decision: string;
+    reason: string;
+    data?: any;
+}
+export declare class CSSImportPrecedenceResolver {
+    private explains;
+    resolve(edges: GraphEdge[], nodes: Map<string, any>): GraphEdge[];
+    private getPrecedence;
+    private compareLayers;
+    private emitExplains;
+    getExplains(): ExplainEvent[];
+}

package/dist/resolve/css-precedence.js

@@ -0,0 +1,56 @@
+export class CSSImportPrecedenceResolver {
+    constructor() {
+        this.explains = [];
+    }
+    resolve(edges, nodes) {
+        const cssEdges = edges.filter(e => e.kind === 'css-import' || e.kind === 'css-layer');
+        // Sort logic based on CSS cascade rules:
+        // 1. @layer precedence (lower layer = lower precedence)
+        // 2. Specificity (id > class > element) - though @import doesn't have specificity in the traditional sense, 
+        //    the plan suggests a specificity score for the import itself or its target.
+        // 3. Source order (later = higher precedence)
+        const resolved = [...cssEdges].sort((a, b) => {
+            const precA = this.getPrecedence(a);
+            const precB = this.getPrecedence(b);
+            // Cascade Layers First
+            if (precA.cascadeLayer !== precB.cascadeLayer) {
+                return this.compareLayers(precA.cascadeLayer, precB.cascadeLayer);
+            }
+            // Specificity Second
+            if (precA.specificity !== precB.specificity) {
+                return precA.specificity - precB.specificity;
+            }
+            // Source Order Third
+            return precA.sourceOrder - precB.sourceOrder;
+        });
+        this.emitExplains(edges, resolved);
+        return resolved;
+    }
+    getPrecedence(edge) {
+        return edge.metadata?.precedence || {
+            specificity: 0,
+            sourceOrder: 0
+        };
+    }
+    compareLayers(layerA, layerB) {
+        // Tailwind standard layers order: base < components < utilities
+        const order = ['base', 'components', 'utilities'];
+        const idxA = layerA ? order.indexOf(layerA) : -1;
+        const idxB = layerB ? order.indexOf(layerB) : -1;
+        return idxA - idxB;
+    }
+    emitExplains(original, resolved) {
+        resolved.forEach((edge, index) => {
+            const prec = this.getPrecedence(edge);
+            this.explains.push({
+                stage: 'css-precedence',
+                subjectId: edge.to,
+                decision: `Position ${index}`,
+                reason: `Resolved via @layer: ${prec.cascadeLayer || 'none'}, specificity: ${prec.specificity}, order: ${prec.sourceOrder}`
+            });
+        });
+    }
+    getExplains() {
+        return this.explains;
+    }
+}

package/dist/resolve/graph.d.ts

@@ -0,0 +1,48 @@
+import { PluginManager } from '../core/plugins/manager.js';
+export type GraphEdgeKind = 'import' | 'dynamic-import' | 'require' | 'css-url' | 'css-import' | 'js-style-import' | 'css-layer';
+export type CSSImportPrecedence = {
+    specificity: number;
+    sourceOrder: number;
+    cascadeLayer?: string;
+};
+export interface GraphEdge {
+    from: string;
+    to: string;
+    kind: GraphEdgeKind;
+    loc?: any;
+    metadata?: any;
+    target?: 'client' | 'server' | 'edge' | 'universal';
+}
+export interface GraphNode {
+    id: string;
+    type: 'file' | 'virtual' | 'css' | 'css-module' | 'style-asset' | 'css-in-js';
+    path: string;
+    contentHash: string;
+    edges: GraphEdge[];
+    specifierMap?: Record<string, string>;
+    metadata?: Record<string, any>;
+    target?: 'client' | 'server' | 'edge' | 'universal';
+    cssInJs?: {
+        runtime: "styled-components" | "emotion" | "linaria";
+        extractedCss: string;
+    };
+}
+export interface GraphValidation {
+    isValid: boolean;
+    cycles: string[][];
+    errors: string[];
+}
+export declare class DependencyGraph {
+    nodes: Map<string, GraphNode>;
+    graphHash: string;
+    private pluginManager;
+    constructor(pluginManager?: PluginManager);
+    addEntry(entryPath: string, rootDir: string): Promise<void>;
+    private detectType;
+    private scanAndAdd;
+    private parseImportsSimple;
+    private resolve;
+    invalidate(filePath: string, rootDir: string): Promise<void>;
+    validate(): GraphValidation;
+    getReachableNodes(entryPoints: string[]): string[];
+}