@pablozaiden/terminatui 0.2.0 → 0.3.0

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);
-  });
 });

package/src/__tests__/schemaToFields.test.ts

@@ -1,176 +1,93 @@
-import { describe, test, expect } from "bun:test";
-import { schemaToFieldConfigs, getFieldDisplayValue } from "../tui/utils/schemaToFields.ts";
+import { describe, expect, test } from "bun:test";
+import { getFieldDisplayValue, schemaToFieldConfigs } 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");
-    });
+describe("schemaToFields", () => {
+  describe("schemaToFieldConfigs", () => {
+    test("maps option schema to field configs", () => {
+      const schema: OptionSchema = {
+        name: { type: "string", description: "User name" },
+        color: {
+          type: "string",
+          description: "Color choice",
+          enum: ["red", "green", "blue"],
+        },
+        verbose: { type: "boolean", description: "Verbose output" },
+        count: { type: "number", description: "Count" },
+        files: { type: "array", description: "Files to process" },
+        repoPath: {
+          type: "string",
+          description: "Repository path",
+          label: "Repository",
+        },
+        hidden: { type: "string", description: "Hidden", tuiHidden: true },
+        path: { type: "string", description: "Path", placeholder: "Enter path here" },
+        grouped: { type: "string", description: "Grouped", group: "Basic" },
+      };
 
-    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");
-    });
+      const fields = schemaToFieldConfigs(schema);
 
-    test("converts boolean type", () => {
-        const schema: OptionSchema = {
-            verbose: {
-                type: "boolean",
-                description: "Verbose output",
-            },
-        };
-        
-        const fields = schemaToFieldConfigs(schema);
-        expect(fields[0]?.type).toBe("boolean");
-    });
+      // Basic mappings
+      const name = fields.find((f) => f.key === "name");
+      expect(name).toMatchObject({ type: "text", label: "Name" });
 
-    test("converts number type", () => {
-        const schema: OptionSchema = {
-            count: {
-                type: "number",
-                description: "Count",
-            },
-        };
-        
-        const fields = schemaToFieldConfigs(schema);
-        expect(fields[0]?.type).toBe("number");
-    });
+      const color = fields.find((f) => f.key === "color");
+      expect(color?.type).toBe("enum");
+      expect(color?.options?.length).toBe(3);
 
-    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");
-    });
+      expect(fields.find((f) => f.key === "verbose")?.type).toBe("boolean");
+      expect(fields.find((f) => f.key === "count")?.type).toBe("number");
+      expect(fields.find((f) => f.key === "files")?.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");
+      // Decorations
+      expect(fields.find((f) => f.key === "repoPath")?.label).toBe("Repository");
+      expect(fields.some((f) => f.key === "hidden")).toBe(false);
+      expect(fields.find((f) => f.key === "path")?.placeholder).toBe("Enter path here");
+      expect(fields.find((f) => f.key === "grouped")?.group).toBe("Basic");
     });
 
     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");
-    });
+      const schema: OptionSchema = {
+        third: { type: "string", description: "Third", order: 3 },
+        first: { type: "string", description: "First", order: 1 },
+        second: { type: "string", description: "Second", order: 2 },
+      };
 
-    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");
+      const fields = schemaToFieldConfigs(schema);
+      expect(fields.map((f) => f.key)).toEqual(["first", "second", "third"]);
     });
+  });
 
-    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");
-    });
+  describe("getFieldDisplayValue", () => {
+    test("formats values for display", () => {
+      expect(getFieldDisplayValue(true, { key: "enabled", label: "Enabled", type: "boolean" })).toBe(
+        "True"
+      );
+      expect(getFieldDisplayValue(false, { key: "enabled", label: "Enabled", type: "boolean" })).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)");
-    });
+      const enumField = {
+        key: "color",
+        label: "Color",
+        type: "enum" as const,
+        options: [
+          { name: "Red", value: "red" },
+          { name: "Green", value: "green" },
+        ],
+      };
+      expect(getFieldDisplayValue("red", enumField)).toBe("Red");
 
-    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);
-    });
+      const textField = { key: "name", label: "Name", type: "text" as const };
+      expect(getFieldDisplayValue("", textField)).toBe("(empty)");
+      expect(getFieldDisplayValue(null, textField)).toBe("(empty)");
+      expect(getFieldDisplayValue(undefined, textField)).toBe("(empty)");
+      expect(getFieldDisplayValue("hello", textField)).toBe("hello");
 
-    test("displays short values as-is", () => {
-        const field = { key: "name", label: "Name", type: "text" as const };
-        expect(getFieldDisplayValue("hello", field)).toBe("hello");
+      const longValue = "a".repeat(100);
+      const longResult = getFieldDisplayValue(longValue, { key: "desc", label: "Description", type: "text" });
+      expect(longResult.length).toBe(60);
+      expect(longResult.endsWith("...")).toBe(true);
     });
+  });
 });

package/src/builtins/help.ts

@@ -1,7 +1,8 @@
 import { Command, type AnyCommand } from "../core/command.ts";
-import type { AppContext } from "../core/context.ts";
 import { generateCommandHelp, generateAppHelp } from "../core/help.ts";
+import { KNOWN_COMMANDS } from "../core/knownCommands.ts";
 import type { OptionSchema } from "../types/command.ts";
+import { GLOBAL_OPTIONS_SCHEMA } from "../core/application.ts";
 
 /**
  * Built-in help command that is auto-injected as a subcommand into all commands.
@@ -11,8 +12,9 @@ import type { OptionSchema } from "../types/command.ts";
  * be instantiated directly.
  */
 export class HelpCommand extends Command<OptionSchema> {
-  readonly name = "help";
+  readonly name = KNOWN_COMMANDS.help;
   readonly description = "Show help for this command";
+  override readonly tuiHidden = true;
   readonly options = {} as const;
 
   private parentCommand: AnyCommand | null = null;
@@ -40,7 +42,7 @@ export class HelpCommand extends Command<OptionSchema> {
     return false;
   }
 
-  override async execute(_ctx: AppContext): Promise<void> {
+  override async execute(): Promise<void> {
     let helpText: string;
 
     if (this.parentCommand) {
@@ -48,12 +50,18 @@ export class HelpCommand extends Command<OptionSchema> {
       helpText = generateCommandHelp(this.parentCommand, {
         appName: this.appName,
         version: this.appVersion,
+        globalOptionsSchema: GLOBAL_OPTIONS_SCHEMA,
       });
     } else {
       // Show help for the entire application
-      helpText = generateAppHelp(this.allCommands, {
+      const visibleCommands = this.allCommands.filter(
+        (cmd) => !cmd.tuiHidden || cmd.supportsCli()
+      );
+
+      helpText = generateAppHelp(visibleCommands, {
         appName: this.appName,
         version: this.appVersion,
+        globalOptionsSchema: GLOBAL_OPTIONS_SCHEMA,
       });
     }
 

package/src/builtins/settings.ts

@@ -1,8 +1,10 @@
 import { Command } from "../core/command.ts";
-import type { AppContext } from "../core/context.ts";
+import { AppContext } from "../core/context.ts";
 import { LogLevel } from "../core/logger.ts";
 import type { OptionSchema, OptionValues } from "../types/command.ts";
 import type { CommandResult } from "../core/command.ts";
+import { getEnumKeys } from "../tui/utils/getEnumKeys.ts";
+import { KNOWN_COMMANDS } from "../core/knownCommands.ts";
 
 /**
  * Options schema for the settings command.
@@ -12,7 +14,7 @@ const settingsOptions = {
     type: "string",
     description: "Minimum log level to emit",
     default: "info",
-    enum: ["silly", "trace", "debug", "info", "warn", "error", "fatal"],
+    enum: getEnumKeys(LogLevel) as (keyof typeof LogLevel)[],
     label: "Log Level",
     order: 1,
   },
@@ -35,28 +37,6 @@ interface SettingsConfig {
   detailedLogs: boolean;
 }
 
-/**
- * Map of string log level names to LogLevel enum values.
- */
-const logLevelMap: Record<string, LogLevel> = {
-  silly: LogLevel.Silly,
-  trace: LogLevel.Trace,
-  debug: LogLevel.Debug,
-  info: LogLevel.Info,
-  warn: LogLevel.Warn,
-  error: LogLevel.Error,
-  fatal: LogLevel.Fatal,
-};
-
-/**
- * Parse a string log level to the LogLevel enum.
- */
-function parseLogLevel(value?: string): LogLevel {
-  if (!value) return LogLevel.Info;
-  const level = logLevelMap[value.toLowerCase()];
-  return level ?? LogLevel.Info;
-}
-
 /**
  * Built-in settings command for configuring logging.
  * 
@@ -69,32 +49,38 @@ function parseLogLevel(value?: string): LogLevel {
  * In TUI mode, this command provides a UI for configuring these settings.
  */
 export class SettingsCommand extends Command<typeof settingsOptions, SettingsConfig> {
-  readonly name = "settings";
+  override supportsCli(): boolean {
+    return false;
+  }
+
+  readonly name = KNOWN_COMMANDS.settings;
   override readonly displayName = "Settings";
+  override readonly tuiHidden = true;
   readonly description = "Configure logging level and output format";
   readonly options = settingsOptions;
 
   override readonly actionLabel = "Save Settings";
   override readonly immediateExecution = false;
 
-  override buildConfig(_ctx: AppContext, opts: SettingsOptions): SettingsConfig {
-    const logLevel = parseLogLevel(opts["log-level"] as string | undefined);
+  override buildConfig(opts: SettingsOptions): SettingsConfig {
+    const logLevelStr = opts["log-level"];
+    const logLevel = LogLevel[logLevelStr as keyof typeof LogLevel] ?? LogLevel.info;
     const detailedLogs = Boolean(opts["detailed-logs"]);
 
     return { logLevel, detailedLogs };
   }
 
-  override async execute(ctx: AppContext, config: SettingsConfig): Promise<CommandResult> {
-    this.applySettings(ctx, config);
+  override async execute(config: SettingsConfig): Promise<CommandResult> {
+    this.applySettings(config);
     return {
       success: true,
       message: `Logging set to ${LogLevel[config.logLevel]}${config.detailedLogs ? " with detailed format" : ""}`,
     };
   }
 
-  private applySettings(ctx: AppContext, config: SettingsConfig): void {
-    ctx.logger.setMinLevel(config.logLevel);
-    ctx.logger.setDetailed(config.detailedLogs);
+  private applySettings(config: SettingsConfig): void {
+    AppContext.current.logger.setMinLevel(config.logLevel);
+    AppContext.current.logger.setDetailed(config.detailedLogs);
   }
 }
 

package/src/builtins/version.ts

@@ -1,12 +1,11 @@
 import { Command } from "../core/command.ts";
-import type { AppContext } from "../core/context.ts";
 import { colors } from "../cli/output/colors.ts";
 import type { OptionSchema } from "../types/command.ts";
 
 /**
  * Configuration for version command.
  */
-export interface VersionConfig {
+interface VersionConfig {
   /** Application name */
   appName: string;
   /** Application version (e.g., "1.0.0") */
@@ -33,6 +32,7 @@ export function formatVersion(version: string, commitHash?: string): string {
 export class VersionCommand extends Command<OptionSchema> {
   readonly name = "version";
   readonly description = "Show version information";
+  override readonly tuiHidden = true;
   readonly options = {} as const;
   readonly aliases = ["--version", "-v"];
 
@@ -54,7 +54,7 @@ export class VersionCommand extends Command<OptionSchema> {
     return formatVersion(this.appVersion, this.commitHash);
   }
 
-  override async execute(_ctx: AppContext): Promise<void> {
+  override async execute(): Promise<void> {
     const versionDisplay = this.getFormattedVersion();
     console.log(`${colors.bold(this.appName)} ${colors.dim(`v${versionDisplay}`)}`);
   }

package/src/cli/output/colors.ts

@@ -23,7 +23,7 @@ const BG_BLUE = "\x1b[44m";
 /**
  * Check if terminal supports colors
  */
-export function supportsColors(): boolean {
+function supportsColors(): boolean {
   if (typeof process === "undefined") return false;
   if (process.env["NO_COLOR"]) return false;
   if (process.env["FORCE_COLOR"]) return true;