lua-cli 3.15.3 → 3.16.2

package/dist/compiler/compiler.js

@@ -1,706 +0,0 @@
-/**
- * Main Lua Compiler
- *
- * This is the entry point for compilation. It orchestrates:
- * 1. Scanning source files for primitives
- * 2. Validating all primitives
- * 3. Bundling each primitive with esbuild
- * 4. Writing artifacts to disk
- */
-import fs from 'fs/promises';
-import path from 'path';
-import { Project } from 'ts-morph';
-import { pluginRegistry } from './plugins/registry.js';
-import { Bundler } from './bundler.js';
-import { AgentTraverser } from './agent-traverser.js';
-import { shouldSkipFile, shouldSkipDirectory, hashContent, formatSize, isInside, classifyProjectFile, } from './utils/common.js';
-import { findWorkspaceRoot } from './utils/workspace.js';
-import { registerProjectRootDir } from './utils/path-resolver.js';
-import { ensureSchemaConverterReady, SchemaConverterUnavailableError } from './utils/schema-converter.js';
-import { COMPILER_VERSION, } from './types.js';
-// Re-export types for consumers
-export * from './types.js';
-// =============================================================================
-// COMPILER
-// =============================================================================
-export class Compiler {
-    constructor(options) {
-        /**
-         * Absolute paths of source files loaded by `AgentTraverser` that live
-         * outside `rootDir` but inside the containing workspace.
-         *
-         * Populated during `scanForPrimitives()` and consumed by
-         * `collectProjectFiles()` so cross-root files are included in the
-         * backup manifest. See BAC-69 and [workspace.ts](src/compiler/utils/workspace.ts).
-         */
-        this.externalWorkspaceFiles = [];
-        this.options = {
-            sourceMaps: true,
-            minify: true,
-            debug: false,
-            verbose: false,
-            quietWarnings: false,
-            runtimeValidation: true,
-            ...options,
-        };
-        this.project = new Project({
-            tsConfigFilePath: path.join(options.rootDir, 'tsconfig.json'),
-        });
-        // Associate this Project with its rootDir so plugin code that only
-        // has a SourceFile/Project in hand (SkillPlugin's extractToolRefs,
-        // the reference resolver's tsconfig-paths lookup) can recover the
-        // correct rootDir without us threading it through every API.
-        registerProjectRootDir(this.project, this.options.rootDir);
-        this.bundler = new Bundler({
-            outDir: this.options.outDir,
-            minify: this.options.minify,
-            sourceMaps: this.options.sourceMaps,
-            debug: this.options.debug,
-        }, this.project, (msg) => this.verbose(msg));
-    }
-    /**
-     * Run the compilation.
-     */
-    async compile() {
-        const startTime = Date.now();
-        const errors = [];
-        const warnings = [];
-        const compiledPrimitives = [];
-        try {
-            // Preflight: load the bundled zod runtime once so a broken lua-cli
-            // installation fails loudly here, before we iterate primitives and
-            // silently ship a manifest with empty `inputSchema`s. Without this
-            // check, every per-primitive schema conversion would throw and the
-            // plugin's catch would degrade each tool to no schema, producing a
-            // "successful" build of an unusable agent.
-            try {
-                await ensureSchemaConverterReady();
-            }
-            catch (err) {
-                if (err instanceof SchemaConverterUnavailableError) {
-                    errors.push({
-                        file: 'lua-cli',
-                        message: err.message,
-                        suggestion: err.suggestion,
-                    });
-                    return await this.createResult(false, [], errors, warnings, startTime);
-                }
-                throw err;
-            }
-            // Step 1: Scan for primitives
-            this.verbose('📁 Scanning source files...');
-            const allMetadata = await this.scanForPrimitives();
-            if (allMetadata.length === 0) {
-                warnings.push({
-                    file: this.options.rootDir,
-                    message: 'No primitives found. Make sure you export primitives using define functions.',
-                });
-            }
-            // Step 2: Validate
-            this.verbose('✅ Validating primitives...');
-            for (const metadata of allMetadata) {
-                const plugin = pluginRegistry.get(metadata.kind);
-                if (!plugin) {
-                    errors.push({
-                        primitive: metadata.name,
-                        kind: metadata.kind,
-                        file: metadata.sourcePath,
-                        line: metadata.line,
-                        message: `Unknown primitive kind: ${metadata.kind}`,
-                    });
-                    continue;
-                }
-                const result = plugin.validate(metadata);
-                errors.push(...result.errors.map((e) => ({
-                    primitive: metadata.name,
-                    kind: metadata.kind,
-                    file: metadata.sourcePath,
-                    line: e.line || metadata.line,
-                    column: e.column,
-                    message: e.message,
-                    suggestion: e.suggestion,
-                })));
-                if (!this.options.quietWarnings) {
-                    warnings.push(...result.warnings.map((w) => ({
-                        primitive: metadata.name,
-                        kind: metadata.kind,
-                        file: metadata.sourcePath,
-                        line: w.line || metadata.line,
-                        message: w.message,
-                    })));
-                }
-            }
-            // Stop if validation errors
-            if (errors.length > 0) {
-                return await this.createResult(false, [], errors, warnings, startTime);
-            }
-            // Step 3: Compile each primitive (parallel with concurrency limit)
-            this.verbose('📦 Bundling primitives...');
-            // Ensure output directory exists
-            await fs.mkdir(this.options.outDir, { recursive: true });
-            await fs.mkdir(path.join(this.options.outDir, '.temp'), { recursive: true });
-            // Compile in parallel with concurrency limit
-            const CONCURRENCY = 4;
-            const compileResults = await this.compileInParallel(allMetadata, CONCURRENCY);
-            for (const result of compileResults) {
-                if ('error' in result) {
-                    errors.push({
-                        primitive: result.metadata.name,
-                        kind: result.metadata.kind,
-                        file: result.metadata.sourcePath,
-                        message: `Compilation failed: ${result.error.message}`,
-                    });
-                }
-                else if (result.compiled) {
-                    compiledPrimitives.push(result.compiled);
-                }
-            }
-            // Step 4: Write artifacts
-            this.verbose('💾 Writing artifacts...');
-            await this.writeArtifacts(compiledPrimitives);
-            // Step 5: Clean up temp files (unless debug mode)
-            if (!this.options.debug) {
-                await fs.rm(path.join(this.options.outDir, '.temp'), { recursive: true, force: true });
-            }
-            return await this.createResult(true, compiledPrimitives, errors, warnings, startTime);
-        }
-        catch (error) {
-            errors.push({
-                file: 'compiler',
-                message: `Unexpected error: ${error.message}`,
-            });
-            return await this.createResult(false, [], errors, warnings, startTime);
-        }
-    }
-    /**
-     * Scan for primitives using agent traversal (preferred) or fallback to full scan.
-     *
-     * Agent traversal only compiles primitives that are actually registered with
-     * a LuaAgent, matching the old compiler's behavior.
-     *
-     * Also caches the agent info for manifest creation (avoids re-traversing).
-     */
-    async scanForPrimitives() {
-        // Try agent traversal first
-        const traverser = new AgentTraverser(this.options.rootDir, this.options.debug);
-        const primitives = await traverser.traverse();
-        // Capture any cross-root files the resolver pulled in, scoped to the
-        // containing workspace. These are backed up alongside in-project files
-        // so `lua init --from-server` can rebuild monorepo agents end-to-end.
-        this.externalWorkspaceFiles = this.collectExternalWorkspaceFiles(traverser);
-        if (primitives && primitives.length > 0) {
-            this.verbose(`🤖 Agent detected with ${primitives.length} primitives`);
-            if (this.externalWorkspaceFiles.length > 0) {
-                this.verbose(`   🌳 Cross-root workspace files: ${this.externalWorkspaceFiles.length}`);
-            }
-            return primitives;
-        }
-        // Fallback: scan all files (for projects without LuaAgent)
-        this.verbose(`⚠️  No LuaAgent found, scanning all source files...`);
-        return this.scanAllFiles();
-    }
-    /**
-     * Resolve the containing workspace root for this compilation, memoized
-     * for the lifetime of the Compiler instance. Returns the normalized
-     * absolute path; for standalone agents it's identical to `rootDir`.
-     */
-    getWorkspaceRoot() {
-        if (this._workspaceRoot === undefined) {
-            this._workspaceRoot = findWorkspaceRoot(path.resolve(this.options.rootDir));
-        }
-        return this._workspaceRoot;
-    }
-    /**
-     * Return absolute paths of files the traverser loaded that live outside
-     * `rootDir` but inside the containing workspace.
-     *
-     * We deliberately skip:
-     *  - Files under `rootDir` (the normal `collectProjectFiles` walker handles them)
-     *  - Files inside `node_modules` (third-party; restored via `npm install`)
-     *  - Files outside the detected workspace root (not our code)
-     */
-    collectExternalWorkspaceFiles(traverser) {
-        const rootDir = path.resolve(this.options.rootDir);
-        const workspaceRoot = this.getWorkspaceRoot();
-        // Standalone agent: no workspace boundary, nothing to capture.
-        if (workspaceRoot === rootDir)
-            return [];
-        const loaded = traverser.getAllLoadedSourceFilePaths();
-        const result = [];
-        const seen = new Set();
-        for (const raw of loaded) {
-            const abs = path.resolve(raw);
-            if (seen.has(abs))
-                continue;
-            seen.add(abs);
-            if (isInside(abs, rootDir))
-                continue;
-            if (abs.includes(`${path.sep}node_modules${path.sep}`))
-                continue;
-            if (!isInside(abs, workspaceRoot))
-                continue;
-            result.push(abs);
-        }
-        return result;
-    }
-    /**
-     * Fallback discovery: scan all source files for primitives when no LuaAgent is found.
-     *
-     * Unlike agent traversal (which only compiles registered primitives), this method
-     * runs every plugin on every source file to discover ALL primitive-like code:
-     * - ToolPlugin: defineTool() OR classes extending/implementing LuaTool
-     * - JobPlugin: defineJob() OR new LuaJob({...})
-     * - WebhookPlugin: defineWebhook() OR new LuaWebhook({...})
-     * - PreProcessorPlugin: definePreProcessor() OR new PreProcessor({...})
-     * - PostProcessorPlugin: definePostProcessor() OR new PostProcessor({...})
-     * - McpServerPlugin: defineMCPServer() OR new LuaMCPServer({...})
-     *
-     * This is less precise and may include unused primitives, but necessary for
-     * projects that don't use the LuaAgent pattern.
-     *
-     * @returns All detected primitive metadata from the entire codebase
-     */
-    scanAllFiles() {
-        const allMetadata = [];
-        const sourceFiles = this.project.getSourceFiles();
-        for (const sourceFile of sourceFiles) {
-            const filePath = sourceFile.getFilePath();
-            // Skip files we don't want to scan
-            if (shouldSkipFile(filePath))
-                continue;
-            // Run all plugins on this file
-            for (const plugin of pluginRegistry.getAll()) {
-                try {
-                    const metadata = plugin.detect(sourceFile);
-                    allMetadata.push(...metadata);
-                }
-                catch (error) {
-                    if (this.options.debug) {
-                        console.warn(`Warning: Plugin ${plugin.kind} failed on ${filePath}:`, error);
-                    }
-                }
-            }
-        }
-        return allMetadata;
-    }
-    /**
-     * Compile primitives in parallel with a concurrency limit.
-     * Returns results in the same order as input, with either compiled primitive or error.
-     */
-    async compileInParallel(allMetadata, concurrency) {
-        const results = [];
-        // Process in batches of `concurrency`
-        for (let i = 0; i < allMetadata.length; i += concurrency) {
-            const batch = allMetadata.slice(i, i + concurrency);
-            const batchResults = await Promise.all(batch.map(async (metadata) => {
-                const plugin = pluginRegistry.get(metadata.kind);
-                if (plugin) {
-                    this.verbose(`   📦 ${plugin.displayName}: ${metadata.name}`);
-                }
-                try {
-                    const compiled = await this.compilePrimitive(metadata);
-                    return { compiled, metadata };
-                }
-                catch (error) {
-                    return { error, metadata };
-                }
-            }));
-            results.push(...batchResults);
-        }
-        return results;
-    }
-    /**
-     * Compile a single primitive through the full pipeline.
-     *
-     * The compilation pipeline for each primitive:
-     * 1. Generate entry point code via the plugin
-     * 2. Bundle with esbuild using stdin (no temp entry file) + virtual module plugin
-     * 3. Run plugin's post-processing hook (if any)
-     * 4. Extract schemas via plugin (e.g., Zod → JSON Schema for tools)
-     *
-     * Uses esbuild's stdin option for the entry point and a virtual module plugin
-     * that appends `export { X as __lua_target__ }` to the source file. This
-     * eliminates all temp files while handling non-exported primitives correctly.
-     *
-     * @param metadata - Primitive metadata from detection phase
-     * @returns Compiled primitive with bundled code, schemas, and metadata, or null if plugin not found
-     */
-    async compilePrimitive(metadata) {
-        const plugin = pluginRegistry.get(metadata.kind);
-        if (!plugin)
-            return null;
-        // Metadata-only primitives (e.g. skills) can bypass esbuild entirely.
-        // A plugin may also return undefined to fall through to the default path
-        // (e.g. an agent with a model resolver still needs bundling).
-        if (plugin.buildArtifact) {
-            const directArtifact = await plugin.buildArtifact(metadata);
-            if (directArtifact) {
-                return {
-                    ...metadata,
-                    artifact: directArtifact,
-                    schemas: undefined,
-                };
-            }
-        }
-        // Generate entry point code (imports from source, creates wrapper)
-        const entryPointCode = plugin.generateEntryPoint(metadata);
-        // Bundle with esbuild using stdin + virtual source plugin (no temp files)
-        const artifact = await this.bundler.bundle(metadata, entryPointCode);
-        // Post-process if plugin supports it and runtime validation is enabled
-        const finalArtifact = plugin.postProcess && this.options.runtimeValidation ? plugin.postProcess(artifact, metadata) : artifact;
-        // Extract schemas if plugin supports it
-        const schemas = plugin.extractSchemas ? await plugin.extractSchemas(metadata, this.project) : undefined;
-        return {
-            ...metadata,
-            artifact: finalArtifact,
-            schemas,
-        };
-    }
-    /**
-     * Write all compilation artifacts to disk with full project preservation.
-     *
-     * Output structure:
-     * ```
-     * dist-v2/
-     * ├── artifacts/
-     * │   ├── tool/
-     * │   │   ├── {name}.js      # Bundled code
-     * │   │   ├── {name}.js.map  # Source map
-     * │   │   └── {name}.json    # Metadata (schemas, description, etc.)
-     * │   ├── job/
-     * │   ├── webhook/
-     * │   └── ...
-     * ├── sources/
-     * │   └── {hash}.ts          # Deduplicated source files (by content hash)
-     * └── manifest.json          # Full compilation manifest
-     * ```
-     *
-     * @param primitives - All compiled primitives to write
-     */
-    async writeArtifacts(primitives) {
-        const artifactsDir = path.join(this.options.outDir, 'artifacts');
-        const sourcesDir = path.join(this.options.outDir, 'sources');
-        await fs.mkdir(sourcesDir, { recursive: true });
-        // Track written sources by hash to avoid duplicates
-        const writtenSources = new Map(); // hash -> relativePath
-        // Step 1: Write primitive artifacts (bundles, source maps, metadata)
-        await this.writePrimitiveArtifacts(primitives, artifactsDir, sourcesDir, writtenSources);
-        // Step 2: Collect and store all project files for full reconstruction
-        this.verbose('   📂 Collecting project files...');
-        const projectFiles = await this.storeProjectFiles(sourcesDir, writtenSources);
-        // Step 3: Create and write manifest
-        const manifest = await this.createManifest(primitives, projectFiles);
-        await fs.writeFile(path.join(this.options.outDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
-        this.verbose(`   📦 Total files stored: ${writtenSources.size} (deduplicated)`);
-        this.verbose(`   📁 Project files: ${projectFiles.length}`);
-        if (this.options.verbose || this.options.debug) {
-            this.logTree(primitives);
-        }
-    }
-    /**
-     * Write primitive artifacts: bundles, source maps, and metadata JSON files.
-     */
-    async writePrimitiveArtifacts(primitives, artifactsDir, sourcesDir, writtenSources) {
-        for (const primitive of primitives) {
-            const primitiveDir = path.join(artifactsDir, primitive.kind);
-            await fs.mkdir(primitiveDir, { recursive: true });
-            const baseName = primitive.name;
-            // Write bundle
-            await fs.writeFile(path.join(primitiveDir, `${baseName}.js`), primitive.artifact.code);
-            // Write source map
-            if (primitive.artifact.sourceMap) {
-                await fs.writeFile(path.join(primitiveDir, `${baseName}.js.map`), primitive.artifact.sourceMap);
-            }
-            // Deduplicate and store original source
-            const sourceHash = hashContent(primitive.artifact.originalSource);
-            if (!writtenSources.has(sourceHash)) {
-                const ext = primitive.sourcePath.endsWith('.tsx') ? '.tsx' : '.ts';
-                await fs.writeFile(path.join(sourcesDir, `${sourceHash}${ext}`), primitive.artifact.originalSource);
-                const relativePath = path.relative(this.options.rootDir, primitive.sourcePath);
-                writtenSources.set(sourceHash, relativePath);
-            }
-            // Write metadata JSON. Route `metadata` through the plugin's
-            // sanitizer so build-machine-only fields (e.g. skill's
-            // `toolRefSourcePaths` — absolute paths) never land on disk. The
-            // artifact hash already excludes those, so sanitizing the sidecar
-            // too makes the on-disk footprint fully reproducible.
-            const sidecarPlugin = pluginRegistry.get(primitive.kind);
-            const sidecarMetadata = sidecarPlugin?.sanitizeForPersistence
-                ? sidecarPlugin.sanitizeForPersistence(primitive.metadata)
-                : primitive.metadata;
-            await fs.writeFile(path.join(primitiveDir, `${baseName}.json`), JSON.stringify({
-                kind: primitive.kind,
-                name: primitive.name,
-                description: primitive.description,
-                sourcePath: primitive.sourcePath,
-                sourceHash,
-                schemas: primitive.schemas,
-                metadata: sidecarMetadata,
-                size: primitive.artifact.size,
-                hash: primitive.artifact.hash,
-            }, null, 2));
-        }
-    }
-    /**
-     * Store all project files for full reconstruction (enables `lua init --from-server`).
-     * Returns the list of project files with their hashes.
-     */
-    async storeProjectFiles(sourcesDir, writtenSources) {
-        const projectFiles = [];
-        const allFiles = await this.collectProjectFiles();
-        const workspaceRoot = this.getWorkspaceRoot();
-        for (const file of allFiles) {
-            // External files resolve against the workspace root; in-project files
-            // against `rootDir`. `file.external` decides which base to use.
-            const absPath = file.external
-                ? path.join(workspaceRoot, file.relativePath)
-                : path.join(this.options.rootDir, file.relativePath);
-            const content = await fs.readFile(absPath, 'utf-8');
-            const hash = hashContent(content);
-            // Store if not already stored (deduplication)
-            if (!writtenSources.has(hash)) {
-                const ext = path.extname(file.relativePath) || '.txt';
-                await fs.writeFile(path.join(sourcesDir, `${hash}${ext}`), content);
-                writtenSources.set(hash, file.relativePath);
-            }
-            projectFiles.push({
-                relativePath: file.relativePath,
-                hash,
-                size: content.length,
-                type: file.type,
-                ...(file.external ? { external: true } : {}),
-            });
-        }
-        return projectFiles;
-    }
-    /**
-     * Create the compilation manifest with all metadata.
-     *
-     * Uses cached agent info from scanForPrimitives() to avoid re-traversing.
-     * Delegates to each plugin's toManifestEntry() for type-specific fields.
-     */
-    async createManifest(primitives, projectFiles) {
-        // Extract config file hashes
-        const config = {};
-        const packageJsonFile = projectFiles.find((f) => f.relativePath === 'package.json');
-        if (packageJsonFile)
-            config.packageJson = packageJsonFile.hash;
-        const tsconfigFile = projectFiles.find((f) => f.relativePath === 'tsconfig.json');
-        if (tsconfigFile)
-            config.tsconfigJson = tsconfigFile.hash;
-        const yamlFile = projectFiles.find((f) => f.relativePath === 'lua.skill.yaml');
-        if (yamlFile)
-            config.luaSkillYaml = yamlFile.hash;
-        return {
-            version: COMPILER_VERSION,
-            compiledAt: new Date().toISOString(),
-            primitives: await this.mapPrimitivesToManifest(primitives),
-            projectFiles,
-            config,
-        };
-    }
-    /**
-     * Map compiled primitives to manifest entries using plugins.
-     * Single source of truth for primitive → manifest conversion.
-     */
-    async mapPrimitivesToManifest(primitives) {
-        return Promise.all(primitives.map(async (p) => {
-            const plugin = pluginRegistry.get(p.kind);
-            if (plugin) {
-                return plugin.toManifestEntry(p, primitives);
-            }
-            // Fallback for unknown kinds (should not happen)
-            return {
-                kind: p.kind,
-                name: p.name,
-                description: p.description,
-                path: `artifacts/${p.kind}/${p.name}.js`,
-                sourcePath: p.sourcePath,
-                hash: p.artifact.hash,
-            };
-        }));
-    }
-    /**
-     * Recursively collect all project files for full reconstruction.
-     *
-     * This enables `lua init --from-server` to recreate the exact project structure.
-     *
-     * File categorization:
-     * - 'source': .ts, .tsx, .js files
-     * - 'config': package.json, tsconfig.json, lua.skill.yaml, *.yaml, *.yml, *.json
-     * - 'other': README.md, .env.example, etc.
-     *
-     * Excludes (via shouldSkipDirectory/shouldSkipFile):
-     * - node_modules, dist, .git, coverage, etc.
-     * - test files, declaration files, lock files
-     *
-     * @returns Array of file info with relative paths and categorized types
-     */
-    async collectProjectFiles() {
-        const files = [];
-        const scanDir = async (dir, relativeBase = '') => {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const relativePath = relativeBase ? `${relativeBase}/${entry.name}` : entry.name;
-                const fullPath = path.join(dir, entry.name);
-                // Skip directories we don't want
-                if (entry.isDirectory()) {
-                    if (shouldSkipDirectory(entry.name))
-                        continue;
-                    await scanDir(fullPath, relativePath);
-                    continue;
-                }
-                // Skip files we don't want
-                if (shouldSkipFile(entry.name))
-                    continue;
-                files.push({ relativePath, type: classifyProjectFile(entry.name) });
-            }
-        };
-        await scanDir(this.options.rootDir);
-        // Append cross-root workspace files picked up by the traverser (BAC-69).
-        // These are keyed by their workspace-relative path and marked external so
-        // the restore step can sandbox them under `.lua/external/`.
-        //
-        // Important: dedup external files against each other, *not* against
-        // in-project files. In-project keys are rootDir-relative; external keys
-        // are workspace-relative, and the two namespaces can coincidentally
-        // collide (e.g. rootDir `/ws/packages/agent/src/index.ts` → `src/index.ts`
-        // and workspace-root `/ws/src/index.ts` → `src/index.ts`). A single
-        // shared `Set` would silently drop the external one — the exact class
-        // of silent-drop bug BAC-69 was meant to eliminate. The restore path
-        // uses `file.external` (not the string shape of `relativePath`) to
-        // decide where each entry lands, so co-existing entries with the same
-        // `relativePath` but different `external` flags is safe.
-        const workspaceRoot = this.getWorkspaceRoot();
-        const externalSeen = new Set();
-        for (const abs of this.externalWorkspaceFiles) {
-            const rel = path.relative(workspaceRoot, abs).split(path.sep).join('/');
-            if (!rel || rel.startsWith('..'))
-                continue;
-            if (externalSeen.has(rel))
-                continue;
-            const name = path.basename(abs);
-            // Defense-in-depth: `shouldSkipFile` accepts either a filename or
-            // a full path and checks both the leading-dot rule and path-based
-            // skips (node_modules, .test., .spec., .d.ts, lock files, etc.).
-            // We pass the *relative* path so nested paths that slipped past
-            // the basename-only check upstream are still caught here — any
-            // future refactor that changes how external paths are collected
-            // can't silently leak dotfiles or lock files into the manifest.
-            if (shouldSkipFile(rel) || shouldSkipFile(name))
-                continue;
-            externalSeen.add(rel);
-            files.push({ relativePath: rel, type: classifyProjectFile(name), external: true });
-        }
-        return files;
-    }
-    /**
-     * Log the output directory tree.
-     */
-    logTree(primitives) {
-        this.log(`   ${this.options.outDir}/`);
-        this.log(`   ├── artifacts/`);
-        const byKind = new Map();
-        for (const p of primitives) {
-            const list = byKind.get(p.kind) || [];
-            list.push(p);
-            byKind.set(p.kind, list);
-        }
-        const kinds = Array.from(byKind.keys());
-        kinds.forEach((kind, i) => {
-            const isLast = i === kinds.length - 1;
-            const primitiveList = byKind.get(kind);
-            this.log(`   │   ${isLast ? '└' : '├'}── ${kind}/`);
-            primitiveList.forEach((p, j) => {
-                const isLastPrimitive = j === primitiveList.length - 1;
-                const prefix = isLast ? '    ' : '│   ';
-                this.log(`   ${prefix}   ${isLastPrimitive ? '└' : '├'}── ${p.name}.js (${formatSize(p.artifact.size)})`);
-            });
-        });
-        this.log(`   └── manifest.json`);
-    }
-    /**
-     * Create the compilation result with stats.
-     * Note: The full manifest (with projectFiles) is written by writeArtifacts.
-     * This returns a minimal manifest for the result object.
-     */
-    async createResult(success, primitives, errors, warnings, startTime) {
-        const stats = this.calculateStats(primitives, startTime);
-        return {
-            success,
-            manifest: await this.createMinimalManifest(primitives),
-            errors,
-            warnings,
-            stats,
-        };
-    }
-    /**
-     * Calculate compilation statistics.
-     */
-    calculateStats(primitives, startTime) {
-        const byKind = {};
-        let totalSize = 0;
-        for (const p of primitives) {
-            byKind[p.kind] = (byKind[p.kind] || 0) + 1;
-            totalSize += p.artifact.size;
-        }
-        return {
-            totalPrimitives: primitives.length,
-            byKind,
-            totalSize,
-            duration: Date.now() - startTime,
-        };
-    }
-    /**
-     * Create a minimal manifest for the result object.
-     * The full manifest (with projectFiles) is written to disk by writeArtifacts.
-     */
-    async createMinimalManifest(primitives) {
-        return {
-            version: COMPILER_VERSION,
-            compiledAt: new Date().toISOString(),
-            primitives: await this.mapPrimitivesToManifest(primitives),
-            projectFiles: [],
-            config: {},
-        };
-    }
-    /**
-     * Log a message (always shown).
-     */
-    log(message) {
-        console.log(message);
-    }
-    /**
-     * Log a verbose message (only shown in verbose or debug mode).
-     */
-    verbose(message) {
-        if (this.options.verbose || this.options.debug) {
-            console.log(message);
-        }
-    }
-}
-// =============================================================================
-// CONVENIENCE FUNCTION
-// =============================================================================
-/**
- * Compile a Lua project.
- *
- * @example
- * ```typescript
- * const result = await compile({
- *   rootDir: process.cwd(),
- *   outDir: 'dist',
- * });
- *
- * if (!result.success) {
- *   console.error('Compilation failed:');
- *   result.errors.forEach(e => console.error(`  ${e.message}`));
- *   process.exit(1);
- * }
- * ```
- */
-export async function compile(options) {
-    const compiler = new Compiler(options);
-    return compiler.compile();
-}
-//# sourceMappingURL=compiler.js.map