@pablozaiden/terminatui 0.2.0 → 0.3.0

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

@@ -1,76 +0,0 @@
-import { 
-    Command, 
-    type AppContext, 
-    type OptionSchema, 
-    type OptionValues,
-    type CommandResult 
-} from "../../../src/index.ts";
-
-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: false,
-        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(ctx: AppContext, opts: OptionValues<typeof greetOptions>): Promise<CommandResult> {
-        const greeting = this.createGreeting(opts);
-        ctx.logger.info(greeting);
-        return {
-            success: true,
-            data: { greeting, timestamp: new Date().toISOString() },
-            message: greeting,
-        };
-    }
-
-    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/index.ts

@@ -1,4 +0,0 @@
-export { GreetCommand } from "./greet.ts";
-export { MathCommand } from "./math.ts";
-export { StatusCommand } from "./status.ts";
-export { ConfigCommand } from "./config/index.ts";

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

@@ -1,115 +0,0 @@
-import { 
-    Command, 
-    type AppContext, 
-    type OptionSchema, 
-    type OptionValues,
-    type CommandResult 
-} from "../../../src/index.ts";
-
-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(ctx: AppContext, opts: OptionValues<typeof mathOptions>): Promise<CommandResult> {
-        const result = this.calculate(opts);
-        if (!result.success) {
-            ctx.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,77 +0,0 @@
-import { 
-    Command, 
-    type AppContext, 
-    type OptionSchema, 
-    type OptionValues,
-    type CommandResult 
-} from "../../../src/index.ts";
-
-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(ctx: AppContext, opts: OptionValues<typeof statusOptions>): Promise<CommandResult> {
-        const result = await this.getStatus(opts);
-        ctx.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>): Promise<CommandResult> {
-        const detailed = opts.detailed as boolean;
-        
-        // Simulate some async work
-        await new Promise((resolve) => setTimeout(resolve, 500));
-
-        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,35 +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/index.ts";
-import { GreetCommand, MathCommand, StatusCommand, ConfigCommand } from "./commands/index.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(Bun.argv.slice(2));

package/guides/01-hello-world.md

@@ -1,96 +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 AppContext, type OptionSchema, type CommandResult } 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(_ctx: AppContext, config: { name: string }): 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 AppContext, 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(_ctx: AppContext, 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)

package/guides/03-multiple-commands.md

@@ -1,163 +0,0 @@
-# Guide 3: Multiple Commands (Basic)
-
-Build a CLI with multiple commands that share common functionality.
-
-## What You'll Build
-
-A file utility CLI with `list` and `count` commands:
-
-```bash
-fileutil list --dir ./src
-# Lists files in directory
-
-fileutil count --dir ./src --ext .ts
-# Counts files with extension
-```
-
-## Step 1: Create the List Command
-
-Create `src/commands/list.ts`:
-
-```typescript
-import { readdirSync } from "fs";
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
-
-const options = {
-  dir: {
-    type: "string",
-    description: "Directory to list",
-    required: true,
-    alias: "d",
-  },
-} satisfies OptionSchema;
-
-export class ListCommand extends Command<typeof options> {
-  readonly name = "list";
-  readonly description = "List files in a directory";
-  readonly options = options;
-
-  execute(_ctx: AppContext, config: { dir: string }): CommandResult {
-    try {
-      const files = readdirSync(config.dir);
-      console.log(`Files in ${config.dir}:`);
-      files.forEach((file) => console.log(`  ${file}`));
-      return { success: true, message: `Found ${files.length} files` };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
-  }
-}
-```
-
-## Step 2: Create the Count Command
-
-Create `src/commands/count.ts`:
-
-```typescript
-import { readdirSync } from "fs";
-import { Command, type AppContext, type OptionSchema, type CommandResult } from "@pablozaiden/terminatui";
-
-const options = {
-  dir: {
-    type: "string",
-    description: "Directory to search",
-    required: true,
-    alias: "d",
-  },
-  ext: {
-    type: "string",
-    description: "File extension to count (e.g., .ts)",
-    alias: "e",
-  },
-} satisfies OptionSchema;
-
-export class CountCommand extends Command<typeof options> {
-  readonly name = "count";
-  readonly description = "Count files in a directory";
-  readonly options = options;
-
-  execute(_ctx: AppContext, config: { dir: string; ext?: string }): CommandResult {
-    try {
-      let files = readdirSync(config.dir);
-      
-      if (config.ext) {
-        files = files.filter((f) => f.endsWith(config.ext!));
-      }
-      
-      console.log(`Found ${files.length} files${config.ext ? ` with ${config.ext}` : ""}`);
-      return { success: true, data: { count: files.length } };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
-  }
-}
-```
-
-## Step 3: Create the Application
-
-Create `src/index.ts`:
-
-```typescript
-import { Application } from "@pablozaiden/terminatui";
-import { ListCommand } from "./commands/list";
-import { CountCommand } from "./commands/count";
-
-class FileUtilApp extends Application {
-  constructor() {
-    super({
-      name: "fileutil",
-      version: "1.0.0",
-      description: "File utility commands",
-      commands: [
-        new ListCommand(),
-        new CountCommand(),
-      ],
-    });
-  }
-}
-
-await new FileUtilApp().run();
-```
-
-## Step 4: Test It
-
-```bash
-# List files
-bun src/index.ts list --dir ./src
-# Files in ./src:
-#   commands
-#   index.ts
-
-# Count all files
-bun src/index.ts count -d ./src
-# Found 2 files
-
-# Count only .ts files
-bun src/index.ts count -d ./src -e .ts
-# Found 1 files with .ts
-
-# Show help
-bun src/index.ts help
-# Lists: list, count, version, help
-```
-
-## Project Structure
-
-```
-src/
-├── index.ts           # App entry point
-└── commands/
-    ├── list.ts        # List command
-    └── count.ts       # Count command
-```
-
-## What You Learned
-
-- Create multiple commands in separate files
-- Return structured `CommandResult` with data
-- Handle errors gracefully
-- Use consistent option patterns across commands
-
-## Next Steps
-
-→ [Guide 4: Subcommands](04-subcommands.md)