@pablozaiden/terminatui 0.2.0 → 0.3.0

package/src/__tests__/registryNew.test.ts

@@ -1,160 +0,0 @@
-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__/table.test.ts

@@ -1,146 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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);
-        });
-    });
-});
-

package/src/builtins/index.ts

@@ -1,4 +0,0 @@
-export { HelpCommand, createHelpCommandForParent, createRootHelpCommand } from "./help.ts";
-export { VersionCommand, createVersionCommand, formatVersion } from "./version.ts";
-export { SettingsCommand, createSettingsCommand } from "./settings.ts";
-export type { VersionConfig } from "./version.ts";

package/src/cli/help.ts

@@ -1,174 +0,0 @@
-import type { Command, OptionDef } from "../types/command.ts";
-import { colors } from "./output/colors.ts";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyCommand = Command<any, any>;
-
-/**
- * Format usage line for a command
- */
-export function formatUsage(
-  command: AnyCommand,
-  appName = "cli"
-): string {
-  const parts = [appName, command.name];
-
-  if (command.subcommands && Object.keys(command.subcommands).length > 0) {
-    parts.push("[command]");
-  }
-
-  if (command.options && Object.keys(command.options).length > 0) {
-    parts.push("[options]");
-  }
-
-  return parts.join(" ");
-}
-
-/**
- * Format subcommands list
- */
-export function formatCommands(command: AnyCommand): string {
-  if (!command.subcommands) return "";
-
-  const entries = Object.entries(command.subcommands)
-    .filter(([, cmd]) => !cmd.hidden)
-    .map(([name, cmd]) => {
-      const aliases = cmd.aliases?.length ? ` (${cmd.aliases.join(", ")})` : "";
-      return `  ${colors.cyan(name)}${aliases}  ${cmd.description}`;
-    });
-
-  if (entries.length === 0) return "";
-
-  return ["Commands:", ...entries].join("\n");
-}
-
-/**
- * Format options list
- */
-export function formatOptions(command: AnyCommand): string {
-  if (!command.options) return "";
-
-  const entries = Object.entries(command.options).map(([name, defUntyped]) => {
-    const def = defUntyped as OptionDef;
-    const alias = def.alias ? `-${def.alias}, ` : "    ";
-    const flag = `${alias}--${name}`;
-    const required = def.required ? colors.red("*") : "";
-    const defaultVal = def.default !== undefined ? ` (default: ${def.default})` : "";
-    const enumVals = def.enum ? ` [${def.enum.join("|")}]` : "";
-
-    return `  ${colors.yellow(flag)}${required}  ${def.description}${enumVals}${defaultVal}`;
-  });
-
-  if (entries.length === 0) return "";
-
-  return ["Options:", ...entries].join("\n");
-}
-
-/**
- * Format examples list
- */
-export function formatExamples(command: AnyCommand): string {
-  if (!command.examples?.length) return "";
-
-  const entries = command.examples.map(
-    (ex) => `  ${colors.dim("$")} ${ex.command}\n    ${colors.dim(ex.description)}`
-  );
-
-  return ["Examples:", ...entries].join("\n");
-}
-
-/**
- * Format global options (log-level, detailed-logs)
- */
-export function formatGlobalOptions(): string {
-  const entries = [
-    `  ${colors.yellow("--log-level")} <level>  Set log level [silly|trace|debug|info|warn|error|fatal]`,
-    `  ${colors.yellow("--detailed-logs")}      Enable detailed log output`,
-    `  ${colors.yellow("--no-detailed-logs")}   Disable detailed log output`,
-  ];
-
-  return ["Global Options:", ...entries].join("\n");
-}
-
-/**
- * Get command summary line
- */
-export function getCommandSummary(command: AnyCommand): string {
-  const aliases = command.aliases?.length ? ` (${command.aliases.join(", ")})` : "";
-  return `${command.name}${aliases}: ${command.description}`;
-}
-
-/**
- * Generate full help text for a command
- */
-export function generateHelp(
-  command: AnyCommand,
-  options: { appName?: string; version?: string } = {}
-): string {
-  const { appName = "cli", version } = options;
-  const sections: string[] = [];
-
-  // Header
-  if (version) {
-    sections.push(`${colors.bold(appName)} ${colors.dim(`v${version}`)}`);
-  }
-
-  // Description
-  sections.push(command.description);
-
-  // Usage
-  sections.push(`\n${colors.bold("Usage:")}\n  ${formatUsage(command, appName)}`);
-
-  // Commands
-  const commandsSection = formatCommands(command);
-  if (commandsSection) {
-    sections.push(`\n${commandsSection}`);
-  }
-
-  // Options
-  const optionsSection = formatOptions(command);
-  if (optionsSection) {
-    sections.push(`\n${optionsSection}`);
-  }
-
-  // Examples
-  const examplesSection = formatExamples(command);
-  if (examplesSection) {
-    sections.push(`\n${examplesSection}`);
-  }
-
-  return sections.join("\n");
-}
-
-/**
- * Generate help text for a specific command (includes global options)
- */
-export function generateCommandHelp(
-  command: AnyCommand,
-  appName = "cli"
-): string {
-  const sections: string[] = [];
-
-  // Description
-  sections.push(command.description);
-
-  // Usage
-  sections.push(`\n${colors.bold("Usage:")}\n  ${formatUsage(command, appName)}`);
-
-  // Options
-  const optionsSection = formatOptions(command);
-  if (optionsSection) {
-    sections.push(`\n${optionsSection}`);
-  }
-
-  // Global Options
-  sections.push(`\n${formatGlobalOptions()}`);
-
-  // Examples
-  const examplesSection = formatExamples(command);
-  if (examplesSection) {
-    sections.push(`\n${examplesSection}`);
-  }
-
-  return sections.join("\n");
-}

package/src/cli/index.ts

@@ -1,3 +0,0 @@
-export * from "./parser.ts";
-export * from "./help.ts";
-export * from "./output/index.ts";

package/src/cli/output/index.ts

@@ -1,2 +0,0 @@
-export * from "./colors.ts";
-export * from "./table.ts";

package/src/cli/output/table.ts

@@ -1,141 +0,0 @@
-/**
- * Column configuration for tables
- */
-export interface ColumnConfig {
-  key: string;
-  header?: string;
-  width?: number;
-  align?: "left" | "right" | "center";
-  formatter?: (value: unknown) => string;
-}
-
-export interface TableOptions {
-  columns?: (string | ColumnConfig)[];
-  showHeaders?: boolean;
-  border?: boolean;
-}
-
-/**
- * Create a formatted table string
- */
-export function table<T extends Record<string, unknown>>(
-  data: T[],
-  options: TableOptions = {}
-): string {
-  if (data.length === 0) return "";
-
-  const { showHeaders = true } = options;
-
-  // Determine columns
-  const columns: ColumnConfig[] = options.columns
-    ? options.columns.map((col) =>
-        typeof col === "string" ? { key: col, header: col } : col
-      )
-    : Object.keys(data[0] ?? {}).map((key) => ({ key, header: key }));
-
-  // Calculate column widths
-  const widths = columns.map((col) => {
-    const headerWidth = (col.header ?? col.key).length;
-    const maxDataWidth = Math.max(
-      ...data.map((row) => {
-        const value = row[col.key];
-        const formatted = col.formatter ? col.formatter(value) : String(value ?? "");
-        return formatted.length;
-      })
-    );
-    return col.width ?? Math.max(headerWidth, maxDataWidth);
-  });
-
-  // Format a row
-  const formatRow = (values: string[]): string => {
-    return values
-      .map((val, i) => {
-        const width = widths[i] ?? 10;
-        const col = columns[i];
-        const align = col?.align ?? "left";
-
-        if (align === "right") {
-          return val.padStart(width);
-        } else if (align === "center") {
-          const leftPad = Math.floor((width - val.length) / 2);
-          return val.padStart(leftPad + val.length).padEnd(width);
-        }
-        return val.padEnd(width);
-      })
-      .join("  ");
-  };
-
-  const rows: string[] = [];
-
-  // Add header
-  if (showHeaders) {
-    const headers = columns.map((col) => col.header ?? col.key);
-    rows.push(formatRow(headers));
-    rows.push(widths.map((w) => "-".repeat(w)).join("  "));
-  }
-
-  // Add data rows
-  for (const row of data) {
-    const values = columns.map((col) => {
-      const value = row[col.key];
-      return col.formatter ? col.formatter(value) : String(value ?? "");
-    });
-    rows.push(formatRow(values));
-  }
-
-  return rows.join("\n");
-}
-
-/**
- * Create a key-value list
- */
-export function keyValueList(
-  data: Record<string, unknown>,
-  options: { separator?: string } = {}
-): string {
-  const { separator = ":" } = options;
-
-  const entries = Object.entries(data);
-  if (entries.length === 0) return "";
-
-  const maxKeyLength = Math.max(...entries.map(([key]) => key.length));
-
-  return entries
-    .map(([key, value]) => `${key.padEnd(maxKeyLength)}${separator} ${value}`)
-    .join("\n");
-}
-
-/**
- * Create a bullet list
- */
-export function bulletList(
-  items: string[],
-  options: { bullet?: string; indent?: number } = {}
-): string {
-  const { bullet = "•", indent = 0 } = options;
-
-  if (items.length === 0) return "";
-
-  const prefix = " ".repeat(indent);
-  return items.map((item) => `${prefix}${bullet} ${item}`).join("\n");
-}
-
-/**
- * Create a numbered list
- */
-export function numberedList(
-  items: string[],
-  options: { start?: number; indent?: number } = {}
-): string {
-  const { start = 1, indent = 0 } = options;
-
-  if (items.length === 0) return "";
-
-  const prefix = " ".repeat(indent);
-  const maxNum = start + items.length - 1;
-  const numWidth = String(maxNum).length;
-
-  return items
-    .map((item, i) => `${prefix}${String(start + i).padStart(numWidth)}. ${item}`)
-    .join("\n");
-}