@pablozaiden/terminatui 0.6.3 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pablozaiden/terminatui",
-  "version": "0.6.3",
+  "version": "0.7.1",
   "description": "Terminal UI and Command Line Application Framework",
   "repository": {
     "url": "https://github.com/PabloZaiden/terminatui",
@@ -21,8 +21,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@opentui/core": "0.1.75",
-    "@opentui/react": "0.1.75",
+    "@opentui/core": "0.1.87",
+    "@opentui/react": "0.1.87",
     "ink": "6.6.0",
     "ink-select-input": "6.2.0",
     "ink-text-input": "6.0.0",

package/src/core/application.ts

@@ -58,8 +58,11 @@ export interface ApplicationConfig {
   version: string;
   /** Optional commit hash for version display (shows "(dev)" if not set) */
   commitHash?: string;
-  /** Commands to register */
-  commands: AnyCommand[];
+  /** 
+   * Commands to register. 
+   * Can be omitted and registered later via `registerCommands()`.
+   */
+  commands?: AnyCommand[];
   /** Default command when no args provided (by name) */
   defaultCommand?: string;
   /** Logger configuration */
@@ -88,6 +91,7 @@ export interface ApplicationHooks {
  * 
  * @example
  * ```typescript
+ * // Option 1: Pass commands in constructor (original API, still works)
  * const app = new Application({
  *   name: "myapp",
  *   version: "1.0.0",
@@ -97,6 +101,25 @@ export interface ApplicationHooks {
  * 
  * await app.run();
  * ```
+ * 
+ * @example
+ * ```typescript
+ * // Option 2: Register commands dynamically after construction
+ * const app = new Application({
+ *   name: "myapp",
+ *   version: "1.0.0",
+ * });
+ * 
+ * // Access context before registering commands
+ * app.context.setService("db", await connectToDb());
+ * 
+ * // Register commands that may depend on context
+ * app.registerCommands([
+ *   new DynamicCommand(app.context),
+ * ]);
+ * 
+ * await app.run();
+ * ```
  */
 export class Application {
   readonly name: string;
@@ -127,6 +150,7 @@ export class Application {
 
   private readonly defaultCommandName?: string;
   private hooks: ApplicationHooks = {};
+  private commandsRegistered = false;
 
   constructor(config: ApplicationConfig) {
     this.name = config.name;
@@ -146,15 +170,57 @@ export class Application {
 
     context.logger.silly(`Application initialized: ${this.name} v${this.version}`);
 
-    // Create registry and register commands
+    // Create registry
     this.registry = new CommandRegistry();
-    this.registerCommands(config.commands);
+    
+    // If commands were provided in config (even empty array), register them now
+    // This maintains backward compatibility - passing commands: [] still registers built-ins
+    if (config.commands !== undefined) {
+      this.registerCommands(config.commands);
+    }
   }
 
   /**
-   * Register commands and inject help subcommands.
+   * Register commands with the application.
+   * 
+   * This method can be called after construction to register commands dynamically.
+   * This is useful when commands depend on context or other runtime information.
+   * 
+   * @param commands Array of commands to register
+   * @throws If commands have already been registered
+   * 
+   * @example
+   * ```typescript
+   * const app = new Application({
+   *   name: "myapp",
+   *   version: "1.0.0",
+   * });
+   * 
+   * // Access context to set up services
+   * app.context.setService("db", await connectToDb());
+   * 
+   * // Register commands that depend on context
+   * app.registerCommands([
+   *   new DbQueryCommand(),
+   *   new DbMigrateCommand(),
+   * ]);
+   * 
+   * await app.run();
+   * ```
+   */
+  registerCommands(commands: AnyCommand[]): void {
+    if (this.commandsRegistered) {
+      throw new Error("Commands have already been registered. registerCommands() can only be called once.");
+    }
+    
+    this.commandsRegistered = true;
+    this.doRegisterCommands(commands);
+  }
+
+  /**
+   * Internal method to register commands and inject help subcommands.
    */
-  private registerCommands(commands: AnyCommand[]): void {
+  private doRegisterCommands(commands: AnyCommand[]): void {
     this.assertNoReservedCommands(commands);
 
     // Register version command at top level
@@ -244,6 +310,13 @@ export class Application {
    * Useful for tests or manual programmatic invocation.
    */
   async runFromArgs(argv: string[]): Promise<void> {
+    // Ensure commands have been registered before running
+    if (!this.commandsRegistered) {
+      throw new Error(
+        "No commands registered. Call registerCommands() before run(), or provide commands in the constructor config."
+      );
+    }
+
     // configure logger
     AppContext.current.logger.onLogEvent((event) => {
       process.stderr.write(event.message + "\n");

package/src/core/builder.ts

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export async function buildBinary(
+    rootDir: string,
+    entrypoint: string,
+    binaryName: string, 
+    plugins : Bun.BunPlugin[] = []) {
+
+    // create a temp directory for output in the os temp directory
+    const outDir = fs.mkdtempSync(path.join(os.tmpdir(), `${binaryName}-build-`));
+    const finalOutDir = `${rootDir}/dist`;
+
+    // Parse --target argument (e.g., --target=linux-x64)
+    const targetArg = process.argv.find(arg => arg.startsWith('--target='));
+    const target = targetArg?.split('=')[1] as
+        | 'bun-linux-x64'
+        | 'bun-linux-arm64'
+        | 'bun-darwin-x64'
+        | 'bun-darwin-arm64'
+        | 'bun-windows-x64'
+        | undefined;
+
+    const isWindowsBinary = target?.startsWith('bun-windows') || (!target && os.platform() === 'win32');
+    const outfile = isWindowsBinary ? `${outDir}/${binaryName}.exe` : `${outDir}/${binaryName}`;
+    console.info('Building binary...');
+    if (target) {
+        console.info(`Target: ${target}`);
+    }
+
+    const result = await Bun.build({
+        entrypoints: [entrypoint],
+        compile: target
+            ? { outfile, target }
+            : { outfile },
+        plugins: plugins,
+        minify: true,
+        sourcemap: true,
+        define: {
+            'process.env.NODE_ENV': JSON.stringify('production'),
+        },
+    });
+
+    if (!result.success) {
+        console.error('Build failed:');
+        for (const log of result.logs) {
+            console.error(log);
+        }
+        process.exit(1);
+    }
+
+
+    console.info('Ensuring dist directory exists...');
+    fs.mkdirSync(finalOutDir, { recursive: true });
+
+    console.info('Copying built file to dist directory...');
+    const finalBinaryBaseName = target ? `${binaryName}-${target.replace('bun-', '')}` : binaryName;
+    const finalBinaryPath = `${finalOutDir}/${finalBinaryBaseName}${isWindowsBinary ? '.exe' : ''}`;
+    fs.copyFileSync(outfile, finalBinaryPath);
+
+    console.info('Cleaning up temporary files...');
+    fs.rmSync(outDir, { recursive: true, force: true });
+
+    console.info('Build completed:', finalBinaryPath);
+}

package/src/index.ts

@@ -6,6 +6,7 @@ export * from "./cli/parser.ts";
 export * from "./cli/output/colors.ts";
 
 export * from "./core/application.ts";
+export * from "./core/builder.ts";
 export * from "./core/command.ts";
 export * from "./core/context.ts";
 export * from "./core/help.ts";