nuclie 1.0.0

package/dist/core/detection/files.js

@@ -0,0 +1,77 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { explainReporter } from '../engine/events.js';
+// Phase 4: Entry File Inspection
+export async function inspectEntryFiles(rootDir, entryFiles) {
+    const signals = [];
+    for (const entry of entryFiles) {
+        const absEntry = path.resolve(rootDir, entry);
+        let content = '';
+        try {
+            content = await fs.readFile(absEntry, 'utf-8');
+        }
+        catch (e) {
+            continue;
+        }
+        // Framework specific signals
+        // React
+        if (content.includes('createRoot') || content.includes('hydrateRoot')) {
+            signals.push({
+                framework: 'react',
+                source: 'entry',
+                strength: 30,
+                evidence: `Found React initialization in ${entry}`
+            });
+        }
+        // Vue
+        if (content.includes('createApp') && (content.includes('vue') || entry.endsWith('.ts') || entry.endsWith('.js'))) {
+            signals.push({
+                framework: 'vue',
+                source: 'entry',
+                strength: 30,
+                evidence: `Found Vue createApp in ${entry}`
+            });
+        }
+        // Svelte
+        if (content.includes('new App') && content.includes('target:')) {
+            signals.push({
+                framework: 'svelte',
+                source: 'entry',
+                strength: 30,
+                evidence: `Found Svelte app initialization in ${entry}`
+            });
+        }
+        // Angular
+        if (content.includes('platformBrowserDynamic') || content.includes('bootstrapModule')) {
+            signals.push({
+                framework: 'angular',
+                source: 'entry',
+                strength: 40,
+                evidence: `Found Angular bootstrap in ${entry}`
+            });
+        }
+        // Meta-framework Specific Exports
+        // Next.js (Pages router)
+        if (content.includes('getStaticProps') || content.includes('getServerSideProps')) {
+            signals.push({
+                framework: 'next',
+                source: 'entry',
+                strength: 40,
+                evidence: `Found Next.js data fetching in ${entry}`
+            });
+        }
+        // Remix
+        if (content.includes('export const loader') || content.includes('export const action')) {
+            // Ambiguous as generic loaders exist, but strong hint with routes
+            // We give it moderate weight
+            signals.push({
+                framework: 'remix',
+                source: 'entry',
+                strength: 20,
+                evidence: `Found Remix-style loader/action in ${entry}`
+            });
+        }
+        explainReporter.report('detect', 'inspect', `Inspected ${entry}`);
+    }
+    return signals;
+}

package/dist/core/detection/index.d.ts

@@ -0,0 +1,8 @@
+import { FrameworkProfile } from './types.js';
+/**
+ * Framework Detection System
+ *
+ * @internal - This is part of the core detection logic. Use public APIs or official presets.
+ */
+export declare function detectFramework(rootDir: string, candidateEntries?: string[]): Promise<FrameworkProfile>;
+export * from './types.js';

package/dist/core/detection/index.js

@@ -0,0 +1,39 @@
+import { scanDependencies, scanFileSystem, scanConfigArtifacts } from './scanner.js';
+import { inspectEntryFiles } from './files.js';
+import { resolveFrameworkProfile } from './resolver.js';
+import { explainReporter } from '../engine/events.js';
+// Phase 10: Main Detection API
+/**
+ * Framework Detection System
+ *
+ * @internal - This is part of the core detection logic. Use public APIs or official presets.
+ */
+export async function detectFramework(rootDir, candidateEntries = []) {
+    explainReporter.report('detect', 'start', 'Starting framework detection');
+    // 1. Initial Scans
+    const depSignals = await scanDependencies(rootDir);
+    const fsSignals = await scanFileSystem(rootDir);
+    const cfgSignals = await scanConfigArtifacts(rootDir);
+    let allSignals = [...depSignals, ...fsSignals, ...cfgSignals];
+    // 2. Intermediate Resolve (to refine Entry Inspection if needed)
+    // Actually, we can inspect entries regardless.
+    // If no candidateEntries provided, we might guess common ones?
+    let entries = [...candidateEntries];
+    if (entries.length === 0) {
+        // Fallback defaults
+        entries = ['src/main.tsx', 'src/main.ts', 'src/index.tsx', 'src/index.ts', 'src/main.js', 'src/index.js'];
+    }
+    // 3. Entry Inspection
+    const entrySignals = await inspectEntryFiles(rootDir, entries);
+    allSignals = [...allSignals, ...entrySignals];
+    // 4. Final Resolution
+    const profile = resolveFrameworkProfile(allSignals);
+    // 5. Populate detected entry points if we found them
+    // Logic: If inspectEntryFiles looked at them, valid ones exist?
+    // inspectEntryFiles only looked.
+    // We should verify existence and add to profile.entryPoints.
+    // This logic belongs partly in scanner or graph, but let's just confirm what we checked.
+    // For now, we trust the input `entries` or found ones.
+    return profile;
+}
+export * from './types.js';

package/dist/core/detection/resolver.d.ts

@@ -0,0 +1,2 @@
+import { DetectionSignal, FrameworkProfile } from './types.js';
+export declare function resolveFrameworkProfile(signals: DetectionSignal[]): FrameworkProfile;

package/dist/core/detection/resolver.js

@@ -0,0 +1,116 @@
+import { UNKNOWN_PROFILE } from './types.js';
+import { explainReporter } from '../engine/events.js';
+const META_FRAMEWORK_MAP = {
+    'next': 'react',
+    'remix': 'react',
+    'nuxt': 'vue',
+    'sveltekit': 'svelte',
+    'solid-start': 'solid-js',
+    'analog': 'angular'
+    // Astro is special, can be its own primary
+};
+export function resolveFrameworkProfile(signals) {
+    explainReporter.report('detect', 'aggregate', `Resolving profile from ${signals.length} signals`);
+    // 1. Group by Framework
+    const scores = new Map();
+    const evidences = new Map();
+    const versionRanges = new Map();
+    for (const s of signals) {
+        const current = scores.get(s.framework) || 0;
+        scores.set(s.framework, current + s.strength);
+        if (!evidences.has(s.framework))
+            evidences.set(s.framework, []);
+        evidences.get(s.framework).push(s.evidence);
+        if (s.versionRange && !versionRanges.has(s.framework)) {
+            versionRanges.set(s.framework, s.versionRange);
+        }
+    }
+    // 2. Sort by Score
+    // Deterministic sort: Score desc, then Name asc
+    const sortedFrameworks = Array.from(scores.keys()).sort((a, b) => {
+        const scoreA = scores.get(a);
+        const scoreB = scores.get(b);
+        if (scoreA !== scoreB)
+            return scoreB - scoreA;
+        return a.localeCompare(b);
+    });
+    if (sortedFrameworks.length === 0) {
+        return UNKNOWN_PROFILE;
+    }
+    const DetectedFrameworks = sortedFrameworks.map(fw => ({
+        name: fw,
+        versionRange: versionRanges.get(fw),
+        compatibility: 'full' // Placeholder logic for now, later version checks
+    }));
+    // 3. Identify Primary and Meta
+    // Top score is usually the winner, but we must handle Meta relationships.
+    // If 'next' is present, it's the Meta, implying 'react' as Primary.
+    // If 'react' is top score (80) and 'next' is (40), we still might want to know it's a Next app.
+    let meta;
+    let primary = sortedFrameworks[0];
+    // Check for meta-frameworks in the detected list
+    // We prioritize detected meta-frameworks even if they have lower score than the lib?
+    // e.g. React (40) + Next (30). It's a Next app.
+    // But usually Next brings React dependency, so React score is high.
+    // Let's look for known meta-frameworks in the list.
+    const detectedMeta = sortedFrameworks.find(fw => Object.keys(META_FRAMEWORK_MAP).includes(fw));
+    if (detectedMeta) {
+        meta = detectedMeta;
+        // Enforce the primary for this meta
+        const impliedPrimary = META_FRAMEWORK_MAP[meta];
+        if (impliedPrimary) {
+            primary = impliedPrimary;
+            // Ensure implied primary is in the list (it should be if deps are correct)
+            if (!scores.has(primary)) {
+                // Hybrid case or pure meta (unlikely for these pairs)
+            }
+        }
+    }
+    else {
+        // No meta found, determine primary from top score
+        // Only if it's not 'unknown'
+    }
+    // 4. Inferences
+    // Routing
+    let routing = 'none';
+    if (meta) {
+        routing = 'file-based'; // Next, Nuxt, SvelteKit, Remix, Astro usually
+    }
+    else if (primary === 'angular') {
+        routing = 'code-based'; // Traditionally
+    }
+    else if (['react', 'vue', 'svelte'].includes(primary)) {
+        // SPA usually code-based or none
+        // Check signals for 'react-router', etc? (Future)
+        routing = 'code-based';
+    }
+    // Rendering
+    // Default to SPA unless Meta/SSR signals
+    let renderingPrimary = 'spa';
+    if (meta || primary === 'astro' || primary === 'qwik') {
+        renderingPrimary = 'ssr'; // Or SSG / Hybrid, strictly speaking 'server-capable'
+    }
+    // 5. Confidence Score
+    // Normalized 0-1 based on top score threshold?
+    // Or just Raw Score.
+    // Let's use 0-100 logic.
+    // If > 50, confident.
+    const topScore = scores.get(meta || primary) || 0;
+    const confidence = Math.min(topScore, 100);
+    const profile = {
+        frameworks: DetectedFrameworks,
+        primaryFramework: primary,
+        metaFramework: meta,
+        versionRange: versionRanges.get(primary),
+        compatibility: 'full', // Default
+        rendering: {
+            primary: renderingPrimary
+        },
+        routing: routing,
+        runtimeTarget: renderingPrimary === 'spa' ? 'browser' : 'node', // Default wrapper
+        entryPoints: [], // Populated by caller or files scanner
+        confidenceScore: confidence
+    };
+    explainReporter.report('detect', 'complete', `Resolved: ${meta ? meta + '+' : ''}${primary} (${confidence}%)`, { profile });
+    return profile;
+}

package/dist/core/detection/scanner.d.ts

@@ -0,0 +1,4 @@
+import { DetectionSignal } from './types.js';
+export declare function scanDependencies(rootDir: string): Promise<DetectionSignal[]>;
+export declare function scanFileSystem(rootDir: string): Promise<DetectionSignal[]>;
+export declare function scanConfigArtifacts(rootDir: string): Promise<DetectionSignal[]>;

package/dist/core/detection/scanner.js

@@ -0,0 +1,145 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { explainReporter } from '../engine/events.js';
+// Phase 2: Dependency Scanner
+export async function scanDependencies(rootDir) {
+    const signals = [];
+    let pkg;
+    try {
+        const pkgContent = await fs.readFile(path.join(rootDir, 'package.json'), 'utf-8');
+        pkg = JSON.parse(pkgContent);
+    }
+    catch (e) {
+        // No package.json, can't scan deps
+        return signals;
+    }
+    const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+        ...pkg.peerDependencies
+    };
+    const FRAMEWORK_MAP = {
+        'react': 'react',
+        'vue': 'vue',
+        'svelte': 'svelte',
+        'solid-js': 'solid-js',
+        'preact': 'preact',
+        '@builder.io/qwik': 'qwik',
+        '@angular/core': 'angular',
+        'lit': 'lit',
+        'next': 'next',
+        '@remix-run/react': 'remix',
+        '@remix-run/node': 'remix',
+        'remix': 'remix', // v1
+        'nuxt': 'nuxt',
+        '@sveltejs/kit': 'sveltekit',
+        'astro': 'astro'
+    };
+    for (const [dep, version] of Object.entries(allDeps)) {
+        if (FRAMEWORK_MAP[dep]) {
+            const fw = FRAMEWORK_MAP[dep];
+            signals.push({
+                framework: fw,
+                source: 'dependency',
+                strength: 40, // Strong signal
+                evidence: `Found dependency: ${dep}@${version}`,
+                versionRange: typeof version === 'string' ? version : undefined
+            });
+            explainReporter.report('detect', 'signal', `Dependency signal: ${fw} from ${dep}`);
+        }
+    }
+    return signals;
+}
+// Phase 3: File System Scanner
+export async function scanFileSystem(rootDir) {
+    const signals = [];
+    // Simple existence checks
+    const check = async (p) => {
+        try {
+            await fs.access(path.join(rootDir, p));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    // Heuristics
+    if (await check('pages') || await check('app')) {
+        // Next.js uses /pages or /app. But generic apps might too.
+        // We give it moderate weight.
+        signals.push({
+            framework: 'next',
+            source: 'filesystem',
+            strength: 20,
+            evidence: 'Found /pages or /app directory'
+        });
+    }
+    if (await check('routes') || await check('app/routes')) {
+        signals.push({
+            framework: 'remix',
+            source: 'filesystem',
+            strength: 20,
+            evidence: 'Found /routes directory'
+        });
+    }
+    if (await check('src/routes')) {
+        signals.push({
+            framework: 'sveltekit',
+            source: 'filesystem',
+            strength: 20,
+            evidence: 'Found /src/routes directory'
+        });
+        signals.push({
+            framework: 'solid-js', // SolidStart also uses src/routes often
+            source: 'filesystem',
+            strength: 10,
+            evidence: 'Found /src/routes directory (ambiguous)'
+        });
+    }
+    if (await check('astro.config.mjs') || await check('astro.config.ts')) {
+        // Config file is also a FS signal but we have a dedicated config scanner. 
+        // We can include it here or there. The prompt distinguishes them.
+        // "Phase 3: /astro.config.* -> Astro"
+        signals.push({
+            framework: 'astro',
+            source: 'filesystem',
+            strength: 30, // Pretty strong
+            evidence: 'Found astro config file'
+        });
+    }
+    if (await check('angular.json')) {
+        signals.push({
+            framework: 'angular',
+            source: 'filesystem',
+            strength: 30,
+            evidence: 'Found angular.json'
+        });
+    }
+    return signals;
+}
+// Phase 5: Config Artifact Inspection
+export async function scanConfigArtifacts(rootDir) {
+    const signals = [];
+    const check = async (p, fw) => {
+        try {
+            await fs.access(path.join(rootDir, p));
+            signals.push({
+                framework: fw,
+                source: 'config',
+                strength: 10, // Confirmation signal
+                evidence: `Found config file: ${p}`
+            });
+        }
+        catch { }
+    };
+    await check('next.config.js', 'next');
+    await check('next.config.ts', 'next');
+    await check('next.config.mjs', 'next');
+    await check('nuxt.config.js', 'nuxt');
+    await check('nuxt.config.ts', 'nuxt');
+    await check('svelte.config.js', 'svelte');
+    await check('svelte.config.ts', 'svelte'); // SvelteKit usually
+    await check('remix.config.js', 'remix');
+    await check('vite.config.ts', 'unknown'); // Generic, but might prompt deep scan
+    return signals;
+}

package/dist/core/detection/types.d.ts

@@ -0,0 +1,33 @@
+export type FrameworkName = 'react' | 'vue' | 'svelte' | 'solid-js' | 'preact' | 'qwik' | 'angular' | 'lit' | 'next' | 'remix' | 'nuxt' | 'sveltekit' | 'astro' | 'unknown';
+export type SignalSource = 'dependency' | 'filesystem' | 'entry' | 'config';
+export interface DetectionSignal {
+    framework: FrameworkName;
+    source: SignalSource;
+    strength: number;
+    evidence: string;
+    versionRange?: string;
+}
+export interface RenderingMode {
+    primary: 'spa' | 'ssr' | 'ssg' | 'isr';
+    islands?: boolean;
+    prerender?: boolean;
+}
+export interface DetectedFramework {
+    name: FrameworkName;
+    versionRange?: string;
+    compatibility: 'full' | 'partial' | 'experimental' | 'unknown';
+}
+export interface FrameworkProfile {
+    frameworks: DetectedFramework[];
+    primaryFramework: FrameworkName;
+    metaFramework?: FrameworkName;
+    versionRange?: string;
+    compatibility: 'full' | 'partial' | 'experimental' | 'unknown';
+    rendering: RenderingMode;
+    routing: 'file-based' | 'code-based' | 'none';
+    runtimeTarget: 'browser' | 'node' | 'edge' | 'mixed';
+    entryPoints: string[];
+    serverEntry?: string;
+    confidenceScore: number;
+}
+export declare const UNKNOWN_PROFILE: FrameworkProfile;

package/dist/core/detection/types.js

@@ -0,0 +1,12 @@
+// Phase 1: Core Types & Contracts
+// Default/Fallback profile
+export const UNKNOWN_PROFILE = {
+    frameworks: [],
+    primaryFramework: 'unknown',
+    compatibility: 'unknown',
+    rendering: { primary: 'spa' },
+    routing: 'none',
+    runtimeTarget: 'browser',
+    entryPoints: [],
+    confidenceScore: 0
+};

package/dist/core/engine/cache.d.ts

@@ -0,0 +1,18 @@
+import { BuildCache, CachedResult } from './types.js';
+export declare class InMemoryBuildCache implements BuildCache {
+    private store;
+    get(key: string): CachedResult | null;
+    set(key: string, value: CachedResult): void;
+    clear(): void;
+    close(): void;
+}
+export declare class PersistentBuildCache implements BuildCache {
+    private cacheDir;
+    constructor(rootDir: string);
+    private getDb;
+    get(key: string): CachedResult | null;
+    getAsync(key: string): Promise<CachedResult | null>;
+    set(key: string, value: CachedResult): Promise<void>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/core/engine/cache.js

@@ -0,0 +1,72 @@
+import path from 'path';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+export class InMemoryBuildCache {
+    constructor() {
+        this.store = new Map();
+    }
+    get(key) {
+        return this.store.get(key) || null;
+    }
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    clear() {
+        this.store.clear();
+    }
+    close() { }
+}
+export class PersistentBuildCache {
+    constructor(rootDir) {
+        this.cacheDir = path.join(rootDir, '.nuclie_cache');
+    }
+    async getDb() {
+        try {
+            const { getLazyCacheDatabase } = await import('../cache/lazy-init.js');
+            return await getLazyCacheDatabase(this.cacheDir);
+        }
+        catch (e) {
+            // Fallback to Memory Cache on Lock Error (Robustness)
+            if (e.message?.includes('Lock') || e.message?.includes('IO error') || e.message?.includes('Resource temporarily unavailable')) {
+                const { log } = await import('../../utils/logger.js');
+                log.warn(`Cache locked, falling back to in-memory cache: ${e.message}`, { category: 'cache' });
+                // Return a mock DB interface that uses an in-memory map
+                const store = new Map();
+                return {
+                    get: (k) => store.get(k),
+                    set: (k, v) => store.set(k, v),
+                    clearAll: () => store.clear(),
+                    close: () => { }
+                };
+            }
+            throw e;
+        }
+    }
+    get(key) {
+        // BuildCache.get is synchronous in type, but RocksDB is fast enough 
+        // that we can potentially use a sync bridge or just handle it.
+        // Actually, the BuildCache interface expects sync. 
+        // For Module 8, we will use the async version for better perf, 
+        // but for compatibility we'll use a trick if needed.
+        // Let's assume we can make the engine await cache results.
+        return null; // Will be handled by the async flow in engine
+    }
+    async getAsync(key) {
+        const db = await this.getDb();
+        const val = db.get(key);
+        if (val)
+            return JSON.parse(val);
+        return null;
+    }
+    async set(key, value) {
+        const db = await this.getDb();
+        db.set(key, JSON.stringify(value));
+    }
+    async clear() {
+        const db = await this.getDb();
+        db.clearAll();
+    }
+    async close() {
+        // Managed by global lazy cache
+    }
+}

package/dist/core/engine/config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Engine Configuration and Initialization
+ *
+ * @internal - This is part of the core engine and NOT a public API.
+ */
+import { BuildConfig } from '../../config/index.js';
+import { BuildContext, BuildMode, InputFingerprint } from './types.js';
+import { DependencyGraph } from '../../resolve/graph.js';
+export declare function initBuild(userConfig: BuildConfig, mode: BuildMode, rootDir: string): Promise<BuildContext>;
+export declare function computeInputFingerprint(ctx: BuildContext): Promise<InputFingerprint>;
+export declare function attachGraph(ctx: BuildContext, graph: DependencyGraph): BuildContext;