@pablozaiden/terminatui 0.1.2 → 0.3.0-beta-1

package/src/__tests__/application.test.ts

@@ -1,8 +1,10 @@
-import { describe, test, expect, afterEach } from "bun:test";
+import { describe, test, expect } from "bun:test";
 import { Application } from "../core/application.ts";
 import { Command } from "../core/command.ts";
-import { AppContext } from "../core/context.ts";
 import type { OptionSchema, OptionValues, OptionDef } from "../types/command.ts";
+import { AppContext } from "../core/context.ts";
+import { LogLevel } from "../core/logger.ts";
+import { KNOWN_COMMANDS } from "../core/knownCommands.ts";
 
 // Define a proper option schema
 const testOptions = {
@@ -21,7 +23,6 @@ class TestCommand extends Command<typeof testOptions> {
   executedWith: Record<string, unknown> | null = null;
 
   override async execute(
-    _ctx: AppContext,
     opts: OptionValues<typeof testOptions>
   ): Promise<void> {
     this.executedWith = opts as Record<string, unknown>;
@@ -35,17 +36,57 @@ class TuiCommand extends Command<OptionSchema> {
 
   executed = false;
 
-  override async execute(_ctx: AppContext): Promise<void> {
+  override async execute(): Promise<void> {
     this.executed = true;
   }
 }
 
 describe("Application", () => {
-  afterEach(() => {
-    AppContext.clearCurrent();
-  });
-
   describe("constructor", () => {
+    test("rejects reserved help command definitions", () => {
+      class ReservedCommand extends Command<OptionSchema> {
+        readonly name = KNOWN_COMMANDS.help;
+        readonly description = "tries to override built-in";
+        readonly options = {};
+
+        override async execute(): Promise<void> {}
+      }
+
+      expect(() => {
+        new Application({
+          name: "test-app",
+          version: "1.0.0",
+          commands: [new ReservedCommand()],
+        });
+      }).toThrow(/reserved/i);
+
+      class SubCommand extends Command<OptionSchema> {
+        readonly name = KNOWN_COMMANDS.help;
+        readonly description = "user help";
+        readonly options = {};
+
+        override async execute(): Promise<void> {}
+      }
+
+      class ParentCommand extends Command<OptionSchema> {
+        readonly name = "parent";
+        readonly description = "parent";
+        readonly options = {};
+
+        override subCommands = [new SubCommand()];
+
+        override async execute(): Promise<void> {}
+      }
+
+      expect(() => {
+        new Application({
+          name: "test-app",
+          version: "1.0.0",
+          commands: [new ParentCommand()],
+        });
+      }).toThrow(/automatically injected/i);
+    });
+
     test("creates application with name and version", () => {
       const app = new Application({
         name: "test-app",
@@ -56,14 +97,16 @@ describe("Application", () => {
       expect(app.version).toBe("1.0.0");
     });
 
-    test("creates context and sets as current", () => {
-      const app = new Application({
+    test("creates context as side effect of creating application", () => {
+      // side effect of creating an application is setting the current context
+      new Application({
         name: "test-app",
         version: "1.0.0",
         commands: [],
       });
-      expect(AppContext.hasCurrent()).toBe(true);
-      expect(app.context).toBe(AppContext.current);
+      
+      expect(AppContext.current.config.name).toBe("test-app");
+      expect(AppContext.current.config.version).toBe("1.0.0");
     });
 
     test("registers provided commands", () => {
@@ -91,7 +134,7 @@ describe("Application", () => {
         version: "1.0.0",
         commands: [],
       });
-      expect(app.registry.has("help")).toBe(true);
+      expect(app.registry.has(KNOWN_COMMANDS.help)).toBe(true);
     });
 
     test("injects help subcommand into commands", () => {
@@ -103,32 +146,11 @@ describe("Application", () => {
         commands: [cmd],
       });
       expect(cmd.subCommands).toBeDefined();
-      expect(cmd.subCommands?.some((c) => c.name === "help")).toBe(true);
-    });
-  });
-
-  describe("getContext", () => {
-    test("returns the application context", () => {
-      const app = new Application({
-        name: "test-app",
-        version: "1.0.0",
-        commands: [],
-      });
-      expect(app.getContext()).toBe(app.context);
+      expect(cmd.subCommands?.some((c) => c.name === KNOWN_COMMANDS.help)).toBe(true);
     });
   });
 
   describe("run", () => {
-    test("shows help when no args and no default command", async () => {
-      const app = new Application({
-        name: "test-app",
-        version: "1.0.0",
-        commands: [new TestCommand()],
-      });
-      // Should not throw
-      await app.run([]);
-    });
-
     test("runs default command when no args", async () => {
       const cmd = new TuiCommand();
       const app = new Application({
@@ -137,31 +159,30 @@ describe("Application", () => {
         commands: [cmd],
         defaultCommand: "tui-cmd",
       });
-      await app.run([]);
+      await app.runFromArgs([]);
       expect(cmd.executed).toBe(true);
     });
 
-    test("runs specified command", async () => {
+    test("runs specified command and passes options", async () => {
       const cmd = new TestCommand();
       const app = new Application({
         name: "test-app",
         version: "1.0.0",
         commands: [cmd],
       });
-      await app.run(["test"]);
-      expect(cmd.executedWith).not.toBeNull();
+
+      await app.runFromArgs(["test", "--value", "hello"]);
+      expect(cmd.executedWith?.["value"]).toBe("hello");
     });
 
-    test("passes options to command", async () => {
-      const cmd = new TestCommand();
+    test("with no args and no default, prints help (no throw)", async () => {
       const app = new Application({
         name: "test-app",
         version: "1.0.0",
-        commands: [cmd],
+        commands: [new TestCommand()],
       });
-      await app.run(["test", "--value", "hello"]);
-      expect(cmd.executedWith).not.toBeNull();
-      expect(cmd.executedWith?.["value"]).toBe("hello");
+
+      await app.runFromArgs([]);
     });
   });
 
@@ -179,7 +200,7 @@ describe("Application", () => {
           called = true;
         },
       });
-      await app.run(["test"]);
+      await app.runFromArgs(["test"]);
       expect(called).toBe(true);
     });
 
@@ -196,7 +217,7 @@ describe("Application", () => {
           called = true;
         },
       });
-      await app.run(["test"]);
+      await app.runFromArgs(["test"]);
       expect(called).toBe(true);
     });
 
@@ -219,11 +240,11 @@ describe("Application", () => {
         commands: [new ErrorCommand()],
       });
       app.setHooks({
-        onError: async (_ctx, error) => {
+        onError: async (error) => {
           errorCaught = error;
         },
       });
-      await app.run(["error-cmd"]);
+      await app.runFromArgs(["error-cmd"]);
       expect(errorCaught?.message).toBe("Test error");
     });
   });
@@ -250,7 +271,6 @@ describe("Application", () => {
         readonly options = configOptions;
 
         override buildConfig(
-          _ctx: AppContext,
           opts: OptionValues<typeof configOptions>
         ): ParsedConfig {
           buildConfigCalled = true;
@@ -260,7 +280,7 @@ describe("Application", () => {
           };
         }
 
-        override async execute(_ctx: AppContext, config: ParsedConfig): Promise<void> {
+        override async execute(config: ParsedConfig): Promise<void> {
           receivedConfig = config;
         }
       }
@@ -271,7 +291,7 @@ describe("Application", () => {
         commands: [new ConfigCommand()],
       });
 
-      await app.run(["config-cmd", "--value", "test", "--count", "42"]);
+      await app.runFromArgs(["config-cmd", "--value", "test", "--count", "42"]);
       
       expect(buildConfigCalled).toBe(true);
       expect(receivedConfig).toEqual({ value: "test", count: 42 });
@@ -286,7 +306,6 @@ describe("Application", () => {
         readonly options = testOptions;
 
         override async execute(
-          _ctx: AppContext,
           opts: OptionValues<typeof testOptions>
         ): Promise<void> {
           receivedOpts = opts as Record<string, unknown>;
@@ -299,7 +318,7 @@ describe("Application", () => {
         commands: [new NoConfigCommand()],
       });
 
-      await app.run(["no-config-cmd", "--value", "hello"]);
+      await app.runFromArgs(["no-config-cmd", "--value", "hello"]);
       
       expect(receivedOpts).toEqual({ value: "hello" });
     });
@@ -328,12 +347,12 @@ describe("Application", () => {
       });
       
       app.setHooks({
-        onError: async (_ctx, error) => {
+        onError: async (error) => {
           errorCaught = error;
         },
       });
 
-      await app.run(["fail-config", "--value", "test"]);
+      await app.runFromArgs(["fail-config", "--value", "test"]);
       
       expect(errorCaught?.message).toBe("Config validation failed");
     });
@@ -349,7 +368,7 @@ describe("Application", () => {
       });
       
       // Should not throw - global option should be parsed and removed
-      await app.run(["--log-level", "debug", "test", "--value", "hello"]);
+      await app.runFromArgs(["--log-level", "debug", "test", "--value", "hello"]);
       expect(cmd.executedWith?.["value"]).toBe("hello");
     });
 
@@ -361,7 +380,7 @@ describe("Application", () => {
         commands: [cmd],
       });
       
-      await app.run(["test", "--log-level", "debug", "--value", "hello"]);
+      await app.runFromArgs(["test", "--log-level", "debug", "--value", "hello"]);
       expect(cmd.executedWith?.["value"]).toBe("hello");
     });
 
@@ -374,14 +393,14 @@ describe("Application", () => {
       });
       
       // All of these should work (case-insensitive)
-      await app.run(["--log-level", "debug", "test"]);
-      expect(app.context.logger.getMinLevel()).toBe(2); // Debug = 2
+      await app.runFromArgs(["--log-level", "debug", "test"]);
+      expect(AppContext.current.logger.getMinLevel()).toBe(LogLevel.debug);
       
-      await app.run(["--log-level", "Debug", "test"]);
-      expect(app.context.logger.getMinLevel()).toBe(2);
+      await app.runFromArgs(["--log-level", "Debug", "test"]);
+      expect(AppContext.current.logger.getMinLevel()).toBe(LogLevel.debug);
       
-      await app.run(["--log-level", "DEBUG", "test"]);
-      expect(app.context.logger.getMinLevel()).toBe(2);
+      await app.runFromArgs(["--log-level", "DEBUG", "test"]);
+      expect(AppContext.current.logger.getMinLevel()).toBe(LogLevel.debug);
     });
 
     test("parses --detailed-logs flag", async () => {
@@ -392,7 +411,7 @@ describe("Application", () => {
         commands: [cmd],
       });
       
-      await app.run(["--detailed-logs", "test"]);
+      await app.runFromArgs(["--detailed-logs", "test"]);
       // Should not throw - flag is recognized
       expect(cmd.executedWith).not.toBeNull();
     });
@@ -405,7 +424,7 @@ describe("Application", () => {
         commands: [cmd],
       });
       
-      await app.run(["--no-detailed-logs", "test"]);
+      await app.runFromArgs(["--no-detailed-logs", "test"]);
       // Should not throw - flag is recognized
       expect(cmd.executedWith).not.toBeNull();
     });
@@ -418,8 +437,8 @@ describe("Application", () => {
         commands: [cmd],
       });
       
-      await app.run(["--log-level=warn", "test"]);
-      expect(app.context.logger.getMinLevel()).toBe(4); // Warn = 4
+      await app.runFromArgs(["--log-level=warn", "test"]);
+      expect(AppContext.current.logger.getMinLevel()).toBe(LogLevel.warn);
     });
   });
 });

package/src/__tests__/buildCliCommand.test.ts

@@ -1,125 +1,105 @@
-import { describe, test, expect } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import { buildCliCommand } from "../tui/utils/buildCliCommand.ts";
 import type { OptionSchema } from "../types/command.ts";
 
 describe("buildCliCommand", () => {
-    test("builds command with no options", () => {
-        const result = buildCliCommand("myapp", ["run"], {}, {});
-        expect(result).toBe("myapp run");
-    });
+  test("builds CLI commands from schema + values", () => {
+    const cases: Array<{
+      name: string;
+      commandPath: string[];
+      schema: OptionSchema;
+      values: Record<string, unknown>;
+      expected: string;
+    }> = [
+      {
+        name: "no options",
+        commandPath: ["run"],
+        schema: {},
+        values: {},
+        expected: "myapp run --mode cli",
+      },
+      {
+        name: "string option",
+        commandPath: ["greet"],
+        schema: { name: { type: "string", description: "Name" } },
+        values: { name: "John" },
+        expected: "myapp greet --name John --mode cli",
+      },
+      {
+        name: "quotes strings with spaces",
+        commandPath: ["greet"],
+        schema: { name: { type: "string", description: "Name" } },
+        values: { name: "John Doe" },
+        expected: "myapp greet --name \"John Doe\" --mode cli",
+      },
+      {
+        name: "skips empty/undefined/null",
+        commandPath: ["run"],
+        schema: {
+          name: { type: "string", description: "Name" },
+          count: { type: "number", description: "Count" },
+        },
+        values: { name: "", count: null },
+        expected: "myapp run --mode cli",
+      },
+      {
+        name: "boolean flags only when needed",
+        commandPath: ["run"],
+        schema: {
+          verbose: { type: "boolean", description: "Verbose" },
+          quiet: { type: "boolean", description: "Quiet" },
+        },
+        values: { verbose: true, quiet: false },
+        expected: "myapp run --verbose --mode cli",
+      },
+      {
+        name: "number values",
+        commandPath: ["process"],
+        schema: { count: { type: "number", description: "Count" } },
+        values: { count: 42 },
+        expected: "myapp process --count 42 --mode cli",
+      },
+      {
+        name: "array values",
+        commandPath: ["process"],
+        schema: { files: { type: "array", description: "Files" } },
+        values: { files: ["a.txt", "b.txt"] },
+        expected: "myapp process --files a.txt --files b.txt --mode cli",
+      },
+      {
+        name: "nested command path",
+        commandPath: ["db", "migrate"],
+        schema: { force: { type: "boolean", description: "Force" } },
+        values: { force: true },
+        expected: "myapp db migrate --force --mode cli",
+      },
+      {
+        name: "camelCase to kebab-case",
+        commandPath: ["build"],
+        schema: {
+          outputDir: { type: "string", description: "Output directory" },
+          maxRetries: { type: "number", description: "Max retries" },
+        },
+        values: { outputDir: "/tmp", maxRetries: 3 },
+        expected: "myapp build --output-dir /tmp --max-retries 3 --mode cli",
+      },
+      {
+        name: "skips defaults and uses --no- for booleans",
+        commandPath: ["run"],
+        schema: {
+          verbose: { type: "boolean", description: "Verbose", default: false },
+          count: { type: "number", description: "Count", default: 10 },
+          color: { type: "boolean", description: "Color output", default: true },
+        },
+        values: { verbose: false, count: 10, color: false },
+        expected: "myapp run --no-color --mode cli",
+      },
+    ];
 
-    test("includes string options", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-        };
-        const values = { name: "John" };
-        
-        const result = buildCliCommand("myapp", ["greet"], schema, values);
-        expect(result).toBe("myapp greet --name John");
-    });
-
-    test("quotes string values with spaces", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-        };
-        const values = { name: "John Doe" };
-        
-        const result = buildCliCommand("myapp", ["greet"], schema, values);
-        expect(result).toBe("myapp greet --name \"John Doe\"");
-    });
-
-    test("excludes empty string values", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-        };
-        const values = { name: "" };
-        
-        const result = buildCliCommand("myapp", ["greet"], schema, values);
-        expect(result).toBe("myapp greet");
-    });
-
-    test("includes boolean flags only when true", () => {
-        const schema: OptionSchema = {
-            verbose: { type: "boolean", description: "Verbose" },
-            quiet: { type: "boolean", description: "Quiet" },
-        };
-        const values = { verbose: true, quiet: false };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run --verbose");
-    });
-
-    test("includes number values", () => {
-        const schema: OptionSchema = {
-            count: { type: "number", description: "Count" },
-        };
-        const values = { count: 42 };
-        
-        const result = buildCliCommand("myapp", ["process"], schema, values);
-        expect(result).toBe("myapp process --count 42");
-    });
-
-    test("excludes undefined and null values", () => {
-        const schema: OptionSchema = {
-            name: { type: "string", description: "Name" },
-            count: { type: "number", description: "Count" },
-        };
-        const values = { name: undefined, count: null };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run");
-    });
-
-    test("handles array values", () => {
-        const schema: OptionSchema = {
-            files: { type: "array", description: "Files" },
-        };
-        const values = { files: ["a.txt", "b.txt"] };
-        
-        const result = buildCliCommand("myapp", ["process"], schema, values);
-        expect(result).toBe("myapp process --files a.txt --files b.txt");
-    });
-
-    test("handles nested command path", () => {
-        const schema: OptionSchema = {
-            force: { type: "boolean", description: "Force" },
-        };
-        const values = { force: true };
-        
-        const result = buildCliCommand("myapp", ["db", "migrate"], schema, values);
-        expect(result).toBe("myapp db migrate --force");
-    });
-
-    test("converts camelCase to kebab-case", () => {
-        const schema: OptionSchema = {
-            outputDir: { type: "string", description: "Output directory" },
-            maxRetries: { type: "number", description: "Max retries" },
-        };
-        const values = { outputDir: "/tmp", maxRetries: 3 };
-        
-        const result = buildCliCommand("myapp", ["build"], schema, values);
-        expect(result).toContain("--output-dir /tmp");
-        expect(result).toContain("--max-retries 3");
-    });
-
-    test("skips values that match defaults", () => {
-        const schema: OptionSchema = {
-            verbose: { type: "boolean", description: "Verbose", default: false },
-            count: { type: "number", description: "Count", default: 10 },
-        };
-        const values = { verbose: false, count: 10 };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run");
-    });
-
-    test("uses --no-flag for false when default is true", () => {
-        const schema: OptionSchema = {
-            color: { type: "boolean", description: "Color output", default: true },
-        };
-        const values = { color: false };
-        
-        const result = buildCliCommand("myapp", ["run"], schema, values);
-        expect(result).toBe("myapp run --no-color");
-    });
+    for (const c of cases) {
+      expect(buildCliCommand("myapp", c.commandPath, c.schema, c.values), c.name).toBe(
+        c.expected
+      );
+    }
+  });
 });