@pablozaiden/terminatui 0.1.0

package/src/__tests__/builtins.test.ts

@@ -0,0 +1,133 @@
+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";
+
+describe("Built-in Commands", () => {
+  let originalLog: typeof console.log;
+  let logOutput: string[];
+
+  beforeEach(() => {
+    originalLog = console.log;
+    logOutput = [];
+    console.log = (...args: unknown[]) => {
+      logOutput.push(args.map(String).join(" "));
+    };
+  });
+
+  afterEach(() => {
+    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'", () => {
+      const cmd = createVersionCommand("myapp", "1.0.0");
+      expect(cmd.name).toBe("version");
+    });
+
+    test("has description", () => {
+      const cmd = createVersionCommand("myapp", "1.0.0");
+      expect(cmd.description).toBeDefined();
+      expect(cmd.description.length).toBeGreaterThan(0);
+    });
+
+    test("has aliases including --version", () => {
+      const cmd = createVersionCommand("myapp", "1.0.0");
+      expect(cmd.aliases).toContain("--version");
+      expect(cmd.aliases).toContain("-v");
+    });
+
+    test("getFormattedVersion returns version with dev", () => {
+      const cmd = createVersionCommand("myapp", "1.2.3");
+      expect(cmd.getFormattedVersion()).toBe("1.2.3 - (dev)");
+    });
+
+    test("getFormattedVersion returns version with commit hash", () => {
+      const cmd = createVersionCommand("myapp", "1.2.3", "abc1234567890");
+      expect(cmd.getFormattedVersion()).toBe("1.2.3 - abc1234");
+    });
+  });
+
+  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");
+    });
+
+    test("has description", () => {
+      const cmd = createHelpCommand({ getCommands: () => mockCommands });
+      expect(cmd.description).toBeDefined();
+    });
+
+    test("has aliases including --help", () => {
+      const cmd = createHelpCommand({ getCommands: () => mockCommands });
+      expect(cmd.aliases).toContain("--help");
+    });
+
+    test("is hidden by default", () => {
+      const cmd = createHelpCommand({ getCommands: () => mockCommands });
+      expect(cmd.hidden).toBe(true);
+    });
+
+    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();
+    });
+
+    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");
+    });
+  });
+});

package/src/__tests__/colors.test.ts

@@ -0,0 +1,127 @@
+import { test, expect, describe } from "bun:test";
+import { colors, supportsColors } from "../cli/output/colors.ts";
+
+describe("colors", () => {
+  describe("basic colors", () => {
+    test("red wraps text", () => {
+      const result = colors.red("test");
+      expect(result).toContain("test");
+    });
+
+    test("green wraps text", () => {
+      const result = colors.green("test");
+      expect(result).toContain("test");
+    });
+
+    test("blue wraps text", () => {
+      const result = colors.blue("test");
+      expect(result).toContain("test");
+    });
+
+    test("yellow wraps text", () => {
+      const result = colors.yellow("test");
+      expect(result).toContain("test");
+    });
+
+    test("cyan wraps text", () => {
+      const result = colors.cyan("test");
+      expect(result).toContain("test");
+    });
+
+    test("gray wraps text", () => {
+      const result = colors.gray("test");
+      expect(result).toContain("test");
+    });
+  });
+
+  describe("styles", () => {
+    test("bold wraps text", () => {
+      const result = colors.bold("test");
+      expect(result).toContain("test");
+    });
+
+    test("dim wraps text", () => {
+      const result = colors.dim("test");
+      expect(result).toContain("test");
+    });
+
+    test("italic wraps text", () => {
+      const result = colors.italic("test");
+      expect(result).toContain("test");
+    });
+
+    test("underline wraps text", () => {
+      const result = colors.underline("test");
+      expect(result).toContain("test");
+    });
+
+    test("strikethrough wraps text", () => {
+      const result = colors.strikethrough("test");
+      expect(result).toContain("test");
+    });
+  });
+
+  describe("semantic colors", () => {
+    test("success includes checkmark and message", () => {
+      const result = colors.success("done");
+      expect(result).toContain("done");
+      expect(result).toContain("✓");
+    });
+
+    test("error includes message", () => {
+      const result = colors.error("failed");
+      expect(result).toContain("failed");
+    });
+
+    test("warning includes message", () => {
+      const result = colors.warning("caution");
+      expect(result).toContain("caution");
+    });
+
+    test("info includes message", () => {
+      const result = colors.info("note");
+      expect(result).toContain("note");
+    });
+  });
+
+  describe("chaining", () => {
+    test("can combine bold and red", () => {
+      const result = colors.bold(colors.red("test"));
+      expect(result).toContain("test");
+    });
+
+    test("can combine dim and italic", () => {
+      const result = colors.dim(colors.italic("test"));
+      expect(result).toContain("test");
+    });
+  });
+
+  describe("edge cases", () => {
+    test("handles empty string", () => {
+      const result = colors.red("");
+      expect(typeof result).toBe("string");
+    });
+
+    test("handles string with newlines", () => {
+      const result = colors.blue("line1\nline2");
+      expect(result).toContain("line1");
+      expect(result).toContain("line2");
+    });
+
+    test("handles string with special characters", () => {
+      const result = colors.green("test © ® ™");
+      expect(result).toContain("©");
+    });
+  });
+});
+
+describe("supportsColors", () => {
+  test("is a function", () => {
+    expect(typeof supportsColors).toBe("function");
+  });
+
+  test("returns a boolean", () => {
+    const result = supportsColors();
+    expect(typeof result).toBe("boolean");
+  });
+});

package/src/__tests__/command.test.ts

@@ -0,0 +1,157 @@
+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: () => {},
+    });
+
+    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("creates a command with aliases", () => {
+    const cmd = defineCommand({
+      name: "test",
+      description: "A test command",
+      aliases: ["t", "tst"],
+      execute: () => {},
+    });
+
+    expect(cmd.aliases).toEqual(["t", "tst"]);
+  });
+
+  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("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);
+  });
+
+  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);
+  });
+
+  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" });
+  });
+
+  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");
+      },
+    });
+
+    await cmd.beforeExecute?.({ options: {}, args: [], commandPath: ["test"] });
+    await cmd.execute({ options: {}, args: [], commandPath: ["test"] });
+    expect(order).toEqual(["before", "execute"]);
+  });
+
+  test("supports afterExecute hook", async () => {
+    const order: string[] = [];
+    const cmd = defineCommand({
+      name: "test",
+      description: "A test command",
+      execute: () => {
+        order.push("execute");
+      },
+      afterExecute: () => {
+        order.push("after");
+      },
+    });
+
+    await cmd.execute({ options: {}, args: [], commandPath: ["test"] });
+    await cmd.afterExecute?.({ options: {}, args: [], commandPath: ["test"] });
+    expect(order).toEqual(["execute", "after"]);
+  });
+
+  test("supports hidden commands", () => {
+    const cmd = defineCommand({
+      name: "hidden",
+      description: "A hidden command",
+      hidden: true,
+      execute: () => {},
+    });
+
+    expect(cmd.hidden).toBe(true);
+  });
+});

package/src/__tests__/commandClass.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect } from "bun:test";
+import { Command, type CommandResult } from "../core/command.ts";
+import type { AppContext } from "../core/context.ts";
+import type { OptionSchema, OptionValues } from "../types/command.ts";
+
+// Test command with options
+class TestCommand extends Command<{ name: { type: "string"; description: string } }> {
+  readonly name = "test";
+  readonly description = "A test command";
+  readonly options = {
+    name: { type: "string" as const, description: "Name option" },
+  };
+
+  executedWith: OptionValues<typeof this.options> | null = null;
+
+  override async execute(
+    _ctx: AppContext,
+    opts: OptionValues<typeof this.options>
+  ): Promise<CommandResult> {
+    this.executedWith = opts;
+    return { success: true, message: "Executed" };
+  }
+}
+
+// Simple command without options
+class SimpleCommand extends Command<OptionSchema> {
+  readonly name = "simple";
+  readonly description = "A simple command";
+  readonly options = {};
+
+  executed = false;
+
+  override async execute(_ctx: AppContext): Promise<CommandResult> {
+    this.executed = true;
+    return { success: true, message: "Done" };
+  }
+}
+
+describe("Command", () => {
+  describe("core properties", () => {
+    test("has name", () => {
+      const cmd = new TestCommand();
+      expect(cmd.name).toBe("test");
+    });
+
+    test("has description", () => {
+      const cmd = new TestCommand();
+      expect(cmd.description).toBe("A test command");
+    });
+
+    test("has options", () => {
+      const cmd = new TestCommand();
+      expect(cmd.options).toEqual({
+        name: { type: "string", description: "Name option" },
+      });
+    });
+  });
+
+  describe("optional metadata", () => {
+    test("subCommands defaults to undefined", () => {
+      const cmd = new TestCommand();
+      expect(cmd.subCommands).toBeUndefined();
+    });
+
+    test("examples defaults to undefined", () => {
+      const cmd = new TestCommand();
+      expect(cmd.examples).toBeUndefined();
+    });
+
+    test("longDescription defaults to undefined", () => {
+      const cmd = new TestCommand();
+      expect(cmd.longDescription).toBeUndefined();
+    });
+  });
+
+  describe("supportsCli", () => {
+    test("returns true for command with execute", () => {
+      const cmd = new TestCommand();
+      expect(cmd.supportsCli()).toBe(true);
+    });
+  });
+
+  describe("supportsTui", () => {
+    test("returns true for command with execute", () => {
+      const cmd = new TestCommand();
+      expect(cmd.supportsTui()).toBe(true);
+    });
+  });
+
+  describe("both modes", () => {
+    test("command supports both CLI and TUI", () => {
+      const cmd = new TestCommand();
+      expect(cmd.supportsCli()).toBe(true);
+      expect(cmd.supportsTui()).toBe(true);
+    });
+  });
+
+  describe("validate", () => {
+    test("passes for command with execute", () => {
+      const cmd = new TestCommand();
+      expect(() => cmd.validate()).not.toThrow();
+    });
+  });
+
+  describe("subcommands", () => {
+    test("hasSubCommands returns false when no subcommands", () => {
+      const cmd = new TestCommand();
+      expect(cmd.hasSubCommands()).toBe(false);
+    });
+
+    test("hasSubCommands returns true when subcommands exist", () => {
+      const cmd = new TestCommand();
+      cmd.subCommands = [new SimpleCommand()];
+      expect(cmd.hasSubCommands()).toBe(true);
+    });
+
+    test("getSubCommand finds subcommand by name", () => {
+      const cmd = new TestCommand();
+      const subCmd = new SimpleCommand();
+      cmd.subCommands = [subCmd];
+      expect(cmd.getSubCommand("simple")).toBe(subCmd);
+    });
+
+    test("getSubCommand returns undefined for unknown name", () => {
+      const cmd = new TestCommand();
+      cmd.subCommands = [new SimpleCommand()];
+      expect(cmd.getSubCommand("unknown")).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/context.test.ts

@@ -0,0 +1,97 @@
+import { describe, test, expect, afterEach } from "bun:test";
+import { AppContext, type AppConfig } from "../core/context.ts";
+
+describe("AppContext", () => {
+  afterEach(() => {
+    AppContext.clearCurrent();
+  });
+
+  describe("constructor", () => {
+    test("creates context with config", () => {
+      const config: AppConfig = { name: "test", version: "1.0.0" };
+      const ctx = new AppContext(config);
+      expect(ctx.config.name).toBe("test");
+      expect(ctx.config.version).toBe("1.0.0");
+    });
+
+    test("creates context with logger", () => {
+      const config: AppConfig = { name: "test", version: "1.0.0" };
+      const ctx = new AppContext(config);
+      expect(ctx.logger).toBeDefined();
+    });
+  });
+
+  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", () => {
+    test("setService and getService work", () => {
+      const config: AppConfig = { name: "test", version: "1.0.0" };
+      const ctx = new AppContext(config);
+      const service = { value: 42 };
+      ctx.setService("myService", service);
+      expect(ctx.getService<typeof service>("myService")).toBe(service);
+    });
+
+    test("getService returns undefined for unknown service", () => {
+      const config: AppConfig = { name: "test", version: "1.0.0" };
+      const ctx = new AppContext(config);
+      expect(ctx.getService("unknown")).toBeUndefined();
+    });
+
+    test("requireService returns service", () => {
+      const config: AppConfig = { name: "test", version: "1.0.0" };
+      const ctx = new AppContext(config);
+      const service = { value: 42 };
+      ctx.setService("myService", service);
+      expect(ctx.requireService<typeof service>("myService")).toBe(service);
+    });
+
+    test("requireService throws for unknown service", () => {
+      const config: AppConfig = { name: "test", version: "1.0.0" };
+      const ctx = new AppContext(config);
+      expect(() => ctx.requireService("unknown")).toThrow(
+        "Service 'unknown' not found"
+      );
+    });
+
+    test("hasService returns correct value", () => {
+      const config: AppConfig = { name: "test", version: "1.0.0" };
+      const ctx = new AppContext(config);
+      expect(ctx.hasService("myService")).toBe(false);
+      ctx.setService("myService", {});
+      expect(ctx.hasService("myService")).toBe(true);
+    });
+  });
+});