@pablozaiden/terminatui 0.1.2 → 0.3.0-beta-1

package/src/__tests__/parser.test.ts

@@ -1,268 +1,122 @@
-import { test, expect, describe } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import {
   extractCommandChain,
-  schemaToParseArgsOptions,
   parseOptionValues,
+  schemaToParseArgsOptions,
   validateOptions,
-  parseCliArgs,
 } from "../cli/parser.ts";
 import type { OptionSchema } from "../types/command.ts";
-import { defineCommand } from "../types/command.ts";
-
-describe("extractCommandChain", () => {
-  test("extracts command path with no flags", () => {
-    const result = extractCommandChain(["run", "test"]);
-    expect(result.commands).toEqual(["run", "test"]);
-    expect(result.remaining).toEqual([]);
-  });
-
-  test("separates commands from flags", () => {
-    const result = extractCommandChain(["run", "--verbose", "file.ts"]);
-    expect(result.commands).toEqual(["run"]);
-    expect(result.remaining).toEqual(["--verbose", "file.ts"]);
-  });
-
-  test("handles args starting with flags", () => {
-    const result = extractCommandChain(["--help"]);
-    expect(result.commands).toEqual([]);
-    expect(result.remaining).toEqual(["--help"]);
-  });
-
-  test("handles short flags", () => {
-    const result = extractCommandChain(["run", "-v"]);
-    expect(result.commands).toEqual(["run"]);
-    expect(result.remaining).toEqual(["-v"]);
-  });
-
-  test("handles empty args", () => {
-    const result = extractCommandChain([]);
-    expect(result.commands).toEqual([]);
-    expect(result.remaining).toEqual([]);
-  });
-
-  test("extracts nested command path", () => {
-    const result = extractCommandChain(["config", "set", "--key", "value"]);
-    expect(result.commands).toEqual(["config", "set"]);
-    expect(result.remaining).toEqual(["--key", "value"]);
-  });
-});
-
-describe("schemaToParseArgsOptions", () => {
-  test("converts string option", () => {
-    const schema: OptionSchema = {
-      name: { type: "string", description: "Name" },
-    };
-    const result = schemaToParseArgsOptions(schema);
-    expect(result.options!["name"]?.type).toBe("string");
-  });
-
-  test("converts boolean option", () => {
-    const schema: OptionSchema = {
-      verbose: { type: "boolean", description: "Verbose" },
-    };
-    const result = schemaToParseArgsOptions(schema);
-    expect(result.options!["verbose"]?.type).toBe("boolean");
-  });
-
-  test("converts alias to short", () => {
-    const schema: OptionSchema = {
-      verbose: { type: "boolean", alias: "v", description: "Verbose" },
-    };
-    const result = schemaToParseArgsOptions(schema);
-    expect(result.options!["verbose"]?.short).toBe("v");
-  });
-
-  test("converts array option to multiple", () => {
-    const schema: OptionSchema = {
-      files: { type: "array", description: "Files" },
-    };
-    const result = schemaToParseArgsOptions(schema);
-    expect(result.options!["files"]?.multiple).toBe(true);
-  });
-
-  test("includes default values", () => {
-    const schema: OptionSchema = {
-      count: { type: "number", default: 10, description: "Count" },
-    };
-    const result = schemaToParseArgsOptions(schema);
-    // parseArgs expects string defaults for non-boolean types
-    expect(result.options!["count"]?.default).toBe("10");
-  });
-
-  test("includes default values for boolean", () => {
-    const schema: OptionSchema = {
-      verbose: { type: "boolean", default: false, description: "Verbose" },
-    };
-    const result = schemaToParseArgsOptions(schema);
-    // Boolean defaults remain as boolean
-    expect(result.options!["verbose"]?.default).toBe(false);
-  });
-});
-
-describe("parseOptionValues", () => {
-  test("passes through string values", () => {
-    const schema: OptionSchema = {
-      name: { type: "string", description: "Name" },
-    };
-    const result = parseOptionValues(schema, { name: "test" });
-    expect(result["name"]).toBe("test");
-  });
-
-  test("coerces number values", () => {
-    const schema: OptionSchema = {
-      count: { type: "number", description: "Count" },
-    };
-    const result = parseOptionValues(schema, { count: "42" });
-    expect(result["count"]).toBe(42);
-  });
 
-  test("coerces boolean values", () => {
-    const schema: OptionSchema = {
-      verbose: { type: "boolean", description: "Verbose" },
-    };
-    const result = parseOptionValues(schema, { verbose: "true" });
-    expect(result["verbose"]).toBe(true);
-  });
-
-  test("applies default values", () => {
-    const schema: OptionSchema = {
-      count: { type: "number", default: 5, description: "Count" },
-    };
-    const result = parseOptionValues(schema, {});
-    expect(result["count"]).toBe(5);
-  });
-
-  test("reads from environment variables", () => {
-    process.env["TEST_VALUE"] = "env-value";
-    const schema: OptionSchema = {
-      value: { type: "string", env: "TEST_VALUE", description: "Value" },
-    };
-    const result = parseOptionValues(schema, {});
-    expect(result["value"]).toBe("env-value");
-    delete process.env["TEST_VALUE"];
-  });
-
-  test("validates enum values", () => {
-    const schema: OptionSchema = {
-      level: {
-        type: "string",
-        enum: ["low", "medium", "high"],
-        description: "Level",
-      },
-    };
-    const result = parseOptionValues(schema, { level: "medium" });
-    expect(result["level"]).toBe("medium");
-  });
-
-  test("throws on invalid enum value", () => {
-    const schema: OptionSchema = {
-      level: {
-        type: "string",
-        enum: ["low", "medium", "high"],
-        description: "Level",
-      },
-    };
-    expect(() => parseOptionValues(schema, { level: "invalid" })).toThrow();
-  });
-});
-
-describe("validateOptions", () => {
-  test("returns empty array for valid options", () => {
-    const schema: OptionSchema = {
-      name: { type: "string", description: "Name" },
-    };
-    const errors = validateOptions(schema, { name: "test" });
-    expect(errors).toEqual([]);
-  });
-
-  test("returns error for missing required option", () => {
-    const schema: OptionSchema = {
-      name: { type: "string", required: true, description: "Name" },
-    };
-    const errors = validateOptions(schema, {} as Record<string, unknown>);
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors[0]?.type).toBe("missing_required");
-  });
-
-  test("validates number min/max", () => {
-    const schema: OptionSchema = {
-      count: { type: "number", min: 1, max: 10, description: "Count" },
-    };
-    const errors = validateOptions(schema, { count: 0 });
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors[0]?.type).toBe("validation");
-  });
-});
-
-describe("parseCliArgs", () => {
-  test("parses command name", () => {
-    const cmd = defineCommand({
-      name: "run",
-      description: "Run command",
-      execute: () => {},
-    });
-
-    const result = parseCliArgs({
-      args: ["run"],
-      commands: { run: cmd },
+describe("cli/parser helpers", () => {
+  describe("extractCommandChain", () => {
+    test("splits commands from flags", () => {
+      const cases: Array<{
+        args: string[];
+        expected: { commands: string[]; remaining: string[] };
+      }> = [
+        { args: ["run", "test"], expected: { commands: ["run", "test"], remaining: [] } },
+        {
+          args: ["run", "--verbose", "file.ts"],
+          expected: { commands: ["run"], remaining: ["--verbose", "file.ts"] },
+        },
+        { args: ["--help"], expected: { commands: [], remaining: ["--help"] } },
+        { args: ["run", "-v"], expected: { commands: ["run"], remaining: ["-v"] } },
+        { args: [], expected: { commands: [], remaining: [] } },
+        {
+          args: ["config", "set", "--key", "value"],
+          expected: { commands: ["config", "set"], remaining: ["--key", "value"] },
+        },
+      ];
+
+      for (const c of cases) {
+        expect(extractCommandChain(c.args)).toEqual(c.expected);
+      }
     });
-
-    expect(result.command).toBe(cmd);
-    expect(result.commandPath).toEqual(["run"]);
   });
 
-  test("detects help flag", () => {
-    const cmd = defineCommand({
-      name: "run",
-      description: "Run command",
-      execute: () => {},
-    });
-
-    const result = parseCliArgs({
-      args: ["run", "--help"],
-      commands: { run: cmd },
+  describe("schemaToParseArgsOptions", () => {
+    test("converts OptionSchema to parseArgs config", () => {
+      const schema: OptionSchema = {
+        name: { type: "string", description: "Name" },
+        verbose: { type: "boolean", alias: "v", default: false, description: "Verbose" },
+        files: { type: "array", description: "Files" },
+        count: { type: "number", default: 10, description: "Count" },
+      };
+
+      const result = schemaToParseArgsOptions(schema);
+
+      expect(result.options?.["name"]).toMatchObject({ type: "string" });
+      expect(result.options?.["verbose"]).toMatchObject({
+        type: "boolean",
+        short: "v",
+        default: false,
+      });
+      expect(result.options?.["files"]).toMatchObject({ multiple: true });
+      // parseArgs expects string defaults for non-boolean types
+      expect(result.options?.["count"]).toMatchObject({ type: "string", default: "10" });
     });
-
-    expect(result.showHelp).toBe(true);
   });
 
-  test("detects -h flag", () => {
-    const cmd = defineCommand({
-      name: "run",
-      description: "Run command",
-      execute: () => {},
+  describe("parseOptionValues", () => {
+    test("coerces values, applies defaults, and reads env", () => {
+      process.env["TEST_VALUE"] = "env-value";
+
+      const schema: OptionSchema = {
+        name: { type: "string", description: "Name" },
+        count: { type: "number", default: 5, description: "Count" },
+        verbose: { type: "boolean", description: "Verbose" },
+        value: { type: "string", env: "TEST_VALUE", description: "Value" },
+        level: {
+          type: "string",
+          enum: ["low", "medium", "high"],
+          description: "Level",
+        },
+      };
+
+      const result = parseOptionValues(schema, {
+        name: "test",
+        count: "42",
+        verbose: "true",
+        level: "medium",
+      });
+
+      expect(result["name"]).toBe("test");
+      expect(result["count"]).toBe(42);
+      expect(result["verbose"]).toBe(true);
+      expect(result["value"]).toBe("env-value");
+      expect(result["level"]).toBe("medium");
+
+      delete process.env["TEST_VALUE"];
     });
 
-    const result = parseCliArgs({
-      args: ["run", "-h"],
-      commands: { run: cmd },
-    });
+    test("throws on invalid enum", () => {
+      const schema: OptionSchema = {
+        level: {
+          type: "string",
+          enum: ["low", "medium", "high"],
+          description: "Level",
+        },
+      };
 
-    expect(result.showHelp).toBe(true);
+      expect(() => parseOptionValues(schema, { level: "invalid" })).toThrow();
+    });
   });
 
-  test("returns error for unknown command", () => {
-    const result = parseCliArgs({
-      args: ["unknown"],
-      commands: {},
-    });
+  describe("validateOptions", () => {
+    test("returns errors for missing required and invalid ranges", () => {
+      const schema: OptionSchema = {
+        name: { type: "string", required: true, description: "Name" },
+        count: { type: "number", min: 1, max: 10, description: "Count" },
+      };
 
-    expect(result.error?.type).toBe("unknown_command");
-  });
+      expect(validateOptions(schema, { name: "ok", count: 5 })).toEqual([]);
 
-  test("uses default command if provided", () => {
-    const cmd = defineCommand({
-      name: "default",
-      description: "Default command",
-      execute: () => {},
-    });
+      const missing = validateOptions(schema, {} as Record<string, unknown>);
+      expect(missing.some((e) => e.type === "missing_required" && e.field === "name")).toBe(true);
 
-    const result = parseCliArgs({
-      args: [],
-      commands: { default: cmd },
-      defaultCommand: "default",
+      const tooLow = validateOptions(schema, { name: "ok", count: 0 });
+      expect(tooLow.some((e) => e.type === "validation" && e.field === "count")).toBe(true);
     });
-
-    expect(result.command).toBe(cmd);
   });
 });
+

package/src/__tests__/registry.test.ts

@@ -1,66 +1,45 @@
 import { test, expect, describe } from "bun:test";
-import { createCommandRegistry } from "../registry/commandRegistry.ts";
-import { defineCommand } from "../types/command.ts";
+import { CommandRegistry } from "../core/registry.ts";
+import { Command } from "../core/command.ts";
+import type { OptionSchema } from "../types/command.ts";
 
-describe("createCommandRegistry", () => {
-  test("registers a command", () => {
-    const registry = createCommandRegistry();
-    const cmd = defineCommand({
-      name: "test",
-      description: "Test command",
-      execute: () => {},
-    });
+class SimpleCommand extends Command<OptionSchema> {
+  readonly name: string;
+  readonly description: string;
+  readonly options = {} as const;
 
-    registry.register(cmd);
+  constructor(name: string, description = "") {
+    super();
+    this.name = name;
+    this.description = description;
+  }
+
+  override async execute(): Promise<void> {}
+}
 
+describe("CommandRegistry", () => {
+  test("registers a command", () => {
+    const registry = new CommandRegistry();
+    registry.register(new SimpleCommand("test", "Test command"));
     expect(registry.has("test")).toBe(true);
   });
 
   test("retrieves command by name", () => {
-    const registry = createCommandRegistry();
-    const cmd = defineCommand({
-      name: "greet",
-      description: "Greet command",
-      execute: () => {},
-    });
-
+    const registry = new CommandRegistry();
+    const cmd = new SimpleCommand("greet", "Greet command");
     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();
+    const registry = new CommandRegistry();
     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: () => {},
-    });
+    const registry = new CommandRegistry();
+    const cmd1 = new SimpleCommand("a", "A");
+    const cmd2 = new SimpleCommand("b", "B");
 
     registry.register(cmd1);
     registry.register(cmd2);
@@ -71,125 +50,19 @@ describe("createCommandRegistry", () => {
   });
 
   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: () => {},
-    });
-
+    const registry = new CommandRegistry();
+    const cmd = new SimpleCommand("dup", "Duplicate");
     registry.register(cmd);
-
-    expect(registry.has("c")).toBe(true);
+    expect(() => registry.register(cmd)).toThrow(/already registered/i);
   });
 
-  test("getNames returns command names", () => {
-    const registry = createCommandRegistry();
-    const cmdA = defineCommand({
-      name: "a",
-      description: "A",
-      execute: () => {},
-    });
-    const cmdB = defineCommand({
-      name: "b",
-      description: "B",
-      execute: () => {},
-    });
+  test("names returns command names", () => {
+    const registry = new CommandRegistry();
+    registry.register(new SimpleCommand("a", "A"));
+    registry.register(new SimpleCommand("b", "B"));
 
-    registry.register(cmdA);
-    registry.register(cmdB);
-
-    const names = registry.getNames();
+    const names = registry.names();
     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);
-  });
 });