@pablozaiden/terminatui 0.1.2 → 0.3.0-beta-1

package/src/__tests__/builtins.test.ts

@@ -1,7 +1,8 @@
-import { test, expect, describe, mock, beforeEach, afterEach } from "bun:test";
-import { createVersionCommand, formatVersion } from "../builtins/version.ts";
-import { createHelpCommand } from "../commands/help.ts";
-import { defineCommand } from "../types/command.ts";
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { createVersionCommand } from "../builtins/version.ts";
+import { createHelpCommandForParent, createRootHelpCommand } from "../builtins/help.ts";
+import { Command } from "../core/command.ts";
+import { KNOWN_COMMANDS } from "../core/knownCommands.ts";
 
 describe("Built-in Commands", () => {
   let originalLog: typeof console.log;
@@ -19,27 +20,6 @@ describe("Built-in Commands", () => {
     console.log = originalLog;
   });
 
-  describe("formatVersion", () => {
-    test("formats version with commit hash", () => {
-      const result = formatVersion("1.0.0", "abc1234567890");
-      expect(result).toBe("1.0.0 - abc1234");
-    });
-
-    test("formats version with short commit hash", () => {
-      const result = formatVersion("1.0.0", "abc1234");
-      expect(result).toBe("1.0.0 - abc1234");
-    });
-
-    test("shows (dev) when no commit hash", () => {
-      const result = formatVersion("1.0.0");
-      expect(result).toBe("1.0.0 - (dev)");
-    });
-
-    test("shows (dev) when commit hash is empty", () => {
-      const result = formatVersion("1.0.0", "");
-      expect(result).toBe("1.0.0 - (dev)");
-    });
-  });
 
   describe("VersionCommand", () => {
     test("creates command with name 'version'", () => {
@@ -70,64 +50,36 @@ describe("Built-in Commands", () => {
     });
   });
 
-  describe("createHelpCommand", () => {
-    const mockCommands = [
-      defineCommand({
-        name: "run",
-        description: "Run something",
-        execute: () => {},
-      }),
-      defineCommand({
-        name: "build",
-        description: "Build something",
-        execute: () => {},
-      }),
-    ];
-
-    test("creates command with name 'help'", () => {
-      const cmd = createHelpCommand({ getCommands: () => mockCommands });
-      expect(cmd.name).toBe("help");
+  describe("HelpCommand", () => {
+    test("createRootHelpCommand creates command with name 'help'", () => {
+      const cmd = createRootHelpCommand([], "myapp", "1.0.0");
+      expect(cmd.name).toBe(KNOWN_COMMANDS.help);
     });
 
-    test("has description", () => {
-      const cmd = createHelpCommand({ getCommands: () => mockCommands });
-      expect(cmd.description).toBeDefined();
+    test("is hidden in TUI", () => {
+      const cmd = createRootHelpCommand([], "myapp", "1.0.0");
+      expect(cmd.tuiHidden).toBe(true);
+      expect(cmd.supportsTui()).toBe(false);
     });
 
-    test("has aliases including --help", () => {
-      const cmd = createHelpCommand({ getCommands: () => mockCommands });
-      expect(cmd.aliases).toContain("--help");
+    test("execute prints app help", async () => {
+      const cmd = createRootHelpCommand([], "myapp", "1.0.0");
+      await cmd.execute();
+      expect(logOutput.join("\n")).toContain("myapp");
     });
 
-    test("is hidden by default", () => {
-      const cmd = createHelpCommand({ getCommands: () => mockCommands });
-      expect(cmd.hidden).toBe(true);
-    });
+    test("createHelpCommandForParent prints parent help", async () => {
+      class ParentCommand extends Command {
+        readonly name = "run";
+        readonly description = "Run something";
+        readonly options = {} as const;
 
-    test("has command option", () => {
-      const cmd = createHelpCommand({ getCommands: () => mockCommands });
-      expect(cmd.options?.["command"]).toBeDefined();
-    });
-
-    test("execute calls getCommands", () => {
-      const getCommands = mock(() => mockCommands);
-      const cmd = createHelpCommand({ getCommands });
-      // @ts-expect-error - testing with partial options
-      cmd.execute({ options: {}, args: [], commandPath: ["help"] });
-      expect(getCommands).toHaveBeenCalled();
-    });
+        override async execute(): Promise<void> {}
+      }
 
-    test("shows help for specific command when provided", () => {
-      const cmd = createHelpCommand({
-        getCommands: () => mockCommands,
-        appName: "myapp",
-      });
-      cmd.execute({
-        options: { command: "run" },
-        args: [],
-        commandPath: ["help"],
-      });
-      expect(logOutput.join("")).toContain("run");
+      const cmd = createHelpCommandForParent(new ParentCommand(), "myapp", "1.0.0");
+      await cmd.execute();
+      expect(logOutput.join("\n")).toContain("run");
     });
   });
 });

package/src/__tests__/command.test.ts

@@ -1,157 +1,126 @@
 import { test, expect, describe } from "bun:test";
-import { defineCommand } from "../types/command.ts";
-
-describe("defineCommand", () => {
-  test("creates a command with name and description", () => {
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      execute: () => {},
-    });
-
+import { Command } from "../core/command.ts";
+import type { OptionSchema, OptionValues } from "../types/command.ts";
+
+const testOptions = {
+  verbose: {
+    type: "boolean",
+    description: "Enable verbose output",
+    alias: "v",
+  },
+  name: {
+    type: "string",
+    description: "Name option",
+  },
+} as const satisfies OptionSchema;
+
+describe("Command (class-based)", () => {
+  test("has name and description", () => {
+    class TestCommand extends Command<typeof testOptions> {
+      readonly name = "test";
+      readonly description = "A test command";
+      readonly options = testOptions;
+
+      override async execute(): Promise<void> {}
+    }
+
+    const cmd = new TestCommand();
     expect(cmd.name).toBe("test");
     expect(cmd.description).toBe("A test command");
   });
 
-  test("creates a command with options", () => {
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      options: {
-        verbose: {
-          type: "boolean",
-          description: "Enable verbose output",
-          alias: "v",
-        },
-      },
-      execute: () => {},
-    });
-
-    expect(cmd.options?.["verbose"]).toBeDefined();
-    expect(cmd.options?.["verbose"]?.type).toBe("boolean");
-  });
+  test("has options", () => {
+    class TestCommand extends Command<typeof testOptions> {
+      readonly name = "test";
+      readonly description = "A test command";
+      readonly options = testOptions;
 
-  test("creates a command with aliases", () => {
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      aliases: ["t", "tst"],
-      execute: () => {},
-    });
+      override async execute(): Promise<void> {}
+    }
 
-    expect(cmd.aliases).toEqual(["t", "tst"]);
+    const cmd = new TestCommand();
+    expect(cmd.options["verbose"]?.type).toBe("boolean");
   });
 
-  test("creates a command with subcommands", () => {
-    const sub = defineCommand({
-      name: "sub",
-      description: "A subcommand",
-      execute: () => {},
-    });
-
-    const cmd = defineCommand({
-      name: "parent",
-      description: "A parent command",
-      subcommands: { sub },
-      execute: () => {},
-    });
-
-    expect(cmd.subcommands?.["sub"]).toBe(sub);
-  });
+  test("supports subcommands", () => {
+    class SubCommand extends Command<OptionSchema> {
+      readonly name = "sub";
+      readonly description = "A subcommand";
+      readonly options = {} as const;
 
-  test("executes sync command", () => {
-    let executed = false;
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      execute: () => {
-        executed = true;
-      },
-    });
-
-    cmd.execute({ options: {}, args: [], commandPath: ["test"] });
-    expect(executed).toBe(true);
-  });
+      override async execute(): Promise<void> {}
+    }
 
-  test("executes async command", async () => {
-    let executed = false;
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      execute: async () => {
-        await new Promise((r) => setTimeout(r, 10));
-        executed = true;
-      },
-    });
-
-    await cmd.execute({ options: {}, args: [], commandPath: ["test"] });
-    expect(executed).toBe(true);
-  });
+    class ParentCommand extends Command<OptionSchema> {
+      readonly name = "parent";
+      readonly description = "A parent command";
+      readonly options = {} as const;
+      override subCommands = [new SubCommand()];
+
+      override async execute(): Promise<void> {}
+    }
 
-  test("passes options to execute", () => {
-    let receivedOptions: unknown;
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      options: {
-        name: {
-          type: "string",
-          description: "Name option",
-        },
-      },
-      execute: (ctx) => {
-        receivedOptions = ctx.options;
-      },
-    });
-
-    cmd.execute({ options: { name: "world" }, args: [], commandPath: ["test"] });
-    expect(receivedOptions).toEqual({ name: "world" });
+    const cmd = new ParentCommand();
+    expect(cmd.getSubCommand("sub")?.name).toBe("sub");
   });
 
-  test("supports beforeExecute hook", async () => {
-    const order: string[] = [];
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      beforeExecute: () => {
-        order.push("before");
-      },
-      execute: () => {
-        order.push("execute");
-      },
-    });
+  test("executes command", async () => {
+    class ExecCommand extends Command<typeof testOptions> {
+      readonly name = "exec";
+      readonly description = "Exec command";
+      readonly options = testOptions;
 
-    await cmd.beforeExecute?.({ options: {}, args: [], commandPath: ["test"] });
-    await cmd.execute({ options: {}, args: [], commandPath: ["test"] });
-    expect(order).toEqual(["before", "execute"]);
+      executedWith: OptionValues<typeof testOptions> | null = null;
+
+      override async execute(opts: OptionValues<typeof testOptions>): Promise<void> {
+        this.executedWith = opts;
+      }
+    }
+
+    const cmd = new ExecCommand();
+    await cmd.execute({ verbose: true, name: "world" });
+    expect(cmd.executedWith).toEqual({ verbose: true, name: "world" });
   });
 
-  test("supports afterExecute hook", async () => {
+  test("beforeExecute/afterExecute hooks are callable", () => {
     const order: string[] = [];
-    const cmd = defineCommand({
-      name: "test",
-      description: "A test command",
-      execute: () => {
+
+    class HookCommand extends Command<OptionSchema> {
+      readonly name = "hook";
+      readonly description = "Hook command";
+      readonly options = {} as const;
+
+      override beforeExecute(): void {
+        order.push("before");
+      }
+
+      override execute(): void {
         order.push("execute");
-      },
-      afterExecute: () => {
+      }
+
+      override afterExecute(): void {
         order.push("after");
-      },
-    });
+      }
+    }
 
-    await cmd.execute({ options: {}, args: [], commandPath: ["test"] });
-    await cmd.afterExecute?.({ options: {}, args: [], commandPath: ["test"] });
-    expect(order).toEqual(["execute", "after"]);
+    const cmd = new HookCommand();
+    cmd.beforeExecute();
+    cmd.execute();
+    cmd.afterExecute();
+
+    expect(order).toEqual(["before", "execute", "after"]);
   });
 
-  test("supports hidden commands", () => {
-    const cmd = defineCommand({
-      name: "hidden",
-      description: "A hidden command",
-      hidden: true,
-      execute: () => {},
-    });
+  test("supports tuiHidden", () => {
+    class HiddenCommand extends Command<OptionSchema> {
+      readonly name = "hidden";
+      readonly description = "Hidden";
+      readonly options = {} as const;
+      override readonly tuiHidden = true;
+
+      override async execute(): Promise<void> {}
+    }
 
-    expect(cmd.hidden).toBe(true);
+    expect(new HiddenCommand().tuiHidden).toBe(true);
   });
 });

package/src/__tests__/context.test.ts

@@ -3,7 +3,7 @@ import { AppContext, type AppConfig } from "../core/context.ts";
 
 describe("AppContext", () => {
   afterEach(() => {
-    AppContext.clearCurrent();
+    AppContext.setCurrent(new AppContext({ name: "empty", version: "0.0.0" }));
   });
 
   describe("constructor", () => {
@@ -22,37 +22,12 @@ describe("AppContext", () => {
   });
 
   describe("static current", () => {
-    test("throws when no current context", () => {
-      expect(() => AppContext.current).toThrow(
-        "AppContext.current accessed before initialization"
-      );
-    });
-
     test("returns current context after setCurrent", () => {
       const config: AppConfig = { name: "test", version: "1.0.0" };
       const ctx = new AppContext(config);
       AppContext.setCurrent(ctx);
       expect(AppContext.current).toBe(ctx);
     });
-
-    test("hasCurrent returns false when no context", () => {
-      expect(AppContext.hasCurrent()).toBe(false);
-    });
-
-    test("hasCurrent returns true after setCurrent", () => {
-      const config: AppConfig = { name: "test", version: "1.0.0" };
-      const ctx = new AppContext(config);
-      AppContext.setCurrent(ctx);
-      expect(AppContext.hasCurrent()).toBe(true);
-    });
-
-    test("clearCurrent clears the context", () => {
-      const config: AppConfig = { name: "test", version: "1.0.0" };
-      const ctx = new AppContext(config);
-      AppContext.setCurrent(ctx);
-      AppContext.clearCurrent();
-      expect(AppContext.hasCurrent()).toBe(false);
-    });
   });
 
   describe("services", () => {

package/src/__tests__/helpCore.test.ts

@@ -0,0 +1,227 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatExamples,
+  formatOptionSchema,
+  formatOptions,
+  formatSubCommands,
+  formatUsage,
+  generateAppHelp,
+  generateCommandHelp,
+} from "../core/help.ts";
+import { Command } from "../core/command.ts";
+import type { OptionSchema } from "../types/command.ts";
+
+class SimpleCommand extends Command<OptionSchema> {
+  readonly name: string;
+  readonly description: string;
+  readonly options: OptionSchema;
+
+  constructor(config: { name: string; description: string; options?: OptionSchema }) {
+    super();
+    this.name = config.name;
+    this.description = config.description;
+    this.options = config.options ?? {};
+  }
+
+  override async execute(): Promise<void> {}
+}
+
+describe("Help Generation (core)", () => {
+  describe("formatUsage", () => {
+    test("formats basic usage and includes tokens", () => {
+      const cmd = new SimpleCommand({
+        name: "parent",
+        description: "Parent",
+        options: { verbose: { type: "boolean", description: "Verbose" } },
+      });
+      cmd.subCommands = [new SimpleCommand({ name: "child", description: "Child" })];
+
+      const usage = formatUsage(cmd, { appName: "myapp" });
+      expect(usage).toContain("myapp");
+      expect(usage).toContain("parent");
+      expect(usage).toContain("[command]");
+      expect(usage).toContain("[options]");
+    });
+  });
+
+  describe("formatSubCommands", () => {
+    test("formats subcommands list", () => {
+      const cmd = new SimpleCommand({ name: "parent", description: "Parent" });
+      cmd.subCommands = [new SimpleCommand({ name: "child", description: "Child command" })];
+
+      const commands = formatSubCommands(cmd);
+      expect(commands).toContain("child");
+      expect(commands).toContain("Child command");
+    });
+
+    test("returns empty for no subcommands", () => {
+      const cmd = new SimpleCommand({ name: "test", description: "Test" });
+      const commands = formatSubCommands(cmd);
+      expect(commands).toBe("");
+    });
+  });
+
+  describe("formatOptions", () => {
+    test("formats options with descriptions", () => {
+      const cmd = new SimpleCommand({
+        name: "test",
+        description: "Test",
+        options: { verbose: { type: "boolean", description: "Enable verbose" } },
+      });
+
+      const options = formatOptions(cmd);
+      expect(options).toContain("--verbose");
+      expect(options).toContain("Enable verbose");
+    });
+
+    test("shows option aliases", () => {
+      const cmd = new SimpleCommand({
+        name: "test",
+        description: "Test",
+        options: { verbose: { type: "boolean", alias: "v", description: "Verbose" } },
+      });
+
+      const options = formatOptions(cmd);
+      expect(options).toContain("-v");
+    });
+
+    test("shows default values", () => {
+      const cmd = new SimpleCommand({
+        name: "test",
+        description: "Test",
+        options: { count: { type: "number", default: 10, description: "Count" } },
+      });
+
+      const options = formatOptions(cmd);
+      expect(options).toContain("10");
+    });
+
+    test("shows required marker", () => {
+      const cmd = new SimpleCommand({
+        name: "test",
+        description: "Test",
+        options: { name: { type: "string", required: true, description: "Name" } },
+      });
+
+      const options = formatOptions(cmd);
+      expect(options).toContain("required");
+    });
+
+    test("shows enum values", () => {
+      const cmd = new SimpleCommand({
+        name: "test",
+        description: "Test",
+        options: {
+          level: {
+            type: "string",
+            enum: ["low", "high"],
+            description: "Level",
+          },
+        },
+      });
+
+      const options = formatOptions(cmd);
+      expect(options).toContain("low");
+      expect(options).toContain("high");
+    });
+
+    test("returns empty for no options", () => {
+      const cmd = new SimpleCommand({ name: "test", description: "Test" });
+      const options = formatOptions(cmd);
+      expect(options).toBe("");
+    });
+  });
+
+  describe("formatExamples", () => {
+    test("formats examples list and empty state", () => {
+      const cmd = new SimpleCommand({ name: "test", description: "Test" });
+      cmd.examples = [{ command: "test --verbose", description: "Run with verbose" }];
+
+      expect(formatExamples(cmd)).toContain("test --verbose");
+      expect(formatExamples(cmd)).toContain("Run with verbose");
+
+      const noExamples = new SimpleCommand({ name: "empty", description: "Empty" });
+      expect(formatExamples(noExamples)).toBe("");
+    });
+  });
+
+  describe("generateCommandHelp", () => {
+    test("includes usage, description, and options section", () => {
+      const cmd = new SimpleCommand({
+        name: "test",
+        description: "A test command for testing",
+        options: { verbose: { type: "boolean", description: "Verbose mode" } },
+      });
+
+      const help = generateCommandHelp(cmd, { appName: "myapp" });
+      expect(help).toContain("Usage:");
+      expect(help).toContain("A test command for testing");
+      expect(help).toContain("Options:");
+      expect(help).toContain("--verbose");
+      expect(help).toContain("--verbose, --no-verbose");
+    });
+  });
+
+  describe("generateAppHelp", () => {
+    test("generates root help with commands", () => {
+      const commands = [new SimpleCommand({ name: "run", description: "Run something" })];
+      const help = generateAppHelp(commands, { appName: "myapp" });
+      expect(help).toContain("Commands:");
+      expect(help).toContain("run");
+    });
+  });
+
+  describe("Global Options section", () => {
+    test("modes via schema and includes mode", () => {
+      const global = formatOptionSchema("Global Options", {
+        "log-level": { type: "string", description: "Minimum log level" },
+        mode: {
+          type: "string",
+          enum: ["opentui", "ink", "cli", "default"],
+          default: "default",
+          description: "Mode",
+        },
+      });
+
+      expect(global).toContain("Global Options");
+      expect(global).toContain("--log-level");
+      expect(global).toContain("--mode");
+      expect(global).toContain("opentui");
+      expect(global).toContain("ink");
+      expect(global).toContain("cli");
+      expect(global).toContain("default");
+      expect(global).toContain("[default: default]");
+    });
+
+    test("generateCommandHelp includes global options when provided", () => {
+      const cmd = new SimpleCommand({ name: "test", description: "Test" });
+      const help = generateCommandHelp(cmd, {
+        appName: "myapp",
+        globalOptionsSchema: {
+          mode: {
+            type: "string",
+            enum: ["opentui", "ink", "cli", "default"],
+            default: "default",
+            description: "Mode",
+          },
+        },
+      });
+
+      expect(help).toContain("Global Options");
+      expect(help).toContain("--mode");
+    });
+
+    test("generateAppHelp includes global options when provided", () => {
+      const commands = [new SimpleCommand({ name: "run", description: "Run something" })];
+      const help = generateAppHelp(commands, {
+        appName: "myapp",
+        globalOptionsSchema: {
+          mode: { type: "string", enum: ["opentui", "ink", "cli", "default"], description: "Mode" },
+        },
+      });
+
+      expect(help).toContain("Global Options");
+      expect(help).toContain("--mode");
+    });
+  });
+});