@pablozaiden/terminatui 0.1.2 → 0.3.0-beta-1

package/examples/tui-app/commands/config/app/set.ts

@@ -0,0 +1,96 @@
+import { Command, type CommandExecutionContext, type CommandResult } from "../../../../../src/core/command";
+import { AppContext } from "../../../../../src/core/context";
+import type { OptionSchema, OptionValues } from "../../../../../src/types/command";
+
+const options = {
+    key: {
+        type: "string",
+        description: "Application configuration key to set",
+        required: true,
+        label: "Key",
+        order: 1,
+        group: "Required",
+        placeholder: "e.g., port, debug, logLevel",
+    },
+    value: {
+        type: "string",
+        description: "Value to set",
+        required: true,
+        label: "Value",
+        order: 2,
+        group: "Required",
+        placeholder: "Enter value...",
+    },
+    type: {
+        type: "string",
+        description: "Value type for parsing",
+        enum: ["string", "number", "boolean"] as const,
+        default: "string",
+        label: "Value Type",
+        order: 3,
+        group: "Options",
+    },
+} as const satisfies OptionSchema;
+
+export class AppSetCommand extends Command<typeof options> {
+    readonly name = "set";
+    override displayName = "Set App Config";
+    readonly description = "Set an application configuration value";
+    readonly options = options;
+
+    override readonly actionLabel = "Set Value";
+
+    override readonly examples = [
+        { command: "config app set --key port --value 8080 --type number", description: "Set app port" },
+        { command: "config app set --key debug --value false --type boolean", description: "Disable debug" },
+    ];
+
+    override async execute(opts: OptionValues<typeof options>, execCtx: CommandExecutionContext): Promise<CommandResult> {
+        let parsedValue: string | number | boolean = opts.value;
+        
+        // Parse value based on type
+        if (opts.type === "number") {
+            parsedValue = Number(opts.value);
+            if (isNaN(parsedValue)) {
+                AppContext.current.logger.error(`Invalid number value: "${opts.value}"`);
+                return {
+                    success: false,
+                    message: `Invalid number: "${opts.value}"`,
+                };
+            }
+        } else if (opts.type === "boolean") {
+            parsedValue = opts.value.toLowerCase() === "true";
+        }
+
+        AppContext.current.logger.info(`Setting app.${opts.key} = ${JSON.stringify(parsedValue)}`);
+        
+
+        // Simulate setting the value on the 5th iteration
+        await new Promise(resolve => {
+            let count = 0;
+            let interval = setInterval(() => {
+                count++;
+                AppContext.current.logger.info(`Applying configuration... (${count}/5)`);
+                if (count >= 5 || execCtx.signal.aborted) {
+                    if (count < 5) {
+                        AppContext.current.logger.warn("Configuration update aborted");
+                    }
+                    clearInterval(interval);
+                    resolve(undefined);
+                }
+            }, 1000);
+        });
+        
+        AppContext.current.logger.info(`Successfully updated application configuration`);
+        return {
+            success: true,
+            data: { key: opts.key, value: parsedValue, type: opts.type },
+        };
+    }
+
+    override renderResult(result: CommandResult): string {
+        if (!result.success) return result.message || "Error";
+        const data = result.data as { key: string; value: string | number | boolean; type: string };
+        return `✓ Set app.${data.key} = ${JSON.stringify(data.value)} (${data.type})`;
+    }
+}

package/examples/tui-app/commands/config/index.ts

@@ -0,0 +1,28 @@
+import { UserConfigCommand } from "./user/index.ts";
+import { AppConfigCommand } from "./app/index.ts";
+import { Command, type CommandResult } from "../../../../src/core/command.ts";
+
+export class ConfigCommand extends Command {
+    readonly name = "config";
+    override displayName = "Config";
+    readonly description = "Manage configuration (user and app settings)";
+    readonly options = {};
+
+    override readonly subCommands = [
+        new UserConfigCommand(),
+        new AppConfigCommand(),
+    ];
+
+    override readonly examples = [
+        { command: "config user get --key name", description: "Get user name" },
+        { command: "config user set --key theme --value dark", description: "Set user theme" },
+        { command: "config app get --key port", description: "Get app port" },
+        { command: "config app set --key debug --value true --type boolean", description: "Enable debug mode" },
+    ];
+
+    override execute(): CommandResult {
+        console.log("Use 'config <category> <command>' to manage settings.");
+        console.log("Categories: user, app");
+        return { success: true };
+    }
+}

package/examples/tui-app/commands/config/user/get.ts

@@ -0,0 +1,61 @@
+import { Command, type CommandResult } from "../../../../../src/core/command";
+import { AppContext } from "../../../../../src/core/context";
+import type { OptionSchema, OptionValues } from "../../../../../src/types/command";
+
+const options = {
+    key: {
+        type: "string",
+        description: "Configuration key to get",
+        required: true,
+        label: "Key",
+        order: 1,
+        group: "Required",
+        placeholder: "e.g., name, email, theme",
+    },
+} as const satisfies OptionSchema;
+
+export class UserGetCommand extends Command<typeof options> {
+    readonly name = "get";
+    override displayName = "Get User Config";
+    readonly description = "Get a user configuration value";
+    readonly options = options;
+
+    override readonly actionLabel = "Get Value";
+
+    override readonly examples = [
+        { command: "config user get --key name", description: "Get user name" },
+        { command: "config user get --key email", description: "Get user email" },
+    ];
+
+    override async execute(opts: OptionValues<typeof options>): Promise<CommandResult> {
+        // Simulated user config store
+        const userConfig: Record<string, string> = {
+            name: "John Doe",
+            email: "john@example.com",
+            theme: "dark",
+            language: "en",
+        };
+
+        const value = userConfig[opts.key];
+        
+        if (value === undefined) {
+            AppContext.current.logger.warn(`Key "${opts.key}" not found in user configuration`);
+            return {
+                success: false,
+                message: `Key "${opts.key}" not found`,
+            };
+        }
+
+        AppContext.current.logger.info(`Retrieved user.${opts.key} = ${value}`);
+        return {
+            success: true,
+            data: { key: opts.key, value },
+        };
+    }
+
+    override renderResult(result: CommandResult): string {
+        if (!result.success) return result.message || "Error";
+        const data = result.data as { key: string; value: string };
+        return `user.${data.key} = "${data.value}"`;
+    }
+}

package/examples/tui-app/commands/config/user/index.ts

@@ -0,0 +1,23 @@
+import { Command, type CommandResult } from "../../../../../src/core/command.ts";
+import { UserGetCommand } from "./get.ts";
+import { UserSetCommand } from "./set.ts";
+
+export class UserConfigCommand extends Command {
+    readonly name = "user";
+    override displayName = "User Settings";
+    readonly description = "Manage user configuration";
+    readonly options = {};
+
+    override readonly subCommands = [
+        new UserGetCommand(),
+        new UserSetCommand(),
+    ];
+
+    override execute(): CommandResult {
+        console.log("Use 'config user <command>' for user configuration.");
+        console.log("Available: get, set");
+        return { success: true };
+    }
+}
+
+export { UserGetCommand, UserSetCommand };

package/examples/tui-app/commands/config/user/set.ts

@@ -0,0 +1,57 @@
+import { Command, type CommandResult } from "../../../../../src/core/command";
+import { AppContext } from "../../../../../src/core/context";
+import type { OptionSchema, OptionValues } from "../../../../../src/types/command";
+
+const options = {
+    key: {
+        type: "string",
+        description: "Configuration key to set",
+        required: true,
+        label: "Key",
+        order: 1,
+        group: "Required",
+        placeholder: "e.g., name, email, theme",
+    },
+    value: {
+        type: "string",
+        description: "Value to set",
+        required: true,
+        label: "Value",
+        order: 2,
+        group: "Required",
+        placeholder: "Enter value...",
+    },
+} as const satisfies OptionSchema;
+
+export class UserSetCommand extends Command<typeof options> {
+    readonly name = "set";
+    override displayName = "Set User Config";
+    readonly description = "Set a user configuration value";
+    readonly options = options;
+
+    override readonly actionLabel = "Set Value";
+
+    override readonly examples = [
+        { command: "config user set --key name --value 'Jane Doe'", description: "Set user name" },
+        { command: "config user set --key theme --value light", description: "Set theme" },
+    ];
+
+    override async execute(opts: OptionValues<typeof options>): Promise<CommandResult> {
+        AppContext.current.logger.info(`Setting user.${opts.key} = "${opts.value}"`);
+        
+        // Simulate setting the value
+        await new Promise(resolve => setTimeout(resolve, 300));
+        
+        AppContext.current.logger.info(`Successfully updated user configuration`);
+        return {
+            success: true,
+            data: { key: opts.key, value: opts.value },
+        };
+    }
+
+    override renderResult(result: CommandResult): string {
+        if (!result.success) return result.message || "Error";
+        const data = result.data as { key: string; value: string };
+        return `✓ Set user.${data.key} = "${data.value}"`;
+    }
+}

package/examples/tui-app/commands/greet.ts

@@ -1,10 +1,8 @@
-import { 
-    Command, 
-    type AppContext, 
-    type OptionSchema, 
-    type OptionValues,
-    type CommandResult 
-} from "../../../src/index.ts";
+import type { ReactNode } from "react";
+import { Command, type CommandResult } from "../../../src/core/command";
+import { AppContext } from "../../../src/core/context";
+import type { OptionSchema, OptionValues } from "../../../src/types/command";
+import { JsonHighlight } from "../../../src/tui/components/JsonHighlight.tsx";
 
 const greetOptions = {
     name: {
@@ -20,7 +18,7 @@ const greetOptions = {
         type: "boolean",
         description: "Use uppercase",
         alias: "l",
-        default: false,
+        default: true,
         label: "Loud Mode",
         order: 2,
         group: "Options",
@@ -37,6 +35,7 @@ const greetOptions = {
 
 export class GreetCommand extends Command<typeof greetOptions> {
     readonly name = "greet";
+    override displayName = "Greet";
     readonly description = "Greet someone with a friendly message";
     readonly options = greetOptions;
 
@@ -47,16 +46,20 @@ export class GreetCommand extends Command<typeof greetOptions> {
         { command: "greet --name World --loud --times 3", description: "Loud greeting 3 times" },
     ];
 
-    override async execute(ctx: AppContext, opts: OptionValues<typeof greetOptions>): Promise<CommandResult> {
+    override async execute(opts: OptionValues<typeof greetOptions>): Promise<CommandResult> {
         const greeting = this.createGreeting(opts);
-        ctx.logger.info(greeting);
+        AppContext.current.logger.trace(greeting);
         return {
             success: true,
-            data: { greeting, timestamp: new Date().toISOString() },
+            data: { greeting, timestamp: new Date().toISOString(), meta: { loud: opts.loud, times: opts.times } },
             message: greeting,
         };
     }
 
+    override renderResult(result: CommandResult): ReactNode {
+        return JsonHighlight({ value: result.data });
+    }
+
     override getClipboardContent(result: CommandResult): string | undefined {
         const data = result.data as { greeting?: string } | undefined;
         return data?.greeting;

package/examples/tui-app/commands/math.ts

@@ -1,10 +1,6 @@
-import { 
-    Command, 
-    type AppContext, 
-    type OptionSchema, 
-    type OptionValues,
-    type CommandResult 
-} from "../../../src/index.ts";
+import { Command, type CommandResult } from "../../../src/core/command";
+import { AppContext } from "../../../src/core/context";
+import type { OptionSchema, OptionValues } from "../../../src/types/command";
 
 const mathOptions = {
     operation: {
@@ -44,15 +40,16 @@ const mathOptions = {
 
 export class MathCommand extends Command<typeof mathOptions> {
     readonly name = "math";
+    override displayName = "Math Operations";
     readonly description = "Perform basic math operations";
     readonly options = mathOptions;
 
     override readonly actionLabel = "Calculate";
 
-    override async execute(ctx: AppContext, opts: OptionValues<typeof mathOptions>): Promise<CommandResult> {
+    override async execute(opts: OptionValues<typeof mathOptions>): Promise<CommandResult> {
         const result = this.calculate(opts);
         if (!result.success) {
-            ctx.logger.error(result.message || "Calculation failed");
+            AppContext.current.logger.error(result.message || "Calculation failed");
         }
         return result;
     }

package/examples/tui-app/commands/status.ts

@@ -1,10 +1,6 @@
-import { 
-    Command, 
-    type AppContext, 
-    type OptionSchema, 
-    type OptionValues,
-    type CommandResult 
-} from "../../../src/index.ts";
+import { Command, type CommandExecutionContext, type CommandResult } from "../../../src/core/command";
+import { AppContext } from "../../../src/core/context";
+import type { OptionSchema, OptionValues } from "../../../src/types/command";
 
 const statusOptions = {
     detailed: {
@@ -12,21 +8,23 @@ const statusOptions = {
         description: "Show detailed status",
         default: false,
         label: "Detailed",
+        alias: "d",
         order: 1,
     },
 } as const satisfies OptionSchema;
 
 export class StatusCommand extends Command<typeof statusOptions> {
     readonly name = "status";
+    override displayName = "Status";
     readonly description = "Show application status";
     readonly options = statusOptions;
 
     override readonly actionLabel = "Check Status";
     override readonly immediateExecution = true; // No required fields
 
-    override async execute(ctx: AppContext, opts: OptionValues<typeof statusOptions>): Promise<CommandResult> {
-        const result = await this.getStatus(opts);
-        ctx.logger.info(result.message || "Status check complete");
+    override async execute(opts: OptionValues<typeof statusOptions>, execCtx : CommandExecutionContext): Promise<CommandResult> {
+        const result = await this.getStatus(opts, execCtx);
+        AppContext.current.logger.info(result.message || "Status check complete");
         return result;
     }
 
@@ -39,15 +37,28 @@ export class StatusCommand extends Command<typeof statusOptions> {
             `  Uptime:   ${data.uptime}`,
             `  Memory:   ${data.memory}`,
             `  Platform: ${data.platform}`,
-            `  Node:     ${data.version}`,
+            `  Bun:      ${data.version}`,
         ].join("\n");
     }
 
-    private async getStatus(opts: OptionValues<typeof statusOptions>): Promise<CommandResult> {
+    private async getStatus(opts: OptionValues<typeof statusOptions>, execCtx: CommandExecutionContext): Promise<CommandResult> {
         const detailed = opts.detailed as boolean;
         
         // Simulate some async work
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise(resolve => {
+            let count = 0;
+            let interval = setInterval(() => {
+                count++;
+                AppContext.current.logger.info(`Applying configuration... (${count}/5)`);
+                if (count >= 5 || execCtx.signal.aborted) {
+                    if (count < 5) {
+                        AppContext.current.logger.warn("Status check aborted");
+                    }
+                    clearInterval(interval);
+                    resolve(undefined);
+                }
+            }, 1000);
+        });
 
         const memMB = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
         const uptimeSec = Math.round(process.uptime());

package/examples/tui-app/index.ts

@@ -12,8 +12,11 @@
  *   bun examples/tui-app/index.ts greet --name "World" --loud
  */
 
-import { TuiApplication } from "../../src/index.ts";
-import { GreetCommand, MathCommand, StatusCommand } from "./commands/index.ts";
+import { TuiApplication } from "../../src/tui/TuiApplication.tsx";
+import { ConfigCommand } from "./commands/config/index.ts";
+import { GreetCommand } from "./commands/greet.ts";
+import { MathCommand } from "./commands/math.ts";
+import { StatusCommand } from "./commands/status.ts";
 
 class ExampleApp extends TuiApplication {
     constructor() {
@@ -24,6 +27,7 @@ class ExampleApp extends TuiApplication {
                 new GreetCommand(),
                 new MathCommand(),
                 new StatusCommand(),
+                new ConfigCommand(),
             ],
             enableTui: true,
         });
@@ -31,4 +35,4 @@ class ExampleApp extends TuiApplication {
 }
 
 // Run the app
-await new ExampleApp().run(Bun.argv.slice(2));
+await new ExampleApp().run();

package/guides/01-hello-world.md

@@ -28,7 +28,12 @@ bun add @pablozaiden/terminatui
 Create `src/greet.ts`:
 
 ```typescript
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
+import {
+  Command,
+  type OptionSchema,
+  type CommandResult,
+  type CommandExecutionContext,
+} from "@pablozaiden/terminatui";
 
 const options = {
   name: {
@@ -43,7 +48,7 @@ export class GreetCommand extends Command<typeof options> {
   readonly description = "Greet someone";
   readonly options = options;
 
-  execute(_ctx: AppContext, config: { name: string }): CommandResult {
+  execute(config: { name: string }, _execCtx: CommandExecutionContext): CommandResult {
     console.log(`Hello, ${config.name}!`);
     return { success: true };
   }

package/guides/02-adding-options.md

@@ -19,7 +19,7 @@ myapp greet --name Alice --loud
 Update `src/greet.ts`:
 
 ```typescript
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
+import { Command, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
 
 const options = {
   name: {
@@ -40,7 +40,7 @@ export class GreetCommand extends Command<typeof options> {
   readonly description = "Greet someone";
   readonly options = options;
 
-  execute(_ctx: AppContext, config: { name: string; loud: boolean }): CommandResult {
+  execute(config: { name: string; loud: boolean }): CommandResult {
     const message = `Hello, ${config.name}!`;
     console.log(config.loud ? message.toUpperCase() : message);
     return { success: true };

package/guides/03-multiple-commands.md

@@ -19,8 +19,7 @@ fileutil count --dir ./src --ext .ts
 Create `src/commands/list.ts`:
 
 ```typescript
-import { readdirSync } from "fs";
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
+import { Command, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
 
 const options = {
   dir: {
@@ -36,9 +35,9 @@ export class ListCommand extends Command<typeof options> {
   readonly description = "List files in a directory";
   readonly options = options;
 
-  execute(_ctx: AppContext, config: { dir: string }): CommandResult {
+  async execute(config: { dir: string }): Promise<CommandResult> {
     try {
-      const files = readdirSync(config.dir);
+      const files = await Array.fromAsync(new Bun.Glob("*").scan({ cwd: config.dir, onlyFiles: false }));
       console.log(`Files in ${config.dir}:`);
       files.forEach((file) => console.log(`  ${file}`));
       return { success: true, message: `Found ${files.length} files` };
@@ -54,8 +53,7 @@ export class ListCommand extends Command<typeof options> {
 Create `src/commands/count.ts`:
 
 ```typescript
-import { readdirSync } from "fs";
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
+import { Command, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
 
 const options = {
   dir: {
@@ -76,9 +74,9 @@ export class CountCommand extends Command<typeof options> {
   readonly description = "Count files in a directory";
   readonly options = options;
 
-  execute(_ctx: AppContext, config: { dir: string; ext?: string }): CommandResult {
+  async execute(config: { dir: string; ext?: string }): Promise<CommandResult> {
     try {
-      let files = readdirSync(config.dir);
+      let files = await Array.fromAsync(new Bun.Glob("*").scan({ cwd: config.dir, onlyFiles: false }));
       
       if (config.ext) {
         files = files.filter((f) => f.endsWith(config.ext!));

package/guides/04-subcommands.md

@@ -17,7 +17,7 @@ dbctl db status
 Create `src/commands/db/migrate.ts`:
 
 ```typescript
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
+import { Command, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
 
 const options = {
   target: {
@@ -37,7 +37,7 @@ export class MigrateCommand extends Command<typeof options> {
   readonly description = "Run database migrations";
   readonly options = options;
 
-  execute(ctx: AppContext, config: { target: string; dry: boolean }): CommandResult {
+  execute(config: { target: string; dry: boolean }): CommandResult {
     ctx.logger.info(`Migrating to: ${config.target}`);
     
     if (config.dry) {
@@ -55,7 +55,7 @@ export class MigrateCommand extends Command<typeof options> {
 Create `src/commands/db/seed.ts`:
 
 ```typescript
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
+import { Command, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
 
 const options = {
   file: {
@@ -71,7 +71,7 @@ export class SeedCommand extends Command<typeof options> {
   readonly description = "Seed the database with data";
   readonly options = options;
 
-  execute(ctx: AppContext, config: { file: string }): CommandResult {
+  execute(config: { file: string }): CommandResult {
     ctx.logger.info(`Seeding from: ${config.file}`);
     console.log(`Loading seed data from ${config.file}...`);
     console.log("Database seeded successfully!");
@@ -83,14 +83,14 @@ export class SeedCommand extends Command<typeof options> {
 Create `src/commands/db/status.ts`:
 
 ```typescript
-import { Command, type AppContext, type CommandResult } from "@pablozaiden/terminatui";
+import { Command, type CommandResult } from "@pablozaiden/terminatui";
 
 export class StatusCommand extends Command {
   readonly name = "status";
   readonly description = "Show database status";
   readonly options = {};
 
-  execute(_ctx: AppContext): CommandResult {
+  execute(): CommandResult {
     console.log("Database Status:");
     console.log("  Connected: Yes");
     console.log("  Version: 1.2.3");
@@ -105,7 +105,7 @@ export class StatusCommand extends Command {
 Create `src/commands/db/index.ts`:
 
 ```typescript
-import { Command, type AppContext, type CommandResult } from "@pablozaiden/terminatui";
+import { Command, type CommandResult } from "@pablozaiden/terminatui";
 import { MigrateCommand } from "./migrate";
 import { SeedCommand } from "./seed";
 import { StatusCommand } from "./status";
@@ -123,7 +123,7 @@ export class DbCommand extends Command {
   ];
 
   // Parent command can have its own execute (optional)
-  execute(_ctx: AppContext): CommandResult {
+  execute(): CommandResult {
     console.log("Use 'dbctl db <command>' for database operations.");
     console.log("Available: migrate, seed, status");
     return { success: true };