@pablozaiden/terminatui 0.1.2 → 0.3.0-beta-1

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;
@@ -33,7 +35,14 @@ export class HelpCommand extends Command<OptionSchema> {
     this.appVersion = config.appVersion;
   }
 
-  override async execute(_ctx: AppContext): Promise<void> {
+  /**
+   * Help command is CLI-only (auto-injected for CLI use, not shown in TUI).
+   */
+  override supportsTui(): boolean {
+    return false;
+  }
+
+  override async execute(): Promise<void> {
     let helpText: string;
 
     if (this.parentCommand) {
@@ -41,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") */
@@ -19,7 +18,7 @@ export interface VersionConfig {
  * Format version string with optional commit hash.
  * If commitHash is empty or undefined, shows "(dev)".
  */
-export function formatVersion(version: string, commitHash?: string): string {
+function formatVersion(version: string, commitHash?: string): string {
   const hashPart = commitHash && commitHash.length > 0 
     ? commitHash.substring(0, 7) 
     : "(dev)";
@@ -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;

package/src/cli/parser.ts

@@ -1,21 +1,6 @@
-import type { Command, OptionSchema, OptionValues } from "../types/command.ts";
-import { parseArgs, type ParseArgsConfig } from "util";
+import type { OptionSchema, OptionValues } from "../types/command.ts";
+import { type ParseArgsConfig } from "util";
 
-/**
- * Result of parsing CLI arguments
- */
-export interface ParseResult<T extends OptionSchema = OptionSchema> {
-  command: Command<T> | null;
-  commandPath: string[];
-  options: OptionValues<T>;
-  args: string[];
-  showHelp: boolean;
-  error?: ParseError;
-}
-
-/**
- * Error during parsing
- */
 export interface ParseError {
   type: "unknown_command" | "invalid_option" | "missing_required" | "validation";
   message: string;
@@ -30,21 +15,38 @@ export function extractCommandChain(args: string[]): {
   remaining: string[];
 } {
   const commands: string[] = [];
-  let i = 0;
+  const remaining: string[] = [];
 
-  for (; i < args.length; i++) {
+  for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg?.startsWith("-")) {
-      break;
+
+    if (!arg) {
+      continue;
     }
-    if (arg) {
-      commands.push(arg);
+
+    if (arg.startsWith("-")) {
+      remaining.push(arg);
+
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        remaining.push(next);
+        i += 1;
+      }
+
+      continue;
     }
+
+    if (remaining.length > 0) {
+      remaining.push(arg);
+      continue;
+    }
+
+    commands.push(arg);
   }
 
   return {
     commands,
-    remaining: args.slice(i),
+    remaining,
   };
 }
 
@@ -168,74 +170,3 @@ export function validateOptions<T extends OptionSchema>(
   return errors;
 }
 
-interface ParseCliArgsOptions<T extends OptionSchema> {
-  args: string[];
-  commands: Record<string, Command<T>>;
-  defaultCommand?: string;
-}
-
-/**
- * Parse CLI arguments into a result
- */
-export function parseCliArgs<T extends OptionSchema>(
-  options: ParseCliArgsOptions<T>
-): ParseResult<T> {
-  const { args, commands, defaultCommand } = options;
-  const { commands: commandChain, remaining } = extractCommandChain(args);
-
-  // Check for help flag
-  const showHelp = remaining.includes("--help") || remaining.includes("-h");
-
-  // Find command
-  const commandName = commandChain[0] ?? defaultCommand;
-  if (!commandName) {
-    return {
-      command: null,
-      commandPath: [],
-      options: {} as OptionValues<T>,
-      args: remaining,
-      showHelp,
-    };
-  }
-
-  const command = commands[commandName];
-  if (!command) {
-    return {
-      command: null,
-      commandPath: commandChain,
-      options: {} as OptionValues<T>,
-      args: remaining,
-      showHelp,
-      error: {
-        type: "unknown_command",
-        message: `Unknown command: ${commandName}`,
-      },
-    };
-  }
-
-  // Parse options
-  const schema = command.options ?? ({} as T);
-  const parseArgsConfig = schemaToParseArgsOptions(schema);
-
-  let parsedValues: Record<string, unknown> = {};
-  try {
-    const { values } = parseArgs({
-      args: remaining,
-      ...parseArgsConfig,
-      allowPositionals: false,
-    });
-    parsedValues = values;
-  } catch {
-    // Ignore parse errors for now
-  }
-
-  const optionValues = parseOptionValues(schema, parsedValues);
-
-  return {
-    command,
-    commandPath: commandChain,
-    options: optionValues,
-    args: remaining,
-    showHelp,
-  };
-}