@bb-labs/bldr 0.0.3 → 0.0.5

package/README.md

@@ -1,6 +1,6 @@
-# @bb-labs/builder
+# bldr
 
-A TypeScript build tool with watch mode and automatic dist synchronization.
+A TypeScript build tool with watch mode, automatic dist synchronization, and split-terminal UI.
 
 ## Installation
 
@@ -21,5 +21,22 @@ bun add -d @bb-labs/builder typescript tsc-alias
 
 ## Options
 
-- `--watch`, `-w`: Watch mode
+- `--watch`, `-w`: Watch mode with split-terminal UI showing tsc, tsc-alias, and bldr outputs side by side
 - `--project`, `-p <path>`: Custom tsconfig.json path
+
+## Testing
+
+Run `bun run test:dev` to test the build tool with the included test files in `test-src/`. This will:
+
+- Build files from `test-src/` to `test-dist/`
+- Show the split-terminal UI with real-time updates
+- Watch for changes and rebuild automatically
+
+Add or modify files in `test-src/` to see the build tool in action!
+
+## Features
+
+- **Split Terminal UI**: In watch mode, displays three panels side by side showing output from TypeScript compiler, tsc-alias, and bldr itself
+- **Clean Builds**: Always cleans output directory before building
+- **Path Alias Support**: Integrates with tsc-alias for path mapping
+- **Process Management**: Properly handles child process cleanup on exit

package/dist/index.js

@@ -3,6 +3,7 @@ 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) {
@@ -65,21 +66,39 @@ function run(cmd, args, cwd) {
     return new Promise((resolve, reject) => {
         const p = spawn(cmd, args, {
             cwd,
-            stdio: "inherit",
+            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
-                reject(new Error(`${cmd} ${args.join(" ")} failed with exit code ${code}`));
+            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",
+        stdio: ["inherit", "pipe", "pipe"], // pipe stdout and stderr
         shell: process.platform === "win32",
     });
     return p;
@@ -133,6 +152,81 @@ async function main() {
     }
     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)}`,
@@ -144,6 +238,42 @@ async function main() {
     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 {
@@ -156,22 +286,69 @@ async function main() {
             await rmIfExists(outDirAbs);
             throw error;
         }
+        console.log(`[bldr] build completed successfully!`);
         return;
     }
     // Watch mode:
-    // 1) Do a clean initial pass so dist is correct immediately.
+    // 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) {
-        console.error(`[bldr] initial build failed: ${error}`);
-        // Continue in watch mode even if initial build fails
-        console.log(`[bldr] continuing in watch mode...`);
+        await handleFatalError(`[bldr] initial build failed: ${error}`);
     }
-    // 2) Start watchers
+    // 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, {
@@ -225,9 +402,16 @@ async function main() {
     // 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 {
-            await srcWatcher.close();
+            if (srcWatcher) {
+                await srcWatcher.close();
+            }
             console.log("[bldr] src watcher closed");
         }
         catch (error) {
@@ -235,7 +419,7 @@ async function main() {
         }
         // Kill child processes
         const killPromises = [];
-        if (!tscWatch.killed) {
+        if (tscWatch && !tscWatch.killed) {
             killPromises.push(new Promise((resolve) => {
                 tscWatch.on("exit", () => resolve());
                 tscWatch.kill();
@@ -249,7 +433,7 @@ async function main() {
             }));
             console.log("[bldr] killing tsc watcher...");
         }
-        if (!aliasWatch.killed) {
+        if (aliasWatch && !aliasWatch.killed) {
             killPromises.push(new Promise((resolve) => {
                 aliasWatch.on("exit", () => resolve());
                 aliasWatch.kill();

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@bb-labs/bldr",
-  "version": "0.0.3",
+  "version": "0.0.5",
+  "type": "module",
   "bin": {
     "bldr": "./dist/index.js"
   },
@@ -9,9 +10,12 @@
   ],
   "scripts": {
     "build": "tsc",
-    "postbuild": "chmod +x dist/index.js"
+    "postbuild": "chmod +x dist/index.js",
+    "test:build": "node dist/index.js --project test-src/tsconfig.json",
+    "test:watch": "node dist/index.js --watch --project test-src/tsconfig.json"
   },
   "devDependencies": {
+    "@types/blessed": "^0.1.27",
     "@types/bun": "latest",
     "@types/node": "latest"
   },
@@ -20,6 +24,7 @@
   },
   "dependencies": {
     "@bb-labs/tsconfigs": "^0.0.1",
+    "blessed": "^0.1.81",
     "chokidar": "^5.0.0",
     "tsc-alias": "^1.8.8"
   }