@pablozaiden/terminatui 0.3.0-beta-1 → 0.4.0

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

@@ -1,23 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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,78 +0,0 @@
-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: {
-        type: "string",
-        description: "Name to greet",
-        required: true,
-        label: "Name",
-        order: 1,
-        group: "Required",
-        placeholder: "Enter name...",
-    },
-    loud: {
-        type: "boolean",
-        description: "Use uppercase",
-        alias: "l",
-        default: true,
-        label: "Loud Mode",
-        order: 2,
-        group: "Options",
-    },
-    times: {
-        type: "number",
-        description: "Number of times to greet",
-        default: 1,
-        label: "Repeat Count",
-        order: 3,
-        group: "Options",
-    },
-} as const satisfies OptionSchema;
-
-export class GreetCommand extends Command<typeof greetOptions> {
-    readonly name = "greet";
-    override displayName = "Greet";
-    readonly description = "Greet someone with a friendly message";
-    readonly options = greetOptions;
-
-    override readonly actionLabel = "Say Hello";
-
-    override readonly examples = [
-        { command: "greet --name World", description: "Simple greeting" },
-        { command: "greet --name World --loud --times 3", description: "Loud greeting 3 times" },
-    ];
-
-    override async execute(opts: OptionValues<typeof greetOptions>): Promise<CommandResult> {
-        const greeting = this.createGreeting(opts);
-        AppContext.current.logger.trace(greeting);
-        return {
-            success: true,
-            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;
-    }
-
-    private createGreeting(opts: OptionValues<typeof greetOptions>): string {
-        const name = opts.name as string;
-        const loud = opts.loud as boolean;
-        const times = (opts.times as number) || 1;
-
-        let message = `Hello, ${name}!`;
-        if (loud) message = message.toUpperCase();
-
-        return Array(times).fill(message).join("\n");
-    }
-}

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

@@ -1,111 +0,0 @@
-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: {
-        type: "string",
-        description: "Math operation to perform",
-        required: true,
-        enum: ["add", "subtract", "multiply", "divide"] as const,
-        label: "Operation",
-        order: 1,
-        group: "Required",
-    },
-    a: {
-        type: "number",
-        description: "First number",
-        required: true,
-        label: "First Number",
-        order: 2,
-        group: "Required",
-    },
-    b: {
-        type: "number",
-        description: "Second number",
-        required: true,
-        label: "Second Number",
-        order: 3,
-        group: "Required",
-    },
-    showSteps: {
-        type: "boolean",
-        description: "Show calculation steps",
-        default: false,
-        label: "Show Steps",
-        order: 4,
-        group: "Options",
-    },
-} as const satisfies OptionSchema;
-
-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(opts: OptionValues<typeof mathOptions>): Promise<CommandResult> {
-        const result = this.calculate(opts);
-        if (!result.success) {
-            AppContext.current.logger.error(result.message || "Calculation failed");
-        }
-        return result;
-    }
-
-    override renderResult(result: CommandResult): string {
-        if (!result.success) return result.message || "Error";
-        const data = result.data as { expression: string; result: number; steps?: string[] };
-        let output = `${data.expression} = ${data.result}`;
-        if (data.steps) {
-            output += "\n\nSteps:\n" + data.steps.map((s, i) => `  ${i + 1}. ${s}`).join("\n");
-        }
-        return output;
-    }
-
-    private calculate(opts: OptionValues<typeof mathOptions>): CommandResult {
-        const op = opts.operation as string;
-        const a = opts.a as number;
-        const b = opts.b as number;
-        const showSteps = opts.showSteps as boolean;
-
-        let result: number;
-        let expression: string;
-        const steps: string[] = [];
-
-        switch (op) {
-            case "add":
-                result = a + b;
-                expression = `${a} + ${b}`;
-                if (showSteps) steps.push(`Adding ${a} and ${b}`, `Result: ${result}`);
-                break;
-            case "subtract":
-                result = a - b;
-                expression = `${a} - ${b}`;
-                if (showSteps) steps.push(`Subtracting ${b} from ${a}`, `Result: ${result}`);
-                break;
-            case "multiply":
-                result = a * b;
-                expression = `${a} × ${b}`;
-                if (showSteps) steps.push(`Multiplying ${a} by ${b}`, `Result: ${result}`);
-                break;
-            case "divide":
-                if (b === 0) {
-                    return { success: false, message: "Cannot divide by zero" };
-                }
-                result = a / b;
-                expression = `${a} ÷ ${b}`;
-                if (showSteps) steps.push(`Dividing ${a} by ${b}`, `Result: ${result}`);
-                break;
-            default:
-                return { success: false, message: `Unknown operation: ${op}` };
-        }
-
-        return {
-            success: true,
-            data: { expression, result, steps: showSteps ? steps : undefined },
-            message: `${expression} = ${result}`,
-        };
-    }
-}

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

@@ -1,86 +0,0 @@
-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: {
-        type: "boolean",
-        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(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;
-    }
-
-    override renderResult(result: CommandResult): string {
-        if (!result.success) return "❌ Status check failed";
-        const data = result.data as { uptime: string; memory: string; platform: string; version: string };
-        return [
-            "✓ Application Status",
-            "",
-            `  Uptime:   ${data.uptime}`,
-            `  Memory:   ${data.memory}`,
-            `  Platform: ${data.platform}`,
-            `  Bun:      ${data.version}`,
-        ].join("\n");
-    }
-
-    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 => {
-            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());
-
-        const data: Record<string, unknown> = {
-            uptime: `${uptimeSec} seconds`,
-            memory: `${memMB} MB`,
-            platform: process.platform,
-            version: Bun.version,
-        };
-
-        if (detailed) {
-            Object.assign(data, {
-                cwd: process.cwd(),
-                pid: process.pid,
-            });
-        }
-
-        return {
-            success: true,
-            data,
-            message: "All systems operational",
-        };
-    }
-}

package/examples/tui-app/index.ts

@@ -1,38 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Example TUI Application
- * 
- * Demonstrates how to use TuiApplication to build a CLI/TUI app
- * with minimal effort. Just run:
- * 
- *   bun examples/tui-app/index.ts
- * 
- * Or in CLI mode:
- * 
- *   bun examples/tui-app/index.ts greet --name "World" --loud
- */
-
-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() {
-        super({
-            name: "example",
-            version: "1.0.0",
-            commands: [
-                new GreetCommand(),
-                new MathCommand(),
-                new StatusCommand(),
-                new ConfigCommand(),
-            ],
-            enableTui: true,
-        });
-    }
-}
-
-// Run the app
-await new ExampleApp().run();

package/guides/01-hello-world.md

@@ -1,101 +0,0 @@
-# Guide 1: Hello World CLI (Super Simple)
-
-Create your first CLI app with Terminatui in under 5 minutes.
-
-## What You'll Build
-
-A simple CLI that greets the user by name.
-
-```bash
-myapp greet --name Alice
-# Output: Hello, Alice!
-```
-
-## Prerequisites
-
-- Bun installed (`curl -fsSL https://bun.sh/install | bash`)
-
-## Step 1: Create Project
-
-```bash
-mkdir hello-cli && cd hello-cli
-bun init -y
-bun add @pablozaiden/terminatui
-```
-
-## Step 2: Create the Command
-
-Create `src/greet.ts`:
-
-```typescript
-import {
-  Command,
-  type OptionSchema,
-  type CommandResult,
-  type CommandExecutionContext,
-} from "@pablozaiden/terminatui";
-
-const options = {
-  name: {
-    type: "string",
-    description: "Name to greet",
-    required: true,
-  },
-} satisfies OptionSchema;
-
-export class GreetCommand extends Command<typeof options> {
-  readonly name = "greet";
-  readonly description = "Greet someone";
-  readonly options = options;
-
-  execute(config: { name: string }, _execCtx: CommandExecutionContext): CommandResult {
-    console.log(`Hello, ${config.name}!`);
-    return { success: true };
-  }
-}
-```
-
-## Step 3: Create the App
-
-Create `src/index.ts`:
-
-```typescript
-import { Application } from "@pablozaiden/terminatui";
-import { GreetCommand } from "./greet";
-
-class MyApp extends Application {
-  constructor() {
-    super({
-      name: "myapp",
-      version: "1.0.0",
-      commands: [new GreetCommand()],
-    });
-  }
-}
-
-await new MyApp().run();
-```
-
-## Step 4: Run It
-
-```bash
-bun src/index.ts greet --name Alice
-# Output: Hello, Alice!
-
-bun src/index.ts help
-# Shows available commands
-
-bun src/index.ts greet help
-# Shows greet options
-```
-
-## What You Learned
-
-- Commands extend the `Command` class
-- Options are defined with `OptionSchema`
-- The `execute()` method handles the logic
-- `Application` ties everything together
-
-## Next Steps
-
-→ [Guide 2: Adding Options](02-adding-options.md)

package/guides/02-adding-options.md

@@ -1,103 +0,0 @@
-# Guide 2: Adding Options (Super Simple)
-
-Add boolean and string options to make your CLI more flexible.
-
-## What You'll Build
-
-Extend the greeting command with a `--loud` flag:
-
-```bash
-myapp greet --name Alice
-# Output: Hello, Alice!
-
-myapp greet --name Alice --loud
-# Output: HELLO, ALICE!
-```
-
-## Step 1: Add the Option
-
-Update `src/greet.ts`:
-
-```typescript
-import { Command, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
-
-const options = {
-  name: {
-    type: "string",
-    description: "Name to greet",
-    required: true,
-  },
-  loud: {
-    type: "boolean",
-    description: "Shout the greeting",
-    alias: "l",        // Short flag: -l
-    default: false,
-  },
-} satisfies OptionSchema;
-
-export class GreetCommand extends Command<typeof options> {
-  readonly name = "greet";
-  readonly description = "Greet someone";
-  readonly options = options;
-
-  execute(config: { name: string; loud: boolean }): CommandResult {
-    const message = `Hello, ${config.name}!`;
-    console.log(config.loud ? message.toUpperCase() : message);
-    return { success: true };
-  }
-}
-```
-
-## Step 2: Test It
-
-```bash
-# Normal greeting
-bun src/index.ts greet --name Alice
-# Hello, Alice!
-
-# Loud greeting with long flag
-bun src/index.ts greet --name Bob --loud
-# HELLO, BOB!
-
-# Loud greeting with short flag
-bun src/index.ts greet --name Charlie -l
-# HELLO, CHARLIE!
-
-# View help to see options
-bun src/index.ts greet help
-```
-
-## Key Concepts
-
-### Option Types
-
-| Type | Description | Example |
-|------|-------------|---------|
-| `string` | Text value | `--name Alice` |
-| `boolean` | Flag (true/false) | `--loud` or `--no-loud` |
-| `number` | Numeric value | `--count 5` |
-| `array` | Multiple values | `--tags a --tags b` |
-
-### Option Properties
-
-```typescript
-{
-  type: "string",
-  description: "Help text",   // Required
-  required: true,             // Must be provided
-  default: "value",           // Default if not provided
-  alias: "n",                 // Short flag (-n)
-  enum: ["a", "b", "c"],      // Restrict to values
-}
-```
-
-## What You Learned
-
-- Add options with different types
-- Use `alias` for short flags (-l instead of --loud)
-- Use `default` for optional values
-- Boolean flags can be negated with `--no-` prefix
-
-## Next Steps
-
-→ [Guide 3: Multiple Commands](03-multiple-commands.md)