@kernlang/cli 2.0.0

package/dist/cli.js

@@ -0,0 +1,981 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { resolve, basename, dirname, relative } from 'path';
+import { createJiti } from 'jiti';
+import { parse, decompile, resolveConfig, VALID_TARGETS, VALID_STRUCTURES, generateCoreNode, isCoreNode, detectVersionsFromPackageJson, scanProject, generateConfigSource, formatScanSummary, registerTemplate, isTemplateNode, expandTemplateNode, clearTemplates, detectTemplates, COMMON_TEMPLATES } from '@kernlang/core';
+import { generateReactNode, isReactNode } from '@kernlang/react';
+import { transpile } from '@kernlang/native';
+import { transpileWeb, transpileTailwind, transpileNextjs } from '@kernlang/react';
+import { transpileExpress } from '@kernlang/express';
+import { transpileCliApp } from './transpiler-cli.js';
+import { transpileTerminal } from '@kernlang/terminal';
+import { transpileVue, transpileNuxt } from '@kernlang/vue';
+import { collectLanguageMetrics } from '@kernlang/metrics';
+import { reviewFile, reviewDirectory, formatReport, formatSummary, checkEnforcement, formatEnforcement, exportKernIR, buildLLMPrompt, dedup, runESLint, runTSCDiagnosticsFromPaths, linkToNodes } from '@kernlang/review';
+const args = process.argv.slice(2);
+const GENERATED_HEADER = '// Generated by KERN — do not edit. Source: ';
+// ── kern dev <dir|file> [--target=...] [--outdir=...] ─────────────────
+if (args[0] === 'dev') {
+    const devInput = args[1];
+    if (!devInput) {
+        console.error('Usage: kern dev <file.kern|dir> [--target=nextjs] [--outdir=<dir>]');
+        process.exit(1);
+    }
+    const inputPath = resolve(devInput);
+    const stat = existsSync(inputPath) ? statSync(inputPath) : null;
+    if (!stat) {
+        console.error(`Not found: ${devInput}`);
+        process.exit(1);
+    }
+    const watchDir = stat.isDirectory() ? inputPath : dirname(inputPath);
+    const watchPattern = stat.isDirectory() ? undefined : basename(inputPath);
+    // Load config
+    const devConfig = loadConfig();
+    // CLI overrides
+    const devCliTarget = args.find(a => a.startsWith('--target='))?.split('=')[1];
+    if (devCliTarget) {
+        if (!VALID_TARGETS.includes(devCliTarget)) {
+            console.error(`Unknown target: '${devCliTarget}'.`);
+            process.exit(1);
+        }
+        devConfig.target = devCliTarget;
+    }
+    const devOutDir = args.find(a => a.startsWith('--outdir='))?.split('=')[1];
+    // Auto-detect framework versions from nearest package.json (walk up from watchDir)
+    const pkgPath = findNearestPackageJson(watchDir);
+    if (pkgPath && Object.keys(devConfig.frameworkVersions).length === 0) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            const detected = detectVersionsFromPackageJson(pkg);
+            if (detected.tailwind || detected.nextjs) {
+                devConfig.frameworkVersions = { ...devConfig.frameworkVersions, ...detected };
+                const parts = [];
+                if (detected.tailwind)
+                    parts.push(`Tailwind ${detected.tailwind}`);
+                if (detected.nextjs)
+                    parts.push(`Next.js ${detected.nextjs}`);
+                console.log(`  Auto-detected: ${parts.join(', ')}`);
+            }
+        }
+        catch { }
+    }
+    // Load templates before compilation
+    loadTemplates(devConfig);
+    console.log(`\n  KERN dev — watching for changes`);
+    console.log(`  Target: ${devConfig.target}`);
+    console.log(`  Watch:  ${relative(process.cwd(), watchDir) || '.'}`);
+    console.log('');
+    // Initial build of all .kern files
+    const initialFiles = findKernFiles(watchDir, watchPattern);
+    for (const file of initialFiles) {
+        transpileAndWrite(file, devConfig, devOutDir);
+    }
+    if (initialFiles.length > 0) {
+        console.log(`  ${initialFiles.length} file(s) compiled.\n`);
+    }
+    // Watch for changes
+    import('chokidar').then(({ watch }) => {
+        const globPattern = watchPattern
+            ? resolve(watchDir, watchPattern)
+            : resolve(watchDir, '**/*.kern');
+        const watcher = watch(globPattern, {
+            ignoreInitial: true,
+            awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+        });
+        watcher.on('change', (filePath) => {
+            const rel = relative(process.cwd(), filePath);
+            const start = performance.now();
+            try {
+                transpileAndWrite(filePath, devConfig, devOutDir);
+                const ms = Math.round(performance.now() - start);
+                console.log(`  ${rel} → compiled (${ms}ms)`);
+            }
+            catch (err) {
+                console.error(`  ${rel} → ERROR: ${err.message}`);
+            }
+        });
+        watcher.on('add', (filePath) => {
+            const rel = relative(process.cwd(), filePath);
+            const start = performance.now();
+            try {
+                transpileAndWrite(filePath, devConfig, devOutDir);
+                const ms = Math.round(performance.now() - start);
+                console.log(`  ${rel} → compiled (${ms}ms)`);
+            }
+            catch (err) {
+                console.error(`  ${rel} → ERROR: ${err.message}`);
+            }
+        });
+        watcher.on('unlink', (filePath) => {
+            const rel = relative(process.cwd(), filePath);
+            const ext = filePath.endsWith('.kern') ? '.kern' : '.ir';
+            const fileBaseName = basename(filePath, ext);
+            const outDir = resolve(devOutDir ? resolve(devOutDir) : dirname(filePath), devConfig.output.outDir);
+            const outExt = (devConfig.target === 'vue' || devConfig.target === 'nuxt') ? '.vue'
+                : (devConfig.target === 'express' || devConfig.target === 'cli' || devConfig.target === 'terminal') ? '.ts' : '.tsx';
+            const outFile = resolve(outDir, `${fileBaseName}${outExt}`);
+            try {
+                if (existsSync(outFile)) {
+                    unlinkSync(outFile);
+                    console.log(`  ${rel} → deleted generated file`);
+                }
+            }
+            catch (err) {
+                console.error(`  ${rel} → ERROR deleting: ${err.message}`);
+            }
+        });
+        console.log('  Watching for changes... (Ctrl+C to stop)\n');
+    }).catch((err) => {
+        console.error(`kern dev requires chokidar: npm install chokidar`);
+        process.exit(1);
+    });
+    // Keep process alive
+    process.on('SIGINT', () => {
+        console.log('\n  KERN dev stopped.');
+        process.exit(0);
+    });
+    // Don't fall through to standard transpile
+    // Keep event loop running by not calling process.exit()
+    await new Promise(() => { }); // eslint-disable-line @typescript-eslint/no-empty-function
+}
+function findNearestPackageJson(startDir) {
+    let dir = startDir;
+    while (true) {
+        const candidate = resolve(dir, 'package.json');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null; // hit root
+        dir = parent;
+    }
+}
+function findKernFiles(dir, singleFile) {
+    if (singleFile)
+        return [resolve(dir, singleFile)];
+    const files = [];
+    function walk(d) {
+        for (const entry of readdirSync(d)) {
+            const full = resolve(d, entry);
+            const s = statSync(full);
+            if (s.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules' && entry !== 'dist') {
+                walk(full);
+            }
+            else if (entry.endsWith('.kern')) {
+                files.push(full);
+            }
+        }
+    }
+    walk(dir);
+    return files;
+}
+function transpileAndWrite(file, cfg, outDirOverride) {
+    const source = readFileSync(file, 'utf-8');
+    const ast = parse(source);
+    const ext = file.endsWith('.kern') ? '.kern' : '.ir';
+    const name = basename(file, ext);
+    const target = cfg.target;
+    const relSource = relative(process.cwd(), file);
+    const header = GENERATED_HEADER + relSource + '\n\n';
+    const result = target === 'native'
+        ? transpile(ast, cfg)
+        : target === 'web'
+            ? transpileWeb(ast, cfg)
+            : target === 'tailwind'
+                ? transpileTailwind(ast, cfg)
+                : target === 'express'
+                    ? transpileExpress(ast, cfg)
+                    : target === 'cli'
+                        ? transpileCliApp(ast, cfg)
+                        : target === 'terminal'
+                            ? transpileTerminal(ast, cfg)
+                            : target === 'vue'
+                                ? transpileVue(ast, cfg)
+                                : target === 'nuxt'
+                                    ? transpileNuxt(ast, cfg)
+                                    : transpileNextjs(ast, cfg);
+    const outDir = resolve(outDirOverride ? resolve(outDirOverride) : dirname(file), cfg.output.outDir);
+    mkdirSync(outDir, { recursive: true });
+    if (result.artifacts && result.artifacts.length > 0 && cfg.structure !== 'flat') {
+        for (const artifact of result.artifacts) {
+            const artifactPath = resolve(outDir, artifact.path);
+            mkdirSync(dirname(artifactPath), { recursive: true });
+            writeFileSync(artifactPath, header + artifact.content);
+        }
+    }
+    else {
+        const outExt = (target === 'vue' || target === 'nuxt') ? '.vue'
+            : (target === 'express' || target === 'cli' || target === 'terminal') ? '.ts' : '.tsx';
+        // For Next.js target, use the file convention name from the transpiler result (page.tsx, layout.tsx, etc.)
+        const resultWithFiles = result;
+        const outFileName = (target === 'nextjs' && resultWithFiles.files && resultWithFiles.files.length > 0)
+            ? resultWithFiles.files[0].path
+            : `${name}${outExt}`;
+        writeFileSync(resolve(outDir, outFileName), header + result.code);
+        if (result.artifacts) {
+            for (const artifact of result.artifacts) {
+                const artifactPath = resolve(outDir, artifact.path);
+                mkdirSync(dirname(artifactPath), { recursive: true });
+                writeFileSync(artifactPath, header + artifact.content);
+            }
+        }
+    }
+}
+function loadConfig() {
+    const configPath = resolve(process.cwd(), 'kern.config.ts');
+    if (existsSync(configPath)) {
+        try {
+            const jiti = createJiti(import.meta.url);
+            const mod = jiti(configPath);
+            const userConfig = mod.default ?? mod;
+            return resolveConfig(userConfig);
+        }
+        catch (err) {
+            console.error(`Warning: Failed to load kern.config.ts: ${err.message}`);
+            return resolveConfig({});
+        }
+    }
+    return resolveConfig({});
+}
+function loadTemplates(cfg) {
+    clearTemplates();
+    if (!cfg.templates || cfg.templates.length === 0)
+        return;
+    for (const templatePath of cfg.templates) {
+        const resolved = resolve(process.cwd(), templatePath);
+        if (!existsSync(resolved))
+            continue;
+        const stat = statSync(resolved);
+        const files = [];
+        if (stat.isDirectory()) {
+            for (const entry of readdirSync(resolved)) {
+                if (entry.endsWith('.kern'))
+                    files.push(resolve(resolved, entry));
+            }
+        }
+        else if (resolved.endsWith('.kern')) {
+            files.push(resolved);
+        }
+        for (const file of files) {
+            try {
+                const source = readFileSync(file, 'utf-8');
+                const ast = parse(source);
+                // Register top-level template nodes
+                const nodes = ast.type === 'template' ? [ast] : (ast.children || []).filter(n => n.type === 'template');
+                for (const node of nodes) {
+                    registerTemplate(node, file);
+                }
+            }
+            catch (err) {
+                console.error(`  Warning: Failed to load template ${basename(file)}: ${err.message}`);
+            }
+        }
+    }
+}
+// ── kern compile <dir|file> --outdir=<dir> ────────────────────────────
+if (args[0] === 'compile') {
+    const compileInput = args[1];
+    const outDirArg = args.find(a => a.startsWith('--outdir='))?.split('=')[1];
+    if (!compileInput) {
+        console.error('Usage: kern compile <file.kern|dir> --outdir=<dir>');
+        process.exit(1);
+    }
+    const outDir = resolve(outDirArg || 'generated');
+    mkdirSync(outDir, { recursive: true });
+    const inputPath = resolve(compileInput);
+    const stat = existsSync(inputPath) ? statSync(inputPath) : null;
+    const kernFiles = [];
+    if (stat && stat.isDirectory()) {
+        for (const f of readdirSync(inputPath)) {
+            if (f.endsWith('.kern'))
+                kernFiles.push(resolve(inputPath, f));
+        }
+    }
+    else if (stat && stat.isFile()) {
+        kernFiles.push(inputPath);
+    }
+    else {
+        console.error(`Not found: ${compileInput}`);
+        process.exit(1);
+    }
+    if (kernFiles.length === 0) {
+        console.error(`No .kern files found in: ${compileInput}`);
+        process.exit(1);
+    }
+    // Load templates from config before compile
+    const compileConfig = loadConfig();
+    loadTemplates(compileConfig);
+    let compiled = 0;
+    for (const file of kernFiles) {
+        const source = readFileSync(file, 'utf-8');
+        const ast = parse(source);
+        const lines = [];
+        let hasReactNodes = false;
+        // Generate TypeScript for all core + React + template nodes (root + children)
+        function processNode(node) {
+            if (isCoreNode(node.type)) {
+                lines.push(...generateCoreNode(node));
+                lines.push('');
+                // hook generates React imports, so flag it
+                if (node.type === 'hook')
+                    hasReactNodes = true;
+            }
+            else if (isTemplateNode(node.type)) {
+                lines.push(...expandTemplateNode(node));
+                lines.push('');
+            }
+            else if (isReactNode(node.type)) {
+                lines.push(...generateReactNode(node));
+                lines.push('');
+                hasReactNodes = true;
+            }
+        }
+        processNode(ast);
+        if (ast.children) {
+            for (const child of ast.children) {
+                processNode(child);
+            }
+        }
+        if (lines.length > 0) {
+            // Use .tsx for files with React nodes (JSX output), .ts otherwise
+            const ext = hasReactNodes ? '.tsx' : '.ts';
+            const outName = basename(file, '.kern') + ext;
+            const outFile = resolve(outDir, outName);
+            writeFileSync(outFile, lines.join('\n') + '\n');
+            console.log(`  ${basename(file)} → ${outName}`);
+            compiled++;
+        }
+        else {
+            console.log(`  ${basename(file)} → (no core nodes, skipped)`);
+        }
+    }
+    console.log(`\nCompiled ${compiled}/${kernFiles.length} files → ${outDir}`);
+    process.exit(0);
+}
+// ── kern scan [--force] [--dry-run] ─────────────────────────────────────
+if (args[0] === 'scan') {
+    const scanCwd = process.cwd();
+    const force = args.includes('--force');
+    const dryRun = args.includes('--dry-run');
+    const result = scanProject(scanCwd);
+    console.log(formatScanSummary(result));
+    if (dryRun) {
+        console.log('  --dry-run: no files written.\n');
+        console.log(generateConfigSource(result));
+        process.exit(0);
+    }
+    const configOutPath = resolve(scanCwd, 'kern.config.ts');
+    if (existsSync(configOutPath) && !force) {
+        console.log('  kern.config.ts already exists. Use --force to overwrite.\n');
+        process.exit(0);
+    }
+    writeFileSync(configOutPath, generateConfigSource(result));
+    console.log('  Written: kern.config.ts\n');
+    process.exit(0);
+}
+// ── kern init-templates [--force] [--dry-run] ───────────────────────────
+if (args[0] === 'init-templates') {
+    const force = args.includes('--force');
+    const dryRun = args.includes('--dry-run');
+    const initCwd = process.cwd();
+    const templatesDir = resolve(initCwd, 'templates');
+    // Find package.json
+    const pkgPath = findNearestPackageJson(initCwd);
+    if (!pkgPath) {
+        console.error('No package.json found. Run this in a project directory.');
+        process.exit(1);
+    }
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    const detected = detectTemplates(pkg);
+    console.log('\n  KERN init-templates — scanning dependencies\n');
+    if (detected.length === 0 && !force) {
+        console.log('  No recognized libraries detected.');
+        console.log('  Common templates (arrow-fn, window-event) will still be created.\n');
+    }
+    // Collect all template files to write
+    const filesToWrite = { ...COMMON_TEMPLATES };
+    for (const entry of detected) {
+        console.log(`  Detected: ${entry.libraryName} (${entry.packageName})`);
+        Object.assign(filesToWrite, entry.templates);
+    }
+    if (dryRun) {
+        console.log(`\n  --dry-run: would create ${Object.keys(filesToWrite).length} template files in templates/\n`);
+        for (const name of Object.keys(filesToWrite).sort()) {
+            console.log(`    templates/${name}`);
+        }
+        process.exit(0);
+    }
+    mkdirSync(templatesDir, { recursive: true });
+    let written = 0;
+    let skipped = 0;
+    for (const [name, content] of Object.entries(filesToWrite)) {
+        const outPath = resolve(templatesDir, name);
+        if (existsSync(outPath) && !force) {
+            console.log(`  skip: templates/${name} (exists, use --force)`);
+            skipped++;
+            continue;
+        }
+        writeFileSync(outPath, content);
+        console.log(`  wrote: templates/${name}`);
+        written++;
+    }
+    // Update kern.config.ts to include templates path
+    const configPath = resolve(initCwd, 'kern.config.ts');
+    if (existsSync(configPath)) {
+        const configContent = readFileSync(configPath, 'utf-8');
+        if (!configContent.includes('templates')) {
+            console.log('\n  Note: Add templates to your kern.config.ts:');
+            console.log("    templates: ['./templates/'],\n");
+        }
+    }
+    else {
+        // Create a minimal kern.config.ts
+        const configSource = [
+            'export default {',
+            "  target: 'web',",
+            "  templates: ['./templates/'],",
+            '};',
+            '',
+        ].join('\n');
+        writeFileSync(configPath, configSource);
+        console.log('  wrote: kern.config.ts');
+        written++;
+    }
+    console.log(`\n  Done: ${written} written, ${skipped} skipped.`);
+    if (detected.length > 0) {
+        console.log(`  Templates ready for: ${detected.map(d => d.libraryName).join(', ')}`);
+    }
+    console.log('');
+    process.exit(0);
+}
+// ── kern review <file|dir|--diff base> [--json] [--recursive] [--enforce] [--min-coverage=N] [--export-kern] [--llm] [--fix] [--lint] ──
+if (args[0] === 'review') {
+    const jsonOutput = args.includes('--json');
+    const recursive = args.includes('--recursive') || args.includes('-r');
+    const enforce = args.includes('--enforce');
+    const exportKern = args.includes('--export-kern');
+    const llmMode = args.includes('--llm');
+    const fixMode = args.includes('--fix');
+    const lintMode = args.includes('--lint');
+    const minCoverageArg = args.find(a => a.startsWith('--min-coverage='))?.split('=')[1];
+    const minCoverage = minCoverageArg ? Number(minCoverageArg) : undefined;
+    const diffBase = args.find(a => a.startsWith('--diff'))
+        ? (args.find(a => a.startsWith('--diff='))?.split('=')[1] || args[args.indexOf('--diff') + 1] || 'origin/main')
+        : undefined;
+    // --diff mode: get changed files from git
+    const reviewInputs = args.filter(a => !a.startsWith('--') && a !== 'review');
+    let reviewInput = reviewInputs[0];
+    if (diffBase && !reviewInput) {
+        try {
+            const { execSync } = await import('child_process');
+            const diffFiles = execSync(`git diff --name-only --diff-filter=ACMR ${diffBase}`, { encoding: 'utf-8' })
+                .trim()
+                .split('\n')
+                .filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))
+                .filter(f => !f.endsWith('.d.ts') && !f.endsWith('.test.ts'));
+            if (diffFiles.length === 0) {
+                console.log('  No changed .ts/.tsx files since ' + diffBase);
+                process.exit(0);
+            }
+            console.log(`  Reviewing ${diffFiles.length} changed files (diff from ${diffBase})\n`);
+            // Process each file individually below
+            reviewInput = '__diff__';
+            globalThis.__diffFiles = diffFiles;
+        }
+        catch (err) {
+            console.error(`  git diff failed: ${err.message}`);
+            process.exit(1);
+        }
+    }
+    if (!reviewInput) {
+        console.error('Usage: kern review <file.ts|dir> [--diff base] [--json] [--recursive] [--enforce] [--min-coverage=N] [--export-kern] [--llm] [--fix]');
+        process.exit(1);
+    }
+    // Skip stat check for --diff mode (files are resolved individually below)
+    if (reviewInput !== '__diff__') {
+        const reviewPath = resolve(reviewInput);
+        const stat = existsSync(reviewPath) ? statSync(reviewPath) : null;
+        if (!stat) {
+            console.error(`Not found: ${reviewInput}`);
+            process.exit(1);
+        }
+    }
+    // Load kern.config.ts to get registered templates and target
+    const reviewCfg = loadConfig();
+    const reviewConfig = {
+        registeredTemplates: [],
+        minCoverage: minCoverage ?? 0,
+        enforceTemplates: enforce,
+        target: reviewCfg.target,
+    };
+    // Load templates and collect their names
+    if (reviewCfg.templates && reviewCfg.templates.length > 0) {
+        clearTemplates();
+        for (const templatePath of reviewCfg.templates) {
+            const resolvedTpl = resolve(process.cwd(), templatePath);
+            if (!existsSync(resolvedTpl))
+                continue;
+            const tplStat = statSync(resolvedTpl);
+            const tplFiles = [];
+            if (tplStat.isDirectory()) {
+                for (const entry of readdirSync(resolvedTpl)) {
+                    if (entry.endsWith('.kern'))
+                        tplFiles.push(resolve(resolvedTpl, entry));
+                }
+            }
+            else if (resolvedTpl.endsWith('.kern')) {
+                tplFiles.push(resolvedTpl);
+            }
+            for (const file of tplFiles) {
+                try {
+                    const source = readFileSync(file, 'utf-8');
+                    const ast = parse(source);
+                    const nodes = ast.type === 'template' ? [ast] : (ast.children || []).filter(n => n.type === 'template');
+                    for (const node of nodes) {
+                        const tplName = node.props?.name;
+                        if (tplName)
+                            reviewConfig.registeredTemplates.push(tplName);
+                        registerTemplate(node, file);
+                    }
+                }
+                catch { }
+            }
+        }
+        if (reviewConfig.registeredTemplates.length > 0) {
+            console.log(`  Templates loaded: ${reviewConfig.registeredTemplates.join(', ')}`);
+        }
+    }
+    // Collect reports from diff, directory, or single file
+    let reports = [];
+    if (reviewInput === '__diff__') {
+        const diffFiles = globalThis.__diffFiles;
+        for (const f of diffFiles) {
+            const fullPath = resolve(f);
+            if (existsSync(fullPath)) {
+                try {
+                    reports.push(reviewFile(fullPath, reviewConfig));
+                }
+                catch { }
+            }
+        }
+    }
+    else {
+        // Support multiple positional paths: kern review file1.ts file2.ts dir/
+        const paths = reviewInputs.length > 0 ? reviewInputs : [reviewInput];
+        for (const p of paths) {
+            const rPath = resolve(p);
+            if (!existsSync(rPath))
+                continue;
+            const rStat = statSync(rPath);
+            if (rStat.isDirectory()) {
+                reports.push(...reviewDirectory(rPath, recursive, reviewConfig));
+            }
+            else {
+                try {
+                    reports.push(reviewFile(rPath, reviewConfig));
+                }
+                catch { }
+            }
+        }
+    }
+    if (reports.length === 0) {
+        console.log('  No .ts/.tsx files found to review.');
+        process.exit(0);
+    }
+    // --export-kern: output KERN IR for AI review (v1 compat)
+    if (exportKern) {
+        for (const report of reports) {
+            console.log(`\n// ── ${report.filePath} ──`);
+            console.log(exportKernIR(report.inferred, report.templateMatches));
+        }
+        process.exit(0);
+    }
+    // --llm: output structured LLM prompt with nodeId aliases
+    if (llmMode) {
+        for (const report of reports) {
+            console.log(`\n// ── ${report.filePath} ──`);
+            console.log(buildLLMPrompt(report.inferred, report.templateMatches));
+        }
+        console.log('\n// Paste the JSON response from your AI to validate and map findings back to TS.');
+        process.exit(0);
+    }
+    // --fix: auto-migration — write .kern files from template suggestions, verify roundtrip
+    if (fixMode) {
+        let fixed = 0;
+        let verified = 0;
+        for (const report of reports) {
+            for (const t of report.templateMatches) {
+                if (!t.suggestedKern)
+                    continue;
+                const kernFileName = report.filePath.replace(/\.tsx?$/, '.kern');
+                try {
+                    writeFileSync(kernFileName, t.suggestedKern + '\n');
+                    // Verify roundtrip: parse the written .kern file
+                    try {
+                        parse(readFileSync(kernFileName, 'utf-8'));
+                        console.log(`  ${report.filePath} → ${kernFileName} (verified)`);
+                        verified++;
+                    }
+                    catch (parseErr) {
+                        console.error(`  ${kernFileName} written but parse failed: ${parseErr.message}`);
+                    }
+                    fixed++;
+                }
+                catch (err) {
+                    console.error(`  Failed to write ${kernFileName}: ${err.message}`);
+                }
+            }
+        }
+        if (fixed === 0) {
+            console.log('  No template suggestions to fix — nothing to migrate.');
+        }
+        else {
+            console.log(`\n  ${fixed} .kern file(s) written, ${verified} verified.`);
+        }
+        process.exit(0);
+    }
+    // --lint: run ESLint + tsc diagnostics and merge into findings
+    if (lintMode) {
+        const filePaths = reports.map(r => r.filePath).filter(f => existsSync(f));
+        // ESLint pass
+        const eslintFindings = await runESLint(filePaths, process.cwd());
+        if (eslintFindings.length > 0) {
+            console.log(`  ESLint: ${eslintFindings.length} findings`);
+            for (const report of reports) {
+                const fileFindings = eslintFindings.filter(f => f.primarySpan.file === report.filePath);
+                const linked = linkToNodes(fileFindings, report.inferred);
+                report.findings = dedup([...report.findings, ...linked]);
+            }
+        }
+        else {
+            console.log('  ESLint: no findings (or not installed)');
+        }
+        // tsc pass
+        const tscFindings = runTSCDiagnosticsFromPaths(filePaths);
+        if (tscFindings.length > 0) {
+            console.log(`  tsc: ${tscFindings.length} findings`);
+            for (const report of reports) {
+                const fileFindings = tscFindings.filter(f => f.primarySpan.file === report.filePath);
+                const linked = linkToNodes(fileFindings, report.inferred);
+                report.findings = dedup([...report.findings, ...linked]);
+            }
+        }
+        else {
+            console.log('  tsc: no findings');
+        }
+    }
+    if (jsonOutput) {
+        console.log(JSON.stringify(reports.length === 1 ? reports[0] : reports, null, 2));
+    }
+    else {
+        for (const report of reports) {
+            console.log('');
+            console.log(formatReport(report));
+        }
+        if (reports.length > 1) {
+            console.log('');
+            console.log(formatSummary(reports));
+        }
+        // Enforcement
+        if (enforce || minCoverage !== undefined) {
+            console.log('');
+            let allPassed = true;
+            for (const report of reports) {
+                const result = checkEnforcement(report, reviewConfig);
+                if (!result.passed) {
+                    allPassed = false;
+                    console.log(formatEnforcement(result));
+                }
+            }
+            if (allPassed) {
+                console.log(`  Enforcement: PASS (all files)`);
+            }
+            else {
+                process.exit(1);
+            }
+        }
+    }
+    process.exit(0);
+}
+// ── Standard transpile mode ────────────────────────────────────────────
+const inputFile = args.find(a => !a.startsWith('--'));
+if (!inputFile) {
+    console.log('Usage: kern <file.kern> [--target=nextjs|tailwind|web|native|express|cli] [options]');
+    console.log('');
+    console.log('Commands:');
+    console.log('  dev <dir|file> [--target=...] [--outdir=...]  Watch & hot-transpile .kern files');
+    console.log('  compile <dir|file> --outdir=<dir>             Compile .kern → .ts (core nodes)');
+    console.log('  scan [--force] [--dry-run]                    Detect project → generate kern.config.ts');
+    console.log('  init-templates [--force] [--dry-run]          Scan deps → scaffold template .kern files');
+    console.log('  review <file.ts|dir> [options]                Analyze TS → infer .kern coverage + review');
+    console.log('');
+    console.log('Targets:');
+    console.log('  nextjs    Next.js App Router (default)');
+    console.log('  tailwind  React + Tailwind CSS');
+    console.log('  web       React with inline styles');
+    console.log('  vue       Vue 3 Single File Component');
+    console.log('  nuxt      Nuxt 3 (pages, layouts, server routes)');
+    console.log('  native    React Native component');
+    console.log('  express   Express TypeScript backend');
+    console.log('  cli       Commander.js CLI app');
+    console.log('  terminal  ANSI terminal rendering');
+    console.log('');
+    console.log('Options:');
+    console.log('  --structure=flat|bulletproof|atomic|kern  Output structure pattern (React targets)');
+    console.log('  --decompile  Output human-readable pseudocode');
+    console.log('  --minify     Output minified single-line Kern (LLM wire format)');
+    console.log('  --pretty     Expand minified Kern back to indented format');
+    console.log('  --metrics    Show language metrics (escape ratio, coverage, etc.)');
+    console.log('');
+    console.log('Structures (React targets only):');
+    console.log('  flat         Single .tsx file (default)');
+    console.log('  bulletproof  Feature-based folder structure');
+    console.log('  atomic       Atomic Design hierarchy (pages/templates/organisms/molecules/atoms)');
+    console.log('  kern         KERN-native (surfaces/blocks/signals/tokens/models)');
+    process.exit(1);
+}
+// ── Load config via jiti (supports .ts config at runtime) ────────────────
+let config;
+const configPath = resolve(process.cwd(), 'kern.config.ts');
+if (existsSync(configPath)) {
+    try {
+        const jiti = createJiti(import.meta.url);
+        const mod = jiti(configPath);
+        const userConfig = mod.default ?? mod;
+        config = resolveConfig(userConfig);
+    }
+    catch (err) {
+        console.error(`Warning: Failed to load kern.config.ts: ${err.message}`);
+        config = resolveConfig({});
+    }
+}
+else {
+    config = resolveConfig({});
+}
+// Load templates before transpile
+loadTemplates(config);
+// CLI flags override config — target
+const cliTarget = args.find(a => a.startsWith('--target='))?.split('=')[1];
+if (cliTarget) {
+    if (!VALID_TARGETS.includes(cliTarget)) {
+        console.error(`Unknown target: '${cliTarget}'. Valid targets: ${VALID_TARGETS.join(', ')}`);
+        process.exit(1);
+    }
+    config = { ...config, target: cliTarget };
+}
+const target = config.target;
+// CLI flags override config — structure
+const cliStructure = args.find(a => a.startsWith('--structure='))?.split('=')[1];
+if (cliStructure) {
+    if (!VALID_STRUCTURES.includes(cliStructure)) {
+        console.error(`Unknown structure: '${cliStructure}'. Valid structures: ${VALID_STRUCTURES.join(', ')}`);
+        process.exit(1);
+    }
+    config = { ...config, structure: cliStructure };
+}
+const irSource = readFileSync(resolve(inputFile), 'utf-8');
+const ast = parse(irSource);
+const ext = inputFile.endsWith('.kern') ? '.kern' : '.ir';
+const name = basename(inputFile, ext);
+// ── Minify: indented Kern → single-line wire format ─────────────────────
+if (args.includes('--minify')) {
+    const minified = minifyKern(ast);
+    const outFile = resolve(dirname(inputFile), `${name}.min.kern`);
+    writeFileSync(outFile, minified);
+    const savings = Math.round((1 - minified.length / irSource.length) * 100);
+    console.log(`Minified: ${inputFile} → ${outFile}`);
+    console.log(`Chars:    ${irSource.length} → ${minified.length} (${savings}% smaller)`);
+    process.exit(0);
+}
+// ── Pretty: re-indent (useful after minify or messy edits) ──────────────
+if (args.includes('--pretty')) {
+    const pretty = prettyKern(ast);
+    const outFile = resolve(dirname(inputFile), `${name}.kern`);
+    writeFileSync(outFile, pretty);
+    console.log(`Formatted: ${inputFile} → ${outFile}`);
+    process.exit(0);
+}
+// ── Decompile: Kern → human-readable pseudocode ─────────────────────────
+if (args.includes('--decompile')) {
+    const result = decompile(ast);
+    console.log(result.code);
+    process.exit(0);
+}
+// ── Metrics: analyze language coverage ────────────────────────────────────
+if (args.includes('--metrics')) {
+    const metrics = collectLanguageMetrics(ast);
+    console.log(`Metrics: ${inputFile}`);
+    console.log(`  Nodes:        ${metrics.nodeCount} (${metrics.nodeTypes.length} types)`);
+    console.log(`  Styles:       ${metrics.styleMetrics.totalStyleDecls} declarations`);
+    console.log(`  Mapped:       ${metrics.styleMetrics.mappedStyleDecls} (${Math.round((1 - metrics.styleMetrics.escapeRatio) * 100)}%)`);
+    console.log(`  Escaped:      ${metrics.styleMetrics.escapedStyleDecls} (${Math.round(metrics.styleMetrics.escapeRatio * 100)}%)`);
+    if (metrics.styleMetrics.escapedKeys.length > 0) {
+        console.log(`  Escape keys:  ${metrics.styleMetrics.escapedKeys.join(', ')}`);
+    }
+    console.log(`  Shorthand:    ${Math.round(metrics.shorthandCoverage * 100)}% coverage`);
+    console.log(`  Theme refs:   ${metrics.themeRefCount}`);
+    console.log(`  Pseudo:       ${metrics.pseudoStyleCount}`);
+    if (metrics.unknownNodeCount > 0) {
+        console.log(`  Unknown nodes: ${metrics.unknownNodeCount}`);
+    }
+    console.log('');
+    console.log('  Node types:');
+    for (const nt of metrics.nodeTypes.slice(0, 10)) {
+        console.log(`    ${nt.type}: ${nt.count} (${nt.styleDecls} styles)`);
+    }
+    process.exit(0);
+}
+// ── Transpile: Kern → target code ───────────────────────────────────────
+const result = target === 'native'
+    ? transpile(ast, config)
+    : target === 'web'
+        ? transpileWeb(ast, config)
+        : target === 'tailwind'
+            ? transpileTailwind(ast, config)
+            : target === 'express'
+                ? transpileExpress(ast, config)
+                : target === 'cli'
+                    ? transpileCliApp(ast, config)
+                    : target === 'terminal'
+                        ? transpileTerminal(ast, config)
+                        : target === 'vue'
+                            ? transpileVue(ast, config)
+                            : target === 'nuxt'
+                                ? transpileNuxt(ast, config)
+                                : transpileNextjs(ast, config);
+const outDir = resolve(dirname(inputFile), config.output.outDir);
+const isStructured = config.structure !== 'flat' && result.artifacts && result.artifacts.length > 0;
+if (isStructured) {
+    // Structured output: write all artifacts, entry code comes from artifacts
+    for (const artifact of result.artifacts) {
+        const artifactPath = resolve(outDir, artifact.path);
+        mkdirSync(dirname(artifactPath), { recursive: true });
+        writeFileSync(artifactPath, artifact.content);
+    }
+    // Find entry file path for display
+    const entryArtifact = result.artifacts.find(a => a.type === 'entry' || a.type === 'page');
+    const displayPath = entryArtifact ? resolve(outDir, entryArtifact.path) : resolve(outDir, `${name}.tsx`);
+    console.log(`Transpiled: ${inputFile} → ${displayPath}`);
+}
+else {
+    // Flat output: single file
+    const outExt = (target === 'vue' || target === 'nuxt') ? '.vue'
+        : (target === 'express' || target === 'cli' || target === 'terminal') ? '.ts' : '.tsx';
+    const outFile = resolve(outDir, `${name}${outExt}`);
+    mkdirSync(dirname(outFile), { recursive: true });
+    writeFileSync(outFile, result.code);
+    if (result.artifacts) {
+        for (const artifact of result.artifacts) {
+            const artifactPath = resolve(outDir, artifact.path);
+            mkdirSync(dirname(artifactPath), { recursive: true });
+            writeFileSync(artifactPath, artifact.content);
+        }
+    }
+    console.log(`Transpiled: ${inputFile} → ${outFile}`);
+}
+const targetNames = { native: 'React Native', web: 'React (inline)', tailwind: 'React + Tailwind', nextjs: 'Next.js App Router', express: 'Express TypeScript', cli: 'Commander.js CLI', terminal: 'ANSI Terminal', vue: 'Vue 3 SFC', nuxt: 'Nuxt 3' };
+console.log(`Target:     ${targetNames[target] || target}`);
+if (config.structure !== 'flat') {
+    const structureNames = { bulletproof: 'Bulletproof React', atomic: 'Atomic Design', kern: 'KERN Native' };
+    console.log(`Structure:  ${structureNames[config.structure] || config.structure}`);
+}
+console.log(`IR tokens:  ${result.irTokenCount}`);
+console.log(`TS tokens:  ${result.tsTokenCount}`);
+console.log(`Reduction:  ${result.tokenReduction}%`);
+console.log(`Source map: ${result.sourceMap.length} entries`);
+if (result.artifacts) {
+    console.log(`Artifacts:  ${result.artifacts.length}`);
+}
+// ── Minify/Pretty implementations ───────────────────────────────────────
+function minifyKern(node) {
+    const type = node.type;
+    const props = node.props || {};
+    let head = type;
+    // Serialize props (theme name is bare word, not key=value)
+    for (const [k, v] of Object.entries(props)) {
+        if (['styles', 'pseudoStyles', 'themeRefs'].includes(k))
+            continue;
+        if (type === 'theme' && k === 'name') {
+            head += ` ${v}`;
+            continue;
+        }
+        if (typeof v === 'object' && v !== null && '__expr' in v) {
+            head += ` ${k}={{ ${v.code} }}`;
+            continue;
+        }
+        const val = typeof v === 'string' && v.includes(' ') ? `"${v}"` : String(v);
+        head += ` ${k}=${val}`;
+    }
+    // Serialize styles
+    if (props.styles) {
+        const pairs = Object.entries(props.styles)
+            .map(([k, v]) => v.includes(' ') || v.includes(',') ? `"${k}":"${v}"` : `${k}:${v}`);
+        head += ` {${pairs.join(',')}}`;
+    }
+    // Serialize pseudo styles
+    if (props.pseudoStyles) {
+        const pseudo = props.pseudoStyles;
+        for (const [state, styles] of Object.entries(pseudo)) {
+            for (const [k, v] of Object.entries(styles)) {
+                head += ` {:${state}:${k}:${v}}`;
+            }
+        }
+    }
+    // Theme refs
+    if (props.themeRefs) {
+        for (const ref of props.themeRefs) {
+            head += ` $${ref}`;
+        }
+    }
+    // Children → S-expression style
+    if (node.children && node.children.length > 0) {
+        const kids = node.children.map(c => minifyKern(c)).join(',');
+        return `${head}(${kids})`;
+    }
+    return head;
+}
+function prettyKern(node, indent = '') {
+    const type = node.type;
+    const props = node.props || {};
+    let line = `${indent}${type}`;
+    for (const [k, v] of Object.entries(props)) {
+        if (['styles', 'pseudoStyles', 'themeRefs'].includes(k))
+            continue;
+        if (type === 'theme' && k === 'name') {
+            line += ` ${v}`;
+            continue;
+        }
+        if (typeof v === 'object' && v !== null && '__expr' in v) {
+            line += ` ${k}={{ ${v.code} }}`;
+            continue;
+        }
+        const val = typeof v === 'string' && v.includes(' ') ? `"${v}"` : String(v);
+        line += ` ${k}=${val}`;
+    }
+    if (props.styles) {
+        const pairs = Object.entries(props.styles)
+            .map(([k, v]) => v.includes(' ') || v.includes(',') ? `"${k}":"${v}"` : `${k}:${v}`);
+        line += ` {${pairs.join(',')}}`;
+    }
+    if (props.pseudoStyles) {
+        const pseudo = props.pseudoStyles;
+        for (const [state, styles] of Object.entries(pseudo)) {
+            for (const [k, v] of Object.entries(styles)) {
+                line += `,${`:${state}:${k}:${v}`}`;
+            }
+        }
+    }
+    if (props.themeRefs) {
+        for (const ref of props.themeRefs) {
+            line += ` $${ref}`;
+        }
+    }
+    let result = line + '\n';
+    if (node.children) {
+        for (const child of node.children) {
+            result += prettyKern(child, indent + '  ');
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=cli.js.map