@bb-labs/bldr 0.0.5 → 0.0.7

package/README.md

@@ -1,11 +1,11 @@
-# bldr
+## Introduction
 
 A TypeScript build tool with watch mode, automatic dist synchronization, and split-terminal UI.
 
 ## Installation
 
 ```bash
-bun add -d @bb-labs/builder typescript tsc-alias
+bun add -d @bb-labs/bldr
 ```
 
 ## Usage
@@ -21,9 +21,17 @@ bun add -d @bb-labs/builder typescript tsc-alias
 
 ## Options
 
-- `--watch`, `-w`: Watch mode with split-terminal UI showing tsc, tsc-alias, and bldr outputs side by side
+- `--watch`, `-w`: Watch mode with split-terminal UI showing tsc, tsc-alias, and bldr outputs
 - `--project`, `-p <path>`: Custom tsconfig.json path
 
+## Controls (Watch Mode)
+
+- **Mouse Wheel**: Scroll individual panels when hovering over them
+- **Arrow Keys**: Scroll the main panel up/down
+- **Page Up/Down**: Scroll the main panel by larger increments
+- **Ctrl+L**: Jump all panels to the bottom
+- **Ctrl+C/Escape/Q**: Exit the application
+
 ## Testing
 
 Run `bun run test:dev` to test the build tool with the included test files in `test-src/`. This will:

package/dist/core/builder.d.ts

@@ -0,0 +1,2 @@
+import { type Args } from "./types.js";
+export declare function build(args: Args): Promise<void>;

package/dist/core/builder.js

@@ -0,0 +1,200 @@
+import path from "node:path";
+import chokidar from "chokidar";
+import {} from "./types.js";
+import { findClosestTsconfig, readTsConfig, rel, rmIfExists, isTsLike, makeDistCleaner } from "../utils/fs.js";
+import { run, spawnLongRunning } from "../utils/process.js";
+import { createTerminalUI } from "../ui/terminal.js";
+export async function build(args) {
+    const cwd = process.cwd();
+    const tsconfigPath = args.project ? path.resolve(cwd, args.project) : findClosestTsconfig(cwd);
+    const cfg = readTsConfig(tsconfigPath);
+    if (!cfg.outDir || !cfg.rootDir) {
+        throw new Error([
+            `tsconfig must specify both "compilerOptions.outDir" and "compilerOptions.rootDir" for dist sync.`,
+            `Found: rootDir=${String(cfg.rootDir)} outDir=${String(cfg.outDir)}`,
+            `File: ${tsconfigPath}`,
+        ].join("\n"));
+    }
+    const rootDirAbs = path.isAbsolute(cfg.rootDir) ? cfg.rootDir : path.resolve(cfg.configDir, cfg.rootDir);
+    const outDirAbs = path.isAbsolute(cfg.outDir) ? cfg.outDir : path.resolve(cfg.configDir, cfg.outDir);
+    const state = {};
+    const shutdown = async (code = 0) => {
+        // Prevent multiple shutdown calls
+        if (shutdown.inProgress)
+            return;
+        shutdown.inProgress = true;
+        if (state.ui) {
+            state.ui.destroy();
+            state.ui = undefined;
+        }
+        console.log("\n■ shutting down...");
+        try {
+            if (state.watcher) {
+                await state.watcher.close();
+            }
+            console.log("✓ src watcher closed");
+        }
+        catch (error) {
+            console.error(`✗ error closing src watcher: ${error}`);
+        }
+        const killProcess = (name, p) => {
+            if (p && !p.killed) {
+                console.log(`↻ killing ${name}...`);
+                p.kill();
+                return new Promise((resolve) => {
+                    const timeout = setTimeout(() => {
+                        if (!p.killed)
+                            p.kill("SIGKILL");
+                        resolve();
+                    }, 2000);
+                    p.on("exit", () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                });
+            }
+            return Promise.resolve();
+        };
+        await Promise.all([killProcess("tsc", state.tsc), killProcess("tsc-alias", state.alias)]);
+        console.log("✓ all processes cleaned up");
+        process.exit(code);
+    };
+    // Register shutdown handlers
+    process.on("SIGINT", () => shutdown(0));
+    process.on("SIGTERM", () => shutdown(0));
+    if (args.watch) {
+        state.ui = createTerminalUI(() => shutdown(0));
+        console.log = (...args) => {
+            state.ui?.logToBldr(args.join(" "));
+        };
+        console.error = (...args) => {
+            state.ui?.logToBldr(`{red-fg}✗ ${args.join(" ")}{/red-fg}`);
+        };
+    }
+    const prefix = args.watch ? "" : "[bldr] ";
+    console.log([
+        `\n${prefix}• project: ${rel(cwd, tsconfigPath)}`,
+        `${prefix}→ rootDir : ${rel(cwd, rootDirAbs)}`,
+        `${prefix}→ outDir  : ${rel(cwd, outDirAbs)}`,
+        `${prefix}▶ mode    : ${args.watch ? "watch" : "build"}\n`,
+    ].join("\n"));
+    console.log(`⌫ cleaning output directory...`);
+    await rmIfExists(outDirAbs);
+    console.log(`✓ output directory cleaned`);
+    const tscArgs = ["-p", tsconfigPath, "--pretty"];
+    const aliasArgs = ["-p", tsconfigPath];
+    if (!args.watch) {
+        try {
+            console.log(`▶ starting build...`);
+            await run("tsc", tscArgs, cwd);
+            await run("tsc-alias", aliasArgs, cwd);
+            console.log(`✓ [bldr] build completed successfully!`);
+        }
+        catch (error) {
+            console.error(`build failed, cleaning output directory...`);
+            await rmIfExists(outDirAbs);
+            throw error;
+        }
+        return;
+    }
+    // Watch mode initial pass
+    try {
+        console.log(`▶ starting initial build...`);
+        await run("tsc", tscArgs, cwd);
+        await run("tsc-alias", aliasArgs, cwd);
+        console.log(`✓ initial build completed`);
+    }
+    catch (error) {
+        if (state.ui) {
+            state.ui.tscBox.insertBottom(`{red-fg}✗ initial build failed: ${error.message}{/red-fg}`);
+            state.ui.tscBox.setScrollPerc(100);
+            state.ui.screen.render();
+        }
+    }
+    // Start processes
+    state.tsc = spawnLongRunning("tsc", [...tscArgs, "-w"], cwd);
+    state.alias = spawnLongRunning("tsc-alias", [...aliasArgs, "-w"], cwd);
+    const setupOutputPipe = (p, box) => {
+        if (!p)
+            return;
+        const handleData = (data) => {
+            const text = data.toString().trim();
+            if (text && state.ui) {
+                box.insertBottom(text);
+                box.setScrollPerc(100);
+                state.ui.screen.render();
+            }
+        };
+        p.stdout?.on("data", handleData);
+        p.stderr?.on("data", handleData);
+        p.on("error", (error) => {
+            if (state.ui) {
+                box.insertBottom(`{red-fg}✗ ${error}{/red-fg}`);
+                box.setScrollPerc(100);
+                state.ui.screen.render();
+            }
+        });
+        p.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`${p === state.tsc ? "tsc" : "tsc-alias"} exited with code ${code}`);
+            }
+            // If one of them exits unexpectedly in watch mode, we might want to shut down or restart
+            // For now, let's just shut down if it's not a normal exit
+            if (code !== 0 && code !== null)
+                shutdown(code);
+        });
+    };
+    if (state.ui) {
+        setupOutputPipe(state.tsc, state.ui.tscBox);
+        setupOutputPipe(state.alias, state.ui.aliasBox);
+    }
+    const cleaner = makeDistCleaner(rootDirAbs, outDirAbs);
+    const srcWatcher = chokidar.watch(rootDirAbs, {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+        atomic: true,
+        interval: 100,
+        binaryInterval: 300,
+    });
+    state.watcher = srcWatcher;
+    const operationQueue = new Map();
+    const MAX_CONCURRENT_OPERATIONS = 10;
+    async function queuedOperation(key, operation) {
+        const existing = operationQueue.get(key);
+        if (existing)
+            await existing;
+        while (operationQueue.size >= MAX_CONCURRENT_OPERATIONS) {
+            await Promise.race(operationQueue.values());
+        }
+        const promise = operation().finally(() => operationQueue.delete(key));
+        operationQueue.set(key, promise);
+        return promise;
+    }
+    srcWatcher.on("unlink", async (absPath) => {
+        try {
+            await queuedOperation(absPath, async () => {
+                if (isTsLike(absPath)) {
+                    await cleaner.removeEmittedForSource(absPath);
+                    console.log(`- sync: removed output for ${path.relative(rootDirAbs, absPath)}`);
+                }
+                else {
+                    const outPath = path.join(outDirAbs, path.relative(rootDirAbs, absPath));
+                    await rmIfExists(outPath);
+                    console.log(`- sync: removed asset ${path.relative(rootDirAbs, absPath)}`);
+                }
+            });
+        }
+        catch (error) {
+            console.error(`error handling file deletion ${absPath}: ${error}`);
+        }
+    });
+    srcWatcher.on("unlinkDir", async (absDir) => {
+        try {
+            await cleaner.removeOutDirForSourceDir(absDir);
+            console.log(`- sync: removed directory ${path.relative(rootDirAbs, absDir)}`);
+        }
+        catch (error) {
+            console.error(`error handling directory deletion ${absDir}: ${error}`);
+        }
+    });
+}

package/dist/core/types.d.ts

@@ -0,0 +1,18 @@
+import type { ChildProcess } from "node:child_process";
+export type Args = {
+    watch: boolean;
+    project?: string;
+};
+export interface Config {
+    tsconfigPath: string;
+    configDir: string;
+    outDir: string;
+    rootDir: string;
+}
+export interface BuildProcess {
+    tsc?: ChildProcess;
+    alias?: ChildProcess;
+    watcher?: {
+        close: () => Promise<void>;
+    };
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -1,462 +1,9 @@
 #!/usr/bin/env bun
-import { spawn } from "node:child_process";
-import path from "node:path";
-import fs from "node:fs";
-import chokidar from "chokidar";
-import blessed from "blessed";
-// We use the TypeScript API to correctly resolve tsconfig + "extends".
-import ts from "typescript";
-function parseArgs(argv) {
-    const args = { watch: false };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (a === "-w" || a === "--watch")
-            args.watch = true;
-        else if (a === "-p" || a === "--project")
-            args.project = argv[++i];
-    }
-    return args;
-}
-function findClosestTsconfig(startDir) {
-    let dir = startDir;
-    while (true) {
-        const candidate = path.join(dir, "tsconfig.json");
-        if (fs.existsSync(candidate))
-            return candidate;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    throw new Error(`Could not find tsconfig.json starting from ${startDir}. Pass -p <path-to-tsconfig>.`);
-}
-function readTsConfig(tsconfigPath) {
-    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-    if (configFile.error) {
-        const msg = ts.formatDiagnosticsWithColorAndContext([configFile.error], {
-            getCanonicalFileName: (f) => f,
-            getCurrentDirectory: ts.sys.getCurrentDirectory,
-            getNewLine: () => ts.sys.newLine,
-        });
-        throw new Error(msg);
-    }
-    const configDir = path.dirname(tsconfigPath);
-    // parseJsonConfigFileContent resolves "extends" and normalizes options.
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, configDir, 
-    /*existingOptions*/ undefined, tsconfigPath);
-    if (parsed.errors?.length) {
-        const msg = ts.formatDiagnosticsWithColorAndContext(parsed.errors, {
-            getCanonicalFileName: (f) => f,
-            getCurrentDirectory: ts.sys.getCurrentDirectory,
-            getNewLine: () => ts.sys.newLine,
-        });
-        throw new Error(msg);
-    }
-    // These are absolute paths in parsed.options (when provided).
-    const outDir = parsed.options.outDir;
-    const rootDir = parsed.options.rootDir;
-    return {
-        tsconfigPath,
-        configDir,
-        outDir,
-        rootDir,
-    };
-}
-function run(cmd, args, cwd) {
-    return new Promise((resolve, reject) => {
-        const p = spawn(cmd, args, {
-            cwd,
-            stdio: ["inherit", "pipe", "pipe"], // pipe both stdout and stderr to capture all output
-            shell: process.platform === "win32",
-        });
-        let stdout = "";
-        let stderr = "";
-        if (p.stdout) {
-            p.stdout.on("data", (data) => {
-                stdout += data.toString();
-            });
-        }
-        if (p.stderr) {
-            p.stderr.on("data", (data) => {
-                stderr += data.toString();
-            });
-        }
-        p.on("exit", (code) => {
-            if (code === 0)
-                resolve();
-            else {
-                // Give a small delay to ensure all output data is captured
-                setTimeout(() => {
-                    const allOutput = (stdout + stderr).trim();
-                    const errorMsg = allOutput || `${cmd} ${args.join(" ")} failed with exit code ${code}`;
-                    reject(new Error(errorMsg));
-                }, 100);
-            }
-        });
-    });
-}
-function spawnLongRunning(cmd, args, cwd) {
-    const p = spawn(cmd, args, {
-        cwd,
-        stdio: ["inherit", "pipe", "pipe"], // pipe stdout and stderr
-        shell: process.platform === "win32",
-    });
-    return p;
-}
-function rel(from, to) {
-    const r = path.relative(from, to);
-    return r.startsWith(".") ? r : `./${r}`;
-}
-async function rmIfExists(p) {
-    try {
-        await fs.promises.rm(p, { force: true, recursive: true });
-    }
-    catch {
-        // ignore
-    }
-}
-function isTsLike(filePath) {
-    return (filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".mts") || filePath.endsWith(".cts"));
-}
-function stripTsExt(p) {
-    return p.replace(/\.(ts|tsx|mts|cts)$/i, "");
-}
-function makeDistCleaner(rootDirAbs, outDirAbs) {
-    const EMITTED_SUFFIXES = [".js", ".js.map", ".d.ts", ".d.ts.map"];
-    function toOutPath(srcPathAbs) {
-        const relPath = path.relative(rootDirAbs, srcPathAbs);
-        return path.join(outDirAbs, relPath);
-    }
-    async function removeEmittedForSource(srcFileAbs) {
-        const outLike = toOutPath(srcFileAbs); // dist/foo.tsx
-        const base = stripTsExt(outLike); // dist/foo
-        await Promise.all(EMITTED_SUFFIXES.map((s) => rmIfExists(base + s)));
-    }
-    async function removeOutDirForSourceDir(srcDirAbs) {
-        const outDir = toOutPath(srcDirAbs);
-        await rmIfExists(outDir);
-    }
-    return { removeEmittedForSource, removeOutDirForSourceDir };
-}
+import { parseArgs } from "./utils/args.js";
+import { build } from "./core/builder.js";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
-    const cwd = process.cwd();
-    const tsconfigPath = args.project ? path.resolve(cwd, args.project) : findClosestTsconfig(cwd);
-    const cfg = readTsConfig(tsconfigPath);
-    if (!cfg.outDir || !cfg.rootDir) {
-        throw new Error([
-            `tsconfig must specify both "compilerOptions.outDir" and "compilerOptions.rootDir" for dist sync.`,
-            `Found: rootDir=${String(cfg.rootDir)} outDir=${String(cfg.outDir)}`,
-            `File: ${tsconfigPath}`,
-        ].join("\n"));
-    }
-    const rootDirAbs = path.isAbsolute(cfg.rootDir) ? cfg.rootDir : path.resolve(cfg.configDir, cfg.rootDir);
-    const outDirAbs = path.isAbsolute(cfg.outDir) ? cfg.outDir : path.resolve(cfg.configDir, cfg.outDir);
-    // Create terminal UI only in watch mode
-    let screen, bldrBox, tscBox, aliasBox, logToBldr;
-    if (args.watch) {
-        screen = blessed.screen({
-            smartCSR: true,
-            title: "bldr - TypeScript Build Tool",
-        });
-        bldrBox = blessed.box({
-            top: 0,
-            left: 0,
-            width: "33%",
-            height: "100%",
-            label: " bldr ",
-            border: { type: "line" },
-            scrollable: true,
-            alwaysScroll: true,
-            scrollbar: { ch: " " },
-        });
-        tscBox = blessed.box({
-            top: 0,
-            left: "33%",
-            width: "34%",
-            height: "100%",
-            label: " tsc ",
-            border: { type: "line" },
-            scrollable: true,
-            alwaysScroll: true,
-            scrollbar: { ch: " " },
-        });
-        aliasBox = blessed.box({
-            top: 0,
-            left: "67%",
-            width: "33%",
-            height: "100%",
-            label: " tsc-alias ",
-            border: { type: "line" },
-            scrollable: true,
-            alwaysScroll: true,
-            scrollbar: { ch: " " },
-        });
-        screen.append(bldrBox);
-        screen.append(tscBox);
-        screen.append(aliasBox);
-        // Handle screen events
-        screen.key(["escape", "q", "C-c"], () => {
-            shutdown();
-        });
-        screen.key(["C-l"], () => {
-            bldrBox.setScrollPerc(100);
-            tscBox.setScrollPerc(100);
-            aliasBox.setScrollPerc(100);
-            screen.render();
-        });
-        // Create a function to log to the bldr box
-        logToBldr = (text) => {
-            if (screen && bldrBox) {
-                bldrBox.insertBottom(text);
-                bldrBox.setScrollPerc(100);
-                screen.render();
-            }
-        };
-        // Override console.log and console.error for bldr messages
-        const originalLog = console.log;
-        const originalError = console.error;
-        console.log = (...args) => {
-            logToBldr(args.join(" "));
-            // Don't call originalLog to avoid double output
-        };
-        console.error = (...args) => {
-            logToBldr(args.join(" "));
-            // Don't call originalError to avoid double output
-        };
-        screen.render();
-    }
-    // Initial messages will now go to the bldr box via overridden console.log
-    console.log([
-        `\n[bldr] project: ${rel(cwd, tsconfigPath)}`,
-        `[bldr] rootDir : ${rel(cwd, rootDirAbs)}`,
-        `[bldr] outDir  : ${rel(cwd, outDirAbs)}`,
-        `[bldr] mode    : ${args.watch ? "watch" : "build"}\n`,
-    ].join("\n"));
-    // Clean the output directory first
-    console.log(`[bldr] cleaning output directory...`);
-    await rmIfExists(outDirAbs);
-    const tscArgs = ["-p", tsconfigPath];
-    const aliasArgs = ["-p", tsconfigPath];
-    // Error handling function for watch mode
-    const handleFatalError = async (errorMessage) => {
-        // Always restore normal console logging for watch mode
-        if (args.watch) {
-            // Destroy UI first to avoid conflicts
-            if (screen) {
-                screen.destroy();
-                screen = null;
-                bldrBox = null;
-                tscBox = null;
-                aliasBox = null;
-            }
-            // Write directly to stderr to ensure visibility
-            process.stderr.write(`[bldr] ${errorMessage}\n`);
-        }
-        else {
-            // In build mode, just print normally
-            console.error(`[bldr] ${errorMessage}`);
-        }
-        // Kill all processes
-        if (tscWatch && !tscWatch.killed) {
-            tscWatch.kill();
-        }
-        if (aliasWatch && !aliasWatch.killed) {
-            aliasWatch.kill();
-        }
-        if (srcWatcher) {
-            try {
-                await srcWatcher.close();
-            }
-            catch (e) {
-                // ignore
-            }
-        }
-        process.exit(1);
-    };
-    if (!args.watch) {
-        // One-shot build: tsc -> tsc-alias
-        try {
-            await run("tsc", tscArgs, cwd);
-            await run("tsc-alias", aliasArgs, cwd);
-        }
-        catch (error) {
-            // Clean up partial output on build failure
-            console.error(`[bldr] build failed, cleaning output directory...`);
-            await rmIfExists(outDirAbs);
-            throw error;
-        }
-        console.log(`[bldr] build completed successfully!`);
-        return;
-    }
-    // Watch mode:
-    // 2) Do a clean initial pass so dist is correct immediately.
-    try {
-        await run("tsc", tscArgs, cwd);
-        await run("tsc-alias", aliasArgs, cwd);
-    }
-    catch (error) {
-        await handleFatalError(`[bldr] initial build failed: ${error}`);
-    }
-    // 3) Start watchers
-    const tscWatch = spawnLongRunning("tsc", [...tscArgs, "-w"], cwd);
-    const aliasWatch = spawnLongRunning("tsc-alias", [...aliasArgs, "-w"], cwd);
-    // Pipe output to boxes
-    if (tscWatch.stdout) {
-        tscWatch.stdout.on("data", (data) => {
-            const text = data.toString().trim();
-            if (text) {
-                tscBox.insertBottom(text);
-                tscBox.setScrollPerc(100);
-                screen.render();
-            }
-        });
-    }
-    if (tscWatch.stderr) {
-        tscWatch.stderr.on("data", (data) => {
-            const text = data.toString().trim();
-            if (text) {
-                tscBox.insertBottom(text);
-                tscBox.setScrollPerc(100);
-                screen.render();
-            }
-        });
-    }
-    if (aliasWatch.stdout) {
-        aliasWatch.stdout.on("data", (data) => {
-            const text = data.toString().trim();
-            if (text) {
-                aliasBox.insertBottom(text);
-                aliasBox.setScrollPerc(100);
-                screen.render();
-            }
-        });
-    }
-    if (aliasWatch.stderr) {
-        aliasWatch.stderr.on("data", (data) => {
-            const text = data.toString().trim();
-            if (text) {
-                aliasBox.insertBottom(text);
-                aliasBox.setScrollPerc(100);
-                screen.render();
-            }
-        });
-    }
-    // If any child process errors or exits, shut down all processes
-    tscWatch.on("error", (error) => {
-        handleFatalError(`[bldr] tsc watcher error: ${error}`);
-    });
-    aliasWatch.on("error", (error) => {
-        handleFatalError(`[bldr] tsc-alias watcher error: ${error}`);
-    });
-    // 3) dist sync watcher: remove stale outputs on deletes/dir deletes
-    const cleaner = makeDistCleaner(rootDirAbs, outDirAbs);
-    const srcWatcher = chokidar.watch(rootDirAbs, {
-        ignoreInitial: true,
-        awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
-        atomic: true, // Handle atomic writes (renames/moves) properly
-        interval: 100, // Poll interval for most files
-        binaryInterval: 300, // Poll interval for binary files
-    });
-    // Queue for handling rapid operations to prevent race conditions
-    const operationQueue = new Map();
-    const MAX_CONCURRENT_OPERATIONS = 10;
-    async function queuedOperation(key, operation) {
-        // Wait for any existing operation on this key
-        const existing = operationQueue.get(key);
-        if (existing) {
-            await existing;
-        }
-        // Limit concurrent operations
-        while (operationQueue.size >= MAX_CONCURRENT_OPERATIONS) {
-            await Promise.race(operationQueue.values());
-        }
-        const promise = operation().finally(() => operationQueue.delete(key));
-        operationQueue.set(key, promise);
-        return promise;
-    }
-    srcWatcher.on("unlink", async (absPath) => {
-        try {
-            await queuedOperation(absPath, async () => {
-                if (isTsLike(absPath)) {
-                    await cleaner.removeEmittedForSource(absPath);
-                }
-                else {
-                    // Mirror non-TS deletes too (assets)
-                    await rmIfExists(path.join(outDirAbs, path.relative(rootDirAbs, absPath)));
-                }
-            });
-        }
-        catch (error) {
-            console.error(`[bldr] error handling file deletion ${absPath}: ${error}`);
-        }
-    });
-    srcWatcher.on("unlinkDir", async (absDir) => {
-        try {
-            await cleaner.removeOutDirForSourceDir(absDir);
-        }
-        catch (error) {
-            console.error(`[bldr] error handling directory deletion ${absDir}: ${error}`);
-        }
-    });
-    // TypeScript compiler handles additions and changes automatically
-    const shutdown = async () => {
-        console.log("\n[bldr] shutting down...");
-        // Destroy screen if it exists
-        if (screen) {
-            screen.destroy();
-            screen = null;
-        }
-        // Close file watcher
-        try {
-            if (srcWatcher) {
-                await srcWatcher.close();
-            }
-            console.log("[bldr] src watcher closed");
-        }
-        catch (error) {
-            console.error(`[bldr] error closing src watcher: ${error}`);
-        }
-        // Kill child processes
-        const killPromises = [];
-        if (tscWatch && !tscWatch.killed) {
-            killPromises.push(new Promise((resolve) => {
-                tscWatch.on("exit", () => resolve());
-                tscWatch.kill();
-                // Force kill after 5 seconds
-                setTimeout(() => {
-                    if (!tscWatch.killed) {
-                        tscWatch.kill("SIGKILL");
-                    }
-                    resolve();
-                }, 5000);
-            }));
-            console.log("[bldr] killing tsc watcher...");
-        }
-        if (aliasWatch && !aliasWatch.killed) {
-            killPromises.push(new Promise((resolve) => {
-                aliasWatch.on("exit", () => resolve());
-                aliasWatch.kill();
-                // Force kill after 5 seconds
-                setTimeout(() => {
-                    if (!aliasWatch.killed) {
-                        aliasWatch.kill("SIGKILL");
-                    }
-                    resolve();
-                }, 5000);
-            }));
-            console.log("[bldr] killing tsc-alias watcher...");
-        }
-        // Wait for all child processes to exit
-        await Promise.all(killPromises);
-        console.log("[bldr] all processes cleaned up");
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    // If any child exits, shut down.
-    tscWatch.on("exit", () => shutdown());
-    aliasWatch.on("exit", () => shutdown());
+    await build(args);
 }
 main().catch((e) => {
     console.error(String(e?.stack || e));

package/dist/ui/terminal.d.ts

@@ -0,0 +1,10 @@
+import blessed from "blessed";
+export interface TerminalUI {
+    screen: blessed.Widgets.Screen;
+    bldrBox: blessed.Widgets.BoxElement;
+    tscBox: blessed.Widgets.BoxElement;
+    aliasBox: blessed.Widgets.BoxElement;
+    logToBldr: (text: string) => void;
+    destroy: () => void;
+}
+export declare function createTerminalUI(onShutdown: () => void): TerminalUI;

package/dist/ui/terminal.js

@@ -0,0 +1,129 @@
+import blessed from "blessed";
+export function createTerminalUI(onShutdown) {
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: "bldr - TypeScript Build Tool",
+        fullUnicode: true,
+    });
+    // Common styles
+    const boxStyle = {
+        border: {
+            fg: "cyan",
+        },
+    };
+    // Left column: tsc (65% width, full height)
+    const tscBox = blessed.box({
+        top: 0,
+        left: 0,
+        width: "65%",
+        height: "100%",
+        label: " tsc ",
+        border: { type: "line" },
+        style: boxStyle,
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+            ch: " ",
+            track: { bg: "grey" },
+            style: { inverse: true },
+        },
+        tags: true, // Enable colors/formatting
+    });
+    // Right column: tsc-alias (top 50%) and bldr (bottom 50%), 35% width, full height
+    const aliasBox = blessed.box({
+        top: 0,
+        left: "65%",
+        width: "35%",
+        height: "50%",
+        label: " tsc alias ",
+        border: { type: "line" },
+        style: boxStyle,
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+            ch: " ",
+            track: { bg: "grey" },
+            style: { inverse: true },
+        },
+        tags: true,
+    });
+    const bldrBox = blessed.box({
+        top: "50%",
+        left: "65%",
+        width: "35%",
+        height: "50%",
+        label: " bldr ",
+        border: { type: "line" },
+        style: boxStyle,
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+            ch: " ",
+            track: { bg: "grey" },
+            style: { inverse: true },
+        },
+        tags: true,
+    });
+    screen.append(tscBox);
+    screen.append(aliasBox);
+    screen.append(bldrBox);
+    // Enable mouse events for scrolling
+    screen.enableMouse();
+    screen.enableKeys();
+    // Handle screen events
+    screen.key(["escape", "q", "C-c"], () => {
+        onShutdown();
+    });
+    screen.key(["C-l"], () => {
+        bldrBox.setScrollPerc(100);
+        tscBox.setScrollPerc(100);
+        aliasBox.setScrollPerc(100);
+        screen.render();
+    });
+    // Handle mouse wheel scrolling for each box
+    screen.on("mouse", (data) => {
+        // Determine which box the mouse is over
+        const x = data.x;
+        const y = data.y;
+        const width = screen.width;
+        const height = screen.height;
+        const tscWidth = Math.floor(width * 0.65);
+        const midHeight = Math.floor(height * 0.5);
+        let targetBox = null;
+        if (x < tscWidth) {
+            targetBox = tscBox;
+        }
+        else {
+            if (y < midHeight) {
+                targetBox = aliasBox;
+            }
+            else {
+                targetBox = bldrBox;
+            }
+        }
+        if (!targetBox)
+            return;
+        if (data.action === "wheelup") {
+            targetBox.scroll(-3);
+            screen.render();
+        }
+        else if (data.action === "wheeldown") {
+            targetBox.scroll(3);
+            screen.render();
+        }
+    });
+    const logToBldr = (text) => {
+        if (bldrBox) {
+            // Trim empty lines but keep content
+            const lines = text.split("\n").filter((l) => l.trim().length > 0 || l === "");
+            lines.forEach((line) => bldrBox.insertBottom(line));
+            bldrBox.setScrollPerc(100);
+            screen.render();
+        }
+    };
+    const destroy = () => {
+        screen.destroy();
+    };
+    screen.render();
+    return { screen, bldrBox, tscBox, aliasBox, logToBldr, destroy };
+}

package/dist/utils/args.d.ts

@@ -0,0 +1,5 @@
+import type { Args } from "../core/types.js";
+/**
+ * Simple CLI argument parser.
+ */
+export declare function parseArgs(argv: string[]): Args;

package/dist/utils/args.js

@@ -0,0 +1,40 @@
+/**
+ * Simple CLI argument parser.
+ */
+export function parseArgs(argv) {
+    const args = { watch: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-w" || a === "--watch") {
+            args.watch = true;
+        }
+        else if (a === "-p" || a === "--project") {
+            const next = argv[i + 1];
+            if (next && !next.startsWith("-")) {
+                args.project = next;
+                i++;
+            }
+            else {
+                throw new Error("The -p/--project flag requires a path to a tsconfig.json file.");
+            }
+        }
+        else if (a === "-h" || a === "--help") {
+            printHelp();
+            process.exit(0);
+        }
+    }
+    return args;
+}
+function printHelp() {
+    console.log(`
+bldr - A simple TypeScript build tool with dist synchronization.
+
+Usage:
+  bldr [options]
+
+Options:
+  -w, --watch    Watch for changes and sync deletions.
+  -p, --project  Path to tsconfig.json (defaults to closest tsconfig.json).
+  -h, --help     Show this help message.
+`);
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,32 @@
+import type { Config } from "../core/types.js";
+/**
+ * Finds the closest tsconfig.json by walking up the directory tree.
+ */
+export declare function findClosestTsconfig(startDir: string): string;
+/**
+ * Reads and parses a tsconfig.json file, resolving "extends".
+ */
+export declare function readTsConfig(tsconfigPath: string): Config;
+/**
+ * Returns a relative path, ensuring it starts with ./ or ../
+ */
+export declare function rel(from: string, to: string): string;
+/**
+ * Safely removes a file or directory if it exists.
+ */
+export declare function rmIfExists(p: string): Promise<void>;
+/**
+ * Checks if a file is a TypeScript-like source file.
+ */
+export declare function isTsLike(filePath: string): boolean;
+/**
+ * Strips TypeScript extensions from a path.
+ */
+export declare function stripTsExt(p: string): string;
+/**
+ * Creates a cleaner utility for synchronizing deletions from src to dist.
+ */
+export declare function makeDistCleaner(rootDirAbs: string, outDirAbs: string): {
+    removeEmittedForSource: (srcFileAbs: string) => Promise<void>;
+    removeOutDirForSourceDir: (srcDirAbs: string) => Promise<void>;
+};

package/dist/utils/fs.js

@@ -0,0 +1,105 @@
+import path from "node:path";
+import fs from "node:fs";
+import ts from "typescript";
+/**
+ * Finds the closest tsconfig.json by walking up the directory tree.
+ */
+export function findClosestTsconfig(startDir) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(dir, "tsconfig.json");
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`Could not find tsconfig.json starting from ${startDir}. Pass -p <path-to-tsconfig>.`);
+}
+/**
+ * Reads and parses a tsconfig.json file, resolving "extends".
+ */
+export function readTsConfig(tsconfigPath) {
+    const absolutePath = path.resolve(tsconfigPath);
+    const configFile = ts.readConfigFile(absolutePath, ts.sys.readFile);
+    if (configFile.error) {
+        throw new Error(formatTsDiagnostics([configFile.error]));
+    }
+    const configDir = path.dirname(absolutePath);
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, configDir, undefined, absolutePath);
+    if (parsed.errors?.length) {
+        throw new Error(formatTsDiagnostics(parsed.errors));
+    }
+    const outDir = parsed.options.outDir;
+    const rootDir = parsed.options.rootDir;
+    if (!outDir || !rootDir) {
+        throw new Error(`tsconfig at ${absolutePath} must specify both "compilerOptions.outDir" and "compilerOptions.rootDir".`);
+    }
+    return {
+        tsconfigPath: absolutePath,
+        configDir,
+        outDir: path.isAbsolute(outDir) ? outDir : path.resolve(configDir, outDir),
+        rootDir: path.isAbsolute(rootDir) ? rootDir : path.resolve(configDir, rootDir),
+    };
+}
+function formatTsDiagnostics(diagnostics) {
+    return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+        getCanonicalFileName: (f) => f,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => ts.sys.newLine,
+    });
+}
+/**
+ * Returns a relative path, ensuring it starts with ./ or ../
+ */
+export function rel(from, to) {
+    const r = path.relative(from, to);
+    return r.startsWith(".") ? r : `./${r}`;
+}
+/**
+ * Safely removes a file or directory if it exists.
+ */
+export async function rmIfExists(p) {
+    try {
+        await fs.promises.rm(p, { force: true, recursive: true });
+    }
+    catch (error) {
+        // Ignore if not found, otherwise rethrow or log
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+/**
+ * Checks if a file is a TypeScript-like source file.
+ */
+export function isTsLike(filePath) {
+    return /\.(ts|tsx|mts|cts)$/i.test(filePath);
+}
+/**
+ * Strips TypeScript extensions from a path.
+ */
+export function stripTsExt(p) {
+    return p.replace(/\.(ts|tsx|mts|cts)$/i, "");
+}
+/**
+ * Creates a cleaner utility for synchronizing deletions from src to dist.
+ */
+export function makeDistCleaner(rootDirAbs, outDirAbs) {
+    const EMITTED_SUFFIXES = [".js", ".js.map", ".d.ts", ".d.ts.map", ".mjs", ".mjs.map", ".cjs", ".cjs.map"];
+    function toOutPath(srcPathAbs) {
+        const relPath = path.relative(rootDirAbs, srcPathAbs);
+        return path.join(outDirAbs, relPath);
+    }
+    async function removeEmittedForSource(srcFileAbs) {
+        const outLike = toOutPath(srcFileAbs);
+        const base = stripTsExt(outLike);
+        await Promise.all(EMITTED_SUFFIXES.map((s) => rmIfExists(base + s)));
+    }
+    async function removeOutDirForSourceDir(srcDirAbs) {
+        const outDir = toOutPath(srcDirAbs);
+        await rmIfExists(outDir);
+    }
+    return { removeEmittedForSource, removeOutDirForSourceDir };
+}

package/dist/utils/process.d.ts

@@ -0,0 +1,10 @@
+import { type ChildProcess } from "node:child_process";
+/**
+ * Runs a command and returns a promise that resolves when the command finishes.
+ * Captures output for error messages if the command fails.
+ */
+export declare function run(cmd: string, args: string[], cwd: string): Promise<void>;
+/**
+ * Spawns a long-running process (like a watcher).
+ */
+export declare function spawnLongRunning(cmd: string, args: string[], cwd: string): ChildProcess;

package/dist/utils/process.js

@@ -0,0 +1,49 @@
+import { spawn } from "node:child_process";
+/**
+ * Runs a command and returns a promise that resolves when the command finishes.
+ * Captures output for error messages if the command fails.
+ */
+export function run(cmd, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const p = spawn(cmd, args, {
+            cwd,
+            stdio: ["inherit", "pipe", "pipe"],
+            shell: process.platform === "win32",
+            env: { ...process.env, FORCE_COLOR: "1" },
+        });
+        let output = "";
+        p.stdout?.on("data", (data) => {
+            output += data.toString();
+        });
+        p.stderr?.on("data", (data) => {
+            output += data.toString();
+        });
+        p.on("error", (error) => {
+            reject(new Error(`Failed to start ${cmd}: ${error.message}`));
+        });
+        p.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                // Give a small delay to ensure all output data is captured
+                setTimeout(() => {
+                    const cleanOutput = output.trim();
+                    const errorMsg = cleanOutput || `${cmd} ${args.join(" ")} failed with exit code ${code}`;
+                    reject(new Error(errorMsg));
+                }, 100);
+            }
+        });
+    });
+}
+/**
+ * Spawns a long-running process (like a watcher).
+ */
+export function spawnLongRunning(cmd, args, cwd) {
+    return spawn(cmd, args, {
+        cwd,
+        stdio: ["inherit", "pipe", "pipe"],
+        shell: process.platform === "win32",
+        env: { ...process.env, FORCE_COLOR: "1" },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bb-labs/bldr",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "bin": {
     "bldr": "./dist/index.js"
@@ -20,6 +20,7 @@
     "@types/node": "latest"
   },
   "peerDependencies": {
+    "tsc-alias": "^1.8.8",
     "typescript": "^5"
   },
   "dependencies": {