@pablozaiden/terminatui 0.2.0 → 0.3.0

package/src/__tests__/buildCliCommand.test.ts

@@ -1,125 +1,105 @@
-import { describe, test, expect } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import { buildCliCommand } from "../tui/utils/buildCliCommand.ts";
 import type { OptionSchema } from "../types/command.ts";
 
 describe("buildCliCommand", () => {
-    test("builds command with no options", () => {
-        const result = buildCliCommand("myapp", ["run"], {}, {});
-        expect(result).toBe("myapp run");
-    });
+  test("builds CLI commands from schema + values", () => {
+    const cases: Array<{
+      name: string;
+      commandPath: string[];
+      schema: OptionSchema;
+      values: Record<string, unknown>;
+      expected: string;
+    }> = [
+      {
+        name: "no options",
+        commandPath: ["run"],
+        schema: {},
+        values: {},
+        expected: "myapp run --mode cli",
+      },
+      {
+        name: "string option",
+        commandPath: ["greet"],
+        schema: { name: { type: "string", description: "Name" } },
+        values: { name: "John" },
+        expected: "myapp greet --name John --mode cli",
+      },
+      {
+        name: "quotes strings with spaces",
+        commandPath: ["greet"],
+        schema: { name: { type: "string", description: "Name" } },
+        values: { name: "John Doe" },
+        expected: "myapp greet --name \"John Doe\" --mode cli",
+      },
+      {
+        name: "skips empty/undefined/null",
+        commandPath: ["run"],
+        schema: {
+          name: { type: "string", description: "Name" },
+          count: { type: "number", description: "Count" },
+        },
+        values: { name: "", count: null },
+        expected: "myapp run --mode cli",
+      },
+      {
+        name: "boolean flags only when needed",
+        commandPath: ["run"],
+        schema: {
+          verbose: { type: "boolean", description: "Verbose" },
+          quiet: { type: "boolean", description: "Quiet" },
+        },
+        values: { verbose: true, quiet: false },
+        expected: "myapp run --verbose --mode cli",
+      },
+      {
+        name: "number values",
+        commandPath: ["process"],
+        schema: { count: { type: "number", description: "Count" } },
+        values: { count: 42 },
+        expected: "myapp process --count 42 --mode cli",
+      },
+      {
+        name: "array values",
+        commandPath: ["process"],
+        schema: { files: { type: "array", description: "Files" } },
+        values: { files: ["a.txt", "b.txt"] },
+        expected: "myapp process --files a.txt --files b.txt --mode cli",
+      },
+      {
+        name: "nested command path",
+        commandPath: ["db", "migrate"],
+        schema: { force: { type: "boolean", description: "Force" } },
+        values: { force: true },
+        expected: "myapp db migrate --force --mode cli",
+      },
+      {
+        name: "camelCase to kebab-case",
+        commandPath: ["build"],
+        schema: {
+          outputDir: { type: "string", description: "Output directory" },
+          maxRetries: { type: "number", description: "Max retries" },
+        },
+        values: { outputDir: "/tmp", maxRetries: 3 },
+        expected: "myapp build --output-dir /tmp --max-retries 3 --mode cli",
+      },
+      {
+        name: "skips defaults and uses --no- for booleans",
+        commandPath: ["run"],
+        schema: {
+          verbose: { type: "boolean", description: "Verbose", default: false },
+          count: { type: "number", description: "Count", default: 10 },
+          color: { type: "boolean", description: "Color output", default: true },
+        },
+        values: { verbose: false, count: 10, color: false },
+        expected: "myapp run --no-color --mode cli",
+      },
+    ];
 
-    test("includes string options", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-        };
-        const values = { name: "John" };
-        
-        const result = buildCliCommand("myapp", ["greet"], schema, values);
-        expect(result).toBe("myapp greet --name John");
-    });
-
-    test("quotes string values with spaces", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-        };
-        const values = { name: "John Doe" };
-        
-        const result = buildCliCommand("myapp", ["greet"], schema, values);
-        expect(result).toBe("myapp greet --name \"John Doe\"");
-    });
-
-    test("excludes empty string values", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-        };
-        const values = { name: "" };
-        
-        const result = buildCliCommand("myapp", ["greet"], schema, values);
-        expect(result).toBe("myapp greet");
-    });
-
-    test("includes boolean flags only when true", () => {
-        const schema: OptionSchema = {
-            verbose: { type: "boolean", description: "Verbose" },
-            quiet: { type: "boolean", description: "Quiet" },
-        };
-        const values = { verbose: true, quiet: false };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run --verbose");
-    });
-
-    test("includes number values", () => {
-        const schema: OptionSchema = {
-            count: { type: "number", description: "Count" },
-        };
-        const values = { count: 42 };
-        
-        const result = buildCliCommand("myapp", ["process"], schema, values);
-        expect(result).toBe("myapp process --count 42");
-    });
-
-    test("excludes undefined and null values", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-            count: { type: "number", description: "Count" },
-        };
-        const values = { name: undefined, count: null };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run");
-    });
-
-    test("handles array values", () => {
-        const schema: OptionSchema = {
-            files: { type: "array", description: "Files" },
-        };
-        const values = { files: ["a.txt", "b.txt"] };
-        
-        const result = buildCliCommand("myapp", ["process"], schema, values);
-        expect(result).toBe("myapp process --files a.txt --files b.txt");
-    });
-
-    test("handles nested command path", () => {
-        const schema: OptionSchema = {
-            force: { type: "boolean", description: "Force" },
-        };
-        const values = { force: true };
-        
-        const result = buildCliCommand("myapp", ["db", "migrate"], schema, values);
-        expect(result).toBe("myapp db migrate --force");
-    });
-
-    test("converts camelCase to kebab-case", () => {
-        const schema: OptionSchema = {
-            outputDir: { type: "string", description: "Output directory" },
-            maxRetries: { type: "number", description: "Max retries" },
-        };
-        const values = { outputDir: "/tmp", maxRetries: 3 };
-        
-        const result = buildCliCommand("myapp", ["build"], schema, values);
-        expect(result).toContain("--output-dir /tmp");
-        expect(result).toContain("--max-retries 3");
-    });
-
-    test("skips values that match defaults", () => {
-        const schema: OptionSchema = {
-            verbose: { type: "boolean", description: "Verbose", default: false },
-            count: { type: "number", description: "Count", default: 10 },
-        };
-        const values = { verbose: false, count: 10 };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run");
-    });
-
-    test("uses --no-flag for false when default is true", () => {
-        const schema: OptionSchema = {
-            color: { type: "boolean", description: "Color output", default: true },
-        };
-        const values = { color: false };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run --no-color");
-    });
+    for (const c of cases) {
+      expect(buildCliCommand("myapp", c.commandPath, c.schema, c.values), c.name).toBe(
+        c.expected
+      );
+    }
+  });
 });

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__/configOnChange.test.ts

@@ -0,0 +1,63 @@
+import { test, expect } from "bun:test";
+import { Command } from "../core/command.ts";
+import type { OptionSchema } from "../types/command.ts";
+
+class TestCommand extends Command<typeof TestCommand.Options> {
+  static readonly Options = {
+    a: { type: "string" as const, description: "a" },
+    b: { type: "string" as const, description: "b" },
+  } as const satisfies OptionSchema;
+
+  readonly name = "my";
+  readonly description = "my";
+  readonly options = TestCommand.Options;
+
+  public readonly onChangeCalls: Array<[
+    string,
+    unknown,
+    Record<string, unknown>
+  ]> = [];
+
+  override execute(): void {}
+
+  override onConfigChange(
+    key: string,
+    value: unknown,
+    allValues: Record<string, unknown>
+  ) {
+    this.onChangeCalls.push([key, value, allValues]);
+    if (key === "a") {
+      return { b: "derived" };
+    }
+    return undefined;
+  }
+
+  applyTuiConfigChange(
+    key: string,
+    value: unknown,
+    values: Record<string, unknown>
+  ): Record<string, unknown> {
+    let nextValues: Record<string, unknown> = { ...values, [key]: value };
+
+    const updates = this.onConfigChange?.(key, value, nextValues);
+    if (updates && typeof updates === "object") {
+      nextValues = { ...nextValues, ...updates };
+    }
+
+    return nextValues;
+  }
+}
+
+test("onConfigChange merges returned updates", () => {
+  const command = new TestCommand();
+
+  const next = command.applyTuiConfigChange("a", "new", {
+    a: "old",
+    b: "oldb",
+  });
+
+  expect(command.onChangeCalls.length).toBe(1);
+  expect(command.onChangeCalls[0]?.[0]).toBe("a");
+  expect(command.onChangeCalls[0]?.[1]).toBe("new");
+  expect(next).toEqual({ a: "new", b: "derived" });
+});