@pablozaiden/terminatui 0.1.0

package/src/__tests__/registry.test.ts

@@ -0,0 +1,195 @@
+import { test, expect, describe } from "bun:test";
+import { createCommandRegistry } from "../registry/commandRegistry.ts";
+import { defineCommand } from "../types/command.ts";
+
+describe("createCommandRegistry", () => {
+  test("registers a command", () => {
+    const registry = createCommandRegistry();
+    const cmd = defineCommand({
+      name: "test",
+      description: "Test command",
+      execute: () => {},
+    });
+
+    registry.register(cmd);
+
+    expect(registry.has("test")).toBe(true);
+  });
+
+  test("retrieves command by name", () => {
+    const registry = createCommandRegistry();
+    const cmd = defineCommand({
+      name: "greet",
+      description: "Greet command",
+      execute: () => {},
+    });
+
+    registry.register(cmd);
+
+    expect(registry.get("greet")).toBe(cmd);
+  });
+
+  test("resolves command by alias", () => {
+    const registry = createCommandRegistry();
+    const cmd = defineCommand({
+      name: "list",
+      description: "List command",
+      aliases: ["ls", "l"],
+      execute: () => {},
+    });
+
+    registry.register(cmd);
+
+    expect(registry.resolve("ls")).toBe(cmd);
+    expect(registry.resolve("l")).toBe(cmd);
+  });
+
+  test("returns undefined for unknown command", () => {
+    const registry = createCommandRegistry();
+    expect(registry.get("unknown")).toBeUndefined();
+  });
+
+  test("lists all commands", () => {
+    const registry = createCommandRegistry();
+    const cmd1 = defineCommand({
+      name: "a",
+      description: "A",
+      execute: () => {},
+    });
+    const cmd2 = defineCommand({
+      name: "b",
+      description: "B",
+      execute: () => {},
+    });
+
+    registry.register(cmd1);
+    registry.register(cmd2);
+
+    const commands = registry.list();
+    expect(commands).toContain(cmd1);
+    expect(commands).toContain(cmd2);
+  });
+
+  test("throws on duplicate registration", () => {
+    const registry = createCommandRegistry();
+    const cmd = defineCommand({
+      name: "dup",
+      description: "Duplicate",
+      execute: () => {},
+    });
+
+    registry.register(cmd);
+
+    expect(() => registry.register(cmd)).toThrow();
+  });
+
+  test("throws on alias conflict", () => {
+    const registry = createCommandRegistry();
+    const cmd1 = defineCommand({
+      name: "first",
+      description: "First",
+      aliases: ["f"],
+      execute: () => {},
+    });
+    const cmd2 = defineCommand({
+      name: "second",
+      description: "Second",
+      aliases: ["f"],
+      execute: () => {},
+    });
+
+    registry.register(cmd1);
+
+    expect(() => registry.register(cmd2)).toThrow();
+  });
+
+  test("has method checks existence by name", () => {
+    const registry = createCommandRegistry();
+    const cmd = defineCommand({
+      name: "exists",
+      description: "Exists",
+      execute: () => {},
+    });
+
+    registry.register(cmd);
+
+    expect(registry.has("exists")).toBe(true);
+    expect(registry.has("notexists")).toBe(false);
+  });
+
+  test("has method checks existence by alias", () => {
+    const registry = createCommandRegistry();
+    const cmd = defineCommand({
+      name: "cmd",
+      description: "Cmd",
+      aliases: ["c"],
+      execute: () => {},
+    });
+
+    registry.register(cmd);
+
+    expect(registry.has("c")).toBe(true);
+  });
+
+  test("getNames returns command names", () => {
+    const registry = createCommandRegistry();
+    const cmdA = defineCommand({
+      name: "a",
+      description: "A",
+      execute: () => {},
+    });
+    const cmdB = defineCommand({
+      name: "b",
+      description: "B",
+      execute: () => {},
+    });
+
+    registry.register(cmdA);
+    registry.register(cmdB);
+
+    const names = registry.getNames();
+    expect(names).toContain("a");
+    expect(names).toContain("b");
+  });
+
+  test("getCommandMap returns command map", () => {
+    const registry = createCommandRegistry();
+    const cmdA = defineCommand({
+      name: "a",
+      description: "A",
+      execute: () => {},
+    });
+    const cmdB = defineCommand({
+      name: "b",
+      description: "B",
+      execute: () => {},
+    });
+
+    registry.register(cmdA);
+    registry.register(cmdB);
+
+    const map = registry.getCommandMap();
+    expect(map["a"]).toBe(cmdA);
+    expect(map["b"]).toBe(cmdB);
+  });
+
+  test("resolve returns undefined for non-existent command", () => {
+    const registry = createCommandRegistry();
+    expect(registry.resolve("nonexistent")).toBeUndefined();
+  });
+
+  test("get does not resolve aliases", () => {
+    const registry = createCommandRegistry();
+    const cmd = defineCommand({
+      name: "list",
+      description: "List command",
+      aliases: ["ls"],
+      execute: () => {},
+    });
+
+    registry.register(cmd);
+
+    expect(registry.get("ls")).toBeUndefined();
+    expect(registry.resolve("ls")).toBe(cmd);
+  });
+});

package/src/__tests__/registryNew.test.ts

@@ -0,0 +1,160 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { CommandRegistry } from "../core/registry.ts";
+import { Command } from "../core/command.ts";
+import type { AppContext } from "../core/context.ts";
+import type { OptionSchema } from "../types/command.ts";
+
+// Test command implementations
+class TestCommand extends Command<OptionSchema> {
+  constructor(
+    public readonly name: string,
+    public readonly description: string = "Test command"
+  ) {
+    super();
+  }
+  readonly options = {};
+
+  override async execute(_ctx: AppContext): Promise<void> {}
+}
+
+describe("CommandRegistry (new)", () => {
+  let registry: CommandRegistry;
+
+  beforeEach(() => {
+    registry = new CommandRegistry();
+  });
+
+  describe("register", () => {
+    test("registers a command", () => {
+      const cmd = new TestCommand("test");
+      registry.register(cmd);
+      expect(registry.has("test")).toBe(true);
+    });
+
+    test("throws on duplicate registration", () => {
+      const cmd = new TestCommand("test");
+      registry.register(cmd);
+      expect(() => registry.register(cmd)).toThrow(
+        "Command 'test' is already registered"
+      );
+    });
+  });
+
+  describe("registerAll", () => {
+    test("registers multiple commands", () => {
+      const cmd1 = new TestCommand("cmd1");
+      const cmd2 = new TestCommand("cmd2");
+      registry.registerAll([cmd1, cmd2]);
+      expect(registry.has("cmd1")).toBe(true);
+      expect(registry.has("cmd2")).toBe(true);
+    });
+  });
+
+  describe("get", () => {
+    test("returns command by name", () => {
+      const cmd = new TestCommand("test");
+      registry.register(cmd);
+      expect(registry.get("test")).toBe(cmd);
+    });
+
+    test("returns undefined for unknown command", () => {
+      expect(registry.get("unknown")).toBeUndefined();
+    });
+  });
+
+  describe("has", () => {
+    test("returns true for registered command", () => {
+      registry.register(new TestCommand("test"));
+      expect(registry.has("test")).toBe(true);
+    });
+
+    test("returns false for unknown command", () => {
+      expect(registry.has("unknown")).toBe(false);
+    });
+  });
+
+  describe("list", () => {
+    test("returns empty array for empty registry", () => {
+      expect(registry.list()).toEqual([]);
+    });
+
+    test("returns all registered commands", () => {
+      const cmd1 = new TestCommand("cmd1");
+      const cmd2 = new TestCommand("cmd2");
+      registry.registerAll([cmd1, cmd2]);
+      expect(registry.list()).toContain(cmd1);
+      expect(registry.list()).toContain(cmd2);
+    });
+  });
+
+  describe("names", () => {
+    test("returns command names", () => {
+      registry.register(new TestCommand("cmd1"));
+      registry.register(new TestCommand("cmd2"));
+      expect(registry.names()).toContain("cmd1");
+      expect(registry.names()).toContain("cmd2");
+    });
+  });
+
+  describe("resolve", () => {
+    test("returns undefined for empty path", () => {
+      const result = registry.resolve([]);
+      expect(result.command).toBeUndefined();
+    });
+
+    test("resolves single command", () => {
+      const cmd = new TestCommand("test");
+      registry.register(cmd);
+      const result = registry.resolve(["test"]);
+      expect(result.command).toBe(cmd);
+      expect(result.resolvedPath).toEqual(["test"]);
+      expect(result.remainingPath).toEqual([]);
+    });
+
+    test("returns undefined for unknown command", () => {
+      const result = registry.resolve(["unknown"]);
+      expect(result.command).toBeUndefined();
+      expect(result.remainingPath).toEqual(["unknown"]);
+    });
+
+    test("resolves nested subcommands", () => {
+      const subCmd = new TestCommand("sub");
+      const cmd = new TestCommand("parent");
+      cmd.subCommands = [subCmd];
+      registry.register(cmd);
+
+      const result = registry.resolve(["parent", "sub"]);
+      expect(result.command).toBe(subCmd);
+      expect(result.resolvedPath).toEqual(["parent", "sub"]);
+      expect(result.remainingPath).toEqual([]);
+    });
+
+    test("returns remaining path for unresolved parts", () => {
+      const cmd = new TestCommand("parent");
+      registry.register(cmd);
+
+      const result = registry.resolve(["parent", "unknown"]);
+      expect(result.command).toBe(cmd);
+      expect(result.resolvedPath).toEqual(["parent"]);
+      expect(result.remainingPath).toEqual(["unknown"]);
+    });
+  });
+
+  describe("clear", () => {
+    test("clears all commands", () => {
+      registry.register(new TestCommand("test"));
+      registry.clear();
+      expect(registry.size).toBe(0);
+    });
+  });
+
+  describe("size", () => {
+    test("returns number of registered commands", () => {
+      expect(registry.size).toBe(0);
+      registry.register(new TestCommand("cmd1"));
+      expect(registry.size).toBe(1);
+      registry.register(new TestCommand("cmd2"));
+      expect(registry.size).toBe(2);
+    });
+  });
+});

package/src/__tests__/schemaToFields.test.ts

@@ -0,0 +1,176 @@
+import { describe, test, expect } from "bun:test";
+import { schemaToFieldConfigs, getFieldDisplayValue } from "../tui/utils/schemaToFields.ts";
+import type { OptionSchema } from "../types/command.ts";
+
+describe("schemaToFieldConfigs", () => {
+    test("converts string type to text field", () => {
+        const schema: OptionSchema = {
+            name: {
+                type: "string",
+                description: "User name",
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields).toHaveLength(1);
+        expect(fields[0]?.key).toBe("name");
+        expect(fields[0]?.type).toBe("text");
+        expect(fields[0]?.label).toBe("Name");
+    });
+
+    test("converts string with enum to enum field", () => {
+        const schema: OptionSchema = {
+            color: {
+                type: "string",
+                description: "Color choice",
+                enum: ["red", "green", "blue"],
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.type).toBe("enum");
+        expect(fields[0]?.options).toHaveLength(3);
+        expect(fields[0]?.options?.[0]?.name).toBe("red");
+    });
+
+    test("converts boolean type", () => {
+        const schema: OptionSchema = {
+            verbose: {
+                type: "boolean",
+                description: "Verbose output",
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.type).toBe("boolean");
+    });
+
+    test("converts number type", () => {
+        const schema: OptionSchema = {
+            count: {
+                type: "number",
+                description: "Count",
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.type).toBe("number");
+    });
+
+    test("converts array type to text", () => {
+        const schema: OptionSchema = {
+            files: {
+                type: "array",
+                description: "Files to process",
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.type).toBe("text");
+    });
+
+    test("uses label from schema if provided", () => {
+        const schema: OptionSchema = {
+            repoPath: {
+                type: "string",
+                description: "Repository path",
+                label: "Repository",
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.label).toBe("Repository");
+    });
+
+    test("sorts by order", () => {
+        const schema: OptionSchema = {
+            third: { type: "string", description: "Third", order: 3 },
+            first: { type: "string", description: "First", order: 1 },
+            second: { type: "string", description: "Second", order: 2 },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.key).toBe("first");
+        expect(fields[1]?.key).toBe("second");
+        expect(fields[2]?.key).toBe("third");
+    });
+
+    test("excludes tuiHidden fields", () => {
+        const schema: OptionSchema = {
+            visible: { type: "string", description: "Visible" },
+            hidden: { type: "string", description: "Hidden", tuiHidden: true },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields).toHaveLength(1);
+        expect(fields[0]?.key).toBe("visible");
+    });
+
+    test("includes placeholder from schema", () => {
+        const schema: OptionSchema = {
+            path: {
+                type: "string",
+                description: "Path",
+                placeholder: "Enter path here",
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.placeholder).toBe("Enter path here");
+    });
+
+    test("includes group from schema", () => {
+        const schema: OptionSchema = {
+            name: {
+                type: "string",
+                description: "Name",
+                group: "Basic",
+            },
+        };
+        
+        const fields = schemaToFieldConfigs(schema);
+        expect(fields[0]?.group).toBe("Basic");
+    });
+});
+
+describe("getFieldDisplayValue", () => {
+    test("displays boolean as True/False", () => {
+        const field = { key: "enabled", label: "Enabled", type: "boolean" as const };
+        expect(getFieldDisplayValue(true, field)).toBe("True");
+        expect(getFieldDisplayValue(false, field)).toBe("False");
+    });
+
+    test("displays enum option name", () => {
+        const field = {
+            key: "color",
+            label: "Color",
+            type: "enum" as const,
+            options: [
+                { name: "Red", value: "red" },
+                { name: "Green", value: "green" },
+            ],
+        };
+        expect(getFieldDisplayValue("red", field)).toBe("Red");
+        expect(getFieldDisplayValue("green", field)).toBe("Green");
+    });
+
+    test("displays (empty) for empty strings", () => {
+        const field = { key: "name", label: "Name", type: "text" as const };
+        expect(getFieldDisplayValue("", field)).toBe("(empty)");
+        expect(getFieldDisplayValue(null, field)).toBe("(empty)");
+        expect(getFieldDisplayValue(undefined, field)).toBe("(empty)");
+    });
+
+    test("truncates long values", () => {
+        const field = { key: "desc", label: "Description", type: "text" as const };
+        const longValue = "a".repeat(100);
+        const result = getFieldDisplayValue(longValue, field);
+        expect(result.length).toBe(60);
+        expect(result.endsWith("...")).toBe(true);
+    });
+
+    test("displays short values as-is", () => {
+        const field = { key: "name", label: "Name", type: "text" as const };
+        expect(getFieldDisplayValue("hello", field)).toBe("hello");
+    });
+});

package/src/__tests__/table.test.ts

@@ -0,0 +1,146 @@
+import { test, expect, describe } from "bun:test";
+import { table, keyValueList, bulletList, numberedList } from "../cli/output/table.ts";
+
+describe("table", () => {
+  test("creates table with data and columns", () => {
+    const data = [
+      { name: "Alice", age: 30 },
+      { name: "Bob", age: 25 },
+    ];
+    const result = table(data, { columns: ["name", "age"] });
+
+    expect(result).toContain("name");
+    expect(result).toContain("Alice");
+    expect(result).toContain("Bob");
+  });
+
+  test("handles empty data", () => {
+    const result = table([]);
+    expect(result).toBe("");
+  });
+
+  test("handles single row", () => {
+    const data = [{ col: "value" }];
+    const result = table(data);
+    expect(result).toContain("value");
+  });
+
+  test("handles multiple columns", () => {
+    const data = [{ a: "1", b: "2", c: "3" }];
+    const result = table(data);
+    expect(result).toContain("1");
+    expect(result).toContain("2");
+    expect(result).toContain("3");
+  });
+
+  test("handles custom column config", () => {
+    const data = [{ value: 123 }];
+    const result = table(data, {
+      columns: [{ key: "value", header: "Amount" }],
+    });
+    expect(result).toContain("Amount");
+  });
+
+  test("handles custom formatter", () => {
+    const data = [{ price: 100 }];
+    const result = table(data, {
+      columns: [
+        {
+          key: "price",
+          formatter: (v) => `$${v}`,
+        },
+      ],
+    });
+    expect(result).toContain("$100");
+  });
+
+  test("hides headers when showHeaders is false", () => {
+    const data = [{ name: "Test" }];
+    const result = table(data, { showHeaders: false });
+    expect(result).not.toContain("---");
+  });
+
+  test("handles undefined values", () => {
+    const data = [{ a: undefined }];
+    const result = table(data);
+    expect(typeof result).toBe("string");
+  });
+});
+
+describe("keyValueList", () => {
+  test("formats key-value pairs", () => {
+    const data = { name: "Test", version: "1.0" };
+    const result = keyValueList(data);
+    expect(result).toContain("name");
+    expect(result).toContain("Test");
+    expect(result).toContain("version");
+    expect(result).toContain("1.0");
+  });
+
+  test("handles empty object", () => {
+    const result = keyValueList({});
+    expect(result).toBe("");
+  });
+
+  test("handles custom separator", () => {
+    const data = { key: "value" };
+    const result = keyValueList(data, { separator: " =" });
+    expect(result).toContain("=");
+  });
+});
+
+describe("bulletList", () => {
+  test("formats bullet list", () => {
+    const items = ["one", "two", "three"];
+    const result = bulletList(items);
+    expect(result).toContain("•");
+    expect(result).toContain("one");
+    expect(result).toContain("two");
+    expect(result).toContain("three");
+  });
+
+  test("handles empty array", () => {
+    const result = bulletList([]);
+    expect(result).toBe("");
+  });
+
+  test("handles custom bullet", () => {
+    const items = ["item"];
+    const result = bulletList(items, { bullet: "-" });
+    expect(result).toContain("-");
+  });
+
+  test("handles indent", () => {
+    const items = ["item"];
+    const result = bulletList(items, { indent: 2 });
+    expect(result.startsWith("  ")).toBe(true);
+  });
+});
+
+describe("numberedList", () => {
+  test("formats numbered list", () => {
+    const items = ["first", "second"];
+    const result = numberedList(items);
+    expect(result).toContain("1.");
+    expect(result).toContain("2.");
+    expect(result).toContain("first");
+    expect(result).toContain("second");
+  });
+
+  test("handles empty array", () => {
+    const result = numberedList([]);
+    expect(result).toBe("");
+  });
+
+  test("handles custom start number", () => {
+    const items = ["item"];
+    const result = numberedList(items, { start: 5 });
+    expect(result).toContain("5.");
+  });
+
+  test("handles indent", () => {
+    const items = ["item"];
+    const result = numberedList(items, { indent: 2 });
+    expect(result.startsWith("  ")).toBe(true);
+  });
+});

package/src/__tests__/tui.test.ts

@@ -0,0 +1,26 @@
+import { describe, test, expect } from "bun:test";
+import {
+    KeyboardPriority,
+} from "../tui/index.ts";
+
+describe("TUI", () => {
+    describe("KeyboardPriority", () => {
+        test("Modal has highest priority", () => {
+            expect(KeyboardPriority.Modal).toBe(100);
+        });
+
+        test("Focused has medium priority", () => {
+            expect(KeyboardPriority.Focused).toBe(50);
+        });
+
+        test("Global has lowest priority", () => {
+            expect(KeyboardPriority.Global).toBe(0);
+        });
+
+        test("priorities are correctly ordered", () => {
+            expect(KeyboardPriority.Modal).toBeGreaterThan(KeyboardPriority.Focused);
+            expect(KeyboardPriority.Focused).toBeGreaterThan(KeyboardPriority.Global);
+        });
+    });
+});
+