@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.1

package/src/util/envVarHelper.ts

@@ -21,7 +21,7 @@ import type ComplexOption from "../api/argument/ComplexOption.ts";
 
 function getKeySegment(segment: string) {
   let keySegment = segment.replace("-", "_").toUpperCase();
-  if (keySegment[0].match(/[0-9]/)) {
+  if (keySegment[0]!.match(/[0-9]/)) {
     keySegment = `_${keySegment}`;
   }
   return keySegment;
@@ -152,7 +152,7 @@ function getOptionValuesFromEnvVars(
               getOptionValuesFromEnvVars(
                 (envVarValues[option.name] as Array<PopulatedArgumentValues>)[
                   index
-                ],
+                ]!,
                 matches,
                 env,
                 property,

package/src/util/helpHelper.ts

@@ -21,12 +21,12 @@ import type CLIConfig from "../api/CLIConfig.ts";
 import type PrinterService from "../api/service/core/PrinterService.ts";
 import type SubCommandArgument from "../api/argument/SubCommandArgument.ts";
 import type ComplexOption from "../api/argument/ComplexOption.ts";
+import type TableGeneratorService from "../api/service/core/TableGeneratorService.ts";
+import Table from "../api/service/core/Table.ts";
 
 const SYNTAX_INDENT_WIDTH = 2;
-const SYNTAX_MIN_PADDING_WIDTH = 2;
 const MINIMUM_SYNTAX_COLUMN_WIDTH = 15;
 const HELP_SYNTAX_INDENT = " ".repeat(SYNTAX_INDENT_WIDTH);
-const HELP_SYNTAX_PADDING = " ".repeat(SYNTAX_MIN_PADDING_WIDTH);
 
 export interface HelpEntry {
   readonly syntax: string;
@@ -40,169 +40,113 @@ export interface HelpSection {
   readonly helpEntries: Array<HelpEntry>;
 }
 
-async function printSingleHelpEntry(
+interface FlattenedRow {
+  syntax: string;
+  description?: string;
+}
+
+function flattenHelpEntry(
   printerService: PrinterService,
   helpEntry: HelpEntry,
-  syntaxWidth: number,
   indentText: string,
   isRoot: boolean,
   isLastSibling: boolean,
-): Promise<void> {
-  let text = "";
-  const notesIndent = syntaxWidth;
-  let syntaxTreeChars = "";
-  let totalSyntaxLength = 0;
-
+  rows: FlattenedRow[],
+): void {
+  let syntax = "";
   if (helpEntry.syntax) {
     if (isRoot) {
-      text += HELP_SYNTAX_INDENT + printerService.primary(helpEntry.syntax);
-      totalSyntaxLength = SYNTAX_INDENT_WIDTH + helpEntry.syntax.length;
+      syntax = HELP_SYNTAX_INDENT + printerService.primary(helpEntry.syntax);
     } else {
+      let syntaxTreeChars = "";
       if (indentText.length > 0) {
         syntaxTreeChars = isLastSibling ? "└╴" : "├╴";
       }
-      text += HELP_SYNTAX_INDENT +
+      syntax = HELP_SYNTAX_INDENT +
         printerService.secondary(indentText + syntaxTreeChars) +
         printerService.primary(helpEntry.syntax);
-      totalSyntaxLength = SYNTAX_INDENT_WIDTH + indentText.length +
-        syntaxTreeChars.length + helpEntry.syntax.length;
-    }
-  }
-  if (helpEntry.description) {
-    if (helpEntry.syntax) {
-      if (totalSyntaxLength > notesIndent) {
-        text += HELP_SYNTAX_PADDING +
-          printerService.secondary(helpEntry.description);
-      } else {
-        text += " ".repeat(syntaxWidth - totalSyntaxLength) +
-          printerService.secondary(helpEntry.description);
-      }
-    } else {
-      text += HELP_SYNTAX_PADDING +
-        printerService.secondary(helpEntry.description);
     }
   }
-  text += "\n";
-  await printerService.print(text);
-}
 
-async function printHelpEntry(
-  printerService: PrinterService,
-  helpEntry: HelpEntry,
-  syntaxWidth: number,
-  indentText: string,
-  isRoot: boolean,
-  hasChildren: boolean,
-  isLastSibling: boolean,
-): Promise<void> {
-  if (hasChildren) {
-    await printSingleHelpEntry(
-      printerService,
-      helpEntry,
-      syntaxWidth,
-      indentText,
-      isRoot,
-      isLastSibling,
-    );
-    indentText += (isLastSibling ? "  " : "│ ") +
+  const description = helpEntry.description
+    ? printerService.secondary(helpEntry.description)
+    : undefined;
+
+  rows.push({ syntax, description });
+
+  if (helpEntry.helpSubEntries !== undefined) {
+    const nextIndent = indentText +
+      (isLastSibling ? "  " : "│ ") +
       " ".repeat(helpEntry.subEntryIndent || 0);
-    for (let i = 0; i < helpEntry.helpSubEntries!.length; i++) {
-      const helpSubEntry = helpEntry.helpSubEntries![i];
-      const helpSubEntryHasChildren = helpSubEntry.helpSubEntries !== undefined;
-      const helpSubEntryIsLastSibling =
-        i === helpEntry.helpSubEntries!.length - 1;
-      await printHelpEntry(
+    for (let i = 0; i < helpEntry.helpSubEntries.length; i++) {
+      const sub = helpEntry.helpSubEntries[i]!;
+      flattenHelpEntry(
         printerService,
-        helpSubEntry,
-        syntaxWidth,
-        indentText,
+        sub,
+        nextIndent,
         false,
-        helpSubEntryHasChildren,
-        helpSubEntryIsLastSibling,
+        i === helpEntry.helpSubEntries.length - 1,
+        rows,
       );
     }
-  } else {
-    await printSingleHelpEntry(
-      printerService,
-      helpEntry,
-      syntaxWidth,
-      indentText,
-      isRoot,
-      isLastSibling,
-    );
-  }
-}
-
-function getSyntaxWidth(helpEntry: HelpEntry, indent: number): number {
-  if (
-    (helpEntry.helpSubEntries === undefined) ||
-    (helpEntry.helpSubEntries.length === 0)
-  ) {
-    // 2 is for the tree characters
-    let finalWidth = SYNTAX_INDENT_WIDTH + indent + 2 +
-      SYNTAX_MIN_PADDING_WIDTH;
-    if (helpEntry.syntax) {
-      finalWidth += helpEntry.syntax.length;
-    }
-    return finalWidth;
   }
-  let maxSubIndent = 0;
-  helpEntry.helpSubEntries.forEach((helpSubEntry) => {
-    // 2 is for the tree characters
-    const subEntryWidth = getSyntaxWidth(
-      helpSubEntry,
-      (helpEntry.subEntryIndent ? helpEntry.subEntryIndent : 0) + 2,
-    );
-    if (subEntryWidth > maxSubIndent) {
-      maxSubIndent = subEntryWidth;
-    }
-  });
-  return indent + maxSubIndent;
 }
 
 export async function printHelpSections(
   printerService: PrinterService,
+  tableGeneratorService: TableGeneratorService,
   sections: Array<HelpSection>,
 ): Promise<void> {
-  // calculate alignment
-  let syntaxWidth = SYNTAX_INDENT_WIDTH + MINIMUM_SYNTAX_COLUMN_WIDTH +
-    SYNTAX_MIN_PADDING_WIDTH;
-  sections.forEach((section) => {
-    section.helpEntries.forEach((helpEntry) => {
-      const entrySyntaxWidth = getSyntaxWidth(helpEntry, 0);
-      // don't expand out if no description as we can overwrite that space on the line
-      if (
-        helpEntry.description && (helpEntry.description.length > 0) &&
-        (entrySyntaxWidth > syntaxWidth)
-      ) {
-        syntaxWidth = entrySyntaxWidth;
-      }
-    });
-  });
+  const terminalWidth = printerService.stdoutColumns();
 
-  // print the help
   for (let i = 0; i < sections.length; i++) {
-    const section = sections[i];
+    const section = sections[i]!;
     if (section.title.length > 0) {
       await printerService.print(
         `${printerService.emphasised(section.title)}\n\n`,
       );
     }
-    for (let j = 0; j < section.helpEntries.length; j++) {
-      const helpEntry = section.helpEntries[j];
-      await printHelpEntry(
+
+    if (section.helpEntries.length === 0) continue;
+
+    const rows: FlattenedRow[] = [];
+    for (const helpEntry of section.helpEntries) {
+      flattenHelpEntry(
         printerService,
         helpEntry,
-        syntaxWidth,
         "",
         true,
-        helpEntry.helpSubEntries !== undefined,
         true,
+        rows,
       );
     }
-    if (section.helpEntries.length > 0) {
-      await printerService.print("\n");
+
+    const hasDescriptions = rows.some((r) => r.description !== undefined);
+
+    if (hasDescriptions) {
+      const table = new Table(rows.length, 2, {
+        border: false,
+        padding: 1,
+        maxWidth: terminalWidth,
+      });
+      table.column(0, { minWidth: MINIMUM_SYNTAX_COLUMN_WIDTH });
+      table.column(1, { flexWeight: 1 });
+
+      for (let r = 0; r < rows.length; r++) {
+        const row = rows[r]!;
+        table.cell(r, 0, row.syntax);
+        table.cell(r, 1, row.description ?? "");
+      }
+
+      const rendered = tableGeneratorService.render(table);
+      await printerService.print(rendered + "\n");
+    } else {
+      for (const row of rows) {
+        await printerService.print(row.syntax + "\n");
+      }
     }
+
+    await printerService.print("\n");
   }
 }
 

package/src/util/logger.ts

@@ -86,9 +86,11 @@ function wrapDefaultLogger(
  * @returns A logger instance with the specified name.
  */
 export default function getLogger(loggerName: string): Logger {
-  if (globalThis.defaultLogger === undefined) {
-    globalThis.defaultLogger = getDefaultLogger();
+  const g = globalThis as Record<string, unknown>;
+  if (g.defaultLogger === undefined) {
+    g.defaultLogger = getDefaultLogger();
   }
+  const defaultLogger = g.defaultLogger as Logger;
 
   if (loggerName.length > maxLoggerNameLength) {
     maxLoggerNameLength = loggerName.length;
@@ -108,28 +110,28 @@ export default function getLogger(loggerName: string): Logger {
     return {
       trace: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.TRACE,
-        globalThis.defaultLogger.trace,
+        LEVEL_PADDINGS.TRACE!,
+        defaultLogger.trace,
       ),
       debug: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.DEBUG,
-        globalThis.defaultLogger.debug,
+        LEVEL_PADDINGS.DEBUG!,
+        defaultLogger.debug,
       ),
       info: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.INFO,
-        globalThis.defaultLogger.info,
+        LEVEL_PADDINGS.INFO!,
+        defaultLogger.info,
       ),
       warn: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.WARN,
-        globalThis.defaultLogger.warn,
+        LEVEL_PADDINGS.WARN!,
+        defaultLogger.warn,
       ),
       error: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.ERROR,
-        globalThis.defaultLogger.error,
+        LEVEL_PADDINGS.ERROR!,
+        defaultLogger.error,
       ),
     };
   }
@@ -140,8 +142,8 @@ export default function getLogger(loggerName: string): Logger {
     warn: () => {},
     error: wrapDefaultLogger(
       loggerName,
-      LEVEL_PADDINGS.ERROR,
-      globalThis.defaultLogger.error,
+      LEVEL_PADDINGS.ERROR!,
+      defaultLogger.error,
     ),
   };
 }

package/src/util/runnerHelper.ts

@@ -10,7 +10,7 @@ import {
 } from "../runtime/command/CommandTypeGuards.ts";
 import type Context from "../api/Context.ts";
 import { getInvalidArgumentString } from "../runtime/values/argumentValueValidation.ts";
-import CommandRegistry from "../runtime/registry/CommandRegistry.ts";
+import type CommandRegistry from "../runtime/registry/CommandRegistry.ts";
 import { findPossibleCommandNames } from "./helpHelper.ts";
 
 function getCommandString(

package/tests/cli/BaseCLI.test.ts

@@ -23,24 +23,31 @@ import type Context from "../../src/api/Context.ts";
 import type CLIConfig from "../../src/api/CLIConfig.ts";
 import StreamString from "../fixtures/StreamString.ts";
 import { expectStringEquals, expectStringIncludes } from "../fixtures/util.ts";
-import TtyTerminal from "../../src/service/printer/terminal/TtyTerminal.ts";
-import TtyStyler from "../../src/service/printer/terminal/TtyStyler.ts";
+import TtyTerminal from "../../src/terminal/TtyTerminal.ts";
+import TtyStyler from "../../src/terminal/TtyStyler.ts";
+import type KeyReader from "../../src/terminal/KeyReader.ts";
+
+const mockKeyReader: KeyReader = {
+  enableRawMode() {},
+  disableRawMode() {},
+  readKey: () => Promise.resolve({}),
+};
 
 describe("BaseCLI tests", () => {
   test("BaseCLI no command specified works", async () => {
     const config = getCLIConfig();
     const dummyStdout = new StreamString();
     const dummyStderr = new StreamString();
-    const terminal = new TtyTerminal(dummyStdout.writeStream);
     const baseCLI = new BaseCLI(
       config,
       dummyStdout.writableStream,
       dummyStderr.writableStream,
       false,
       false,
-      terminal,
+      new TtyTerminal(dummyStdout.writeStream),
+      new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
-      false,
+      mockKeyReader,
     );
 
     baseCLI.addCommand(getSubCommandWithOptionAndPositional());
@@ -54,16 +61,16 @@ describe("BaseCLI tests", () => {
     const config = getCLIConfig();
     const dummyStdout = new StreamString();
     const dummyStderr = new StreamString();
-    const terminal = new TtyTerminal(dummyStderr.writeStream);
     const baseCLI = new BaseCLI(
       config,
       dummyStdout.writableStream,
       dummyStderr.writableStream,
       false,
       false,
-      terminal,
+      new TtyTerminal(dummyStdout.writeStream),
+      new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
-      false,
+      mockKeyReader,
     );
 
     let modifierHasRun = false;
@@ -122,11 +129,14 @@ describe("BaseCLI tests", () => {
       dummyStderr.writableStream,
       false,
       false,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
-      false,
-      true,
-      true,
+      mockKeyReader,
+      {
+        configFileSupportEnabled: true,
+        keyValueServiceEnabled: true,
+      },
     );
 
     let serviceProvider1Initialised = false;
@@ -140,21 +150,20 @@ describe("BaseCLI tests", () => {
     const SERVICE_2 = "service2";
 
     interface ServiceInterface {
-      serviceMethod(context: Context): void;
+      serviceMethod(context: Context): Promise<void>;
     }
 
     class DefaultService1 implements ServiceInterface {
       copyOfKeyValueService: KeyValueService | undefined;
 
-      serviceMethod(context: Context): void {
-        // should only have access to the modifierCommand KV scope
-        expect(this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
+      async serviceMethod(context: Context): Promise<void> {
+        expect(await this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
         expect(
-          this.copyOfKeyValueService!.getKey("name"),
+          await this.copyOfKeyValueService!.getKey("name"),
         ).toEqual(
           "modifierCommand",
         );
-        this.copyOfKeyValueService!.setKey(
+        await this.copyOfKeyValueService!.setKey(
           "name",
           "defaultService1+modifierCommand",
         );
@@ -163,10 +172,9 @@ describe("BaseCLI tests", () => {
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the modifierCommand KV scope
-        expect(keyValueService.hasKey("name")).toBeTrue();
+        expect(await keyValueService.hasKey("name")).toBeTrue();
         expect(
-          this.copyOfKeyValueService!.getKey("name"),
+          await this.copyOfKeyValueService!.getKey("name"),
         ).toEqual(
           "defaultService1+modifierCommand",
         );
@@ -178,13 +186,12 @@ describe("BaseCLI tests", () => {
     class DefaultService2 implements ServiceInterface {
       copyOfKeyValueService: KeyValueService | undefined;
 
-      serviceMethod(context: Context): void {
-        // should only have access to the modifierCommand KV scope
-        expect(this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
-        expect(this.copyOfKeyValueService!.getKey("name")).toEqual(
+      async serviceMethod(context: Context): Promise<void> {
+        expect(await this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
+        expect(await this.copyOfKeyValueService!.getKey("name")).toEqual(
           "subCommand",
         );
-        this.copyOfKeyValueService!.setKey(
+        await this.copyOfKeyValueService!.setKey(
           "name",
           "defaultService2+subCommand",
         );
@@ -193,10 +200,9 @@ describe("BaseCLI tests", () => {
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the subCommand KV scope
-        expect(keyValueService.hasKey("name")).toBeTrue();
+        expect(await keyValueService.hasKey("name")).toBeTrue();
         expect(
-          this.copyOfKeyValueService!.getKey("name"),
+          await this.copyOfKeyValueService!.getKey("name"),
         ).toEqual(
           "defaultService2+subCommand",
         );
@@ -211,7 +217,7 @@ describe("BaseCLI tests", () => {
 
       defaultService1: DefaultService1 | undefined;
 
-      provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+      getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
         this.defaultService1 = new DefaultService1();
         return Promise.resolve({
           service: this.defaultService1,
@@ -219,20 +225,17 @@ describe("BaseCLI tests", () => {
         });
       }
 
-      initService(context: Context): Promise<void> {
+      async initService(context: Context): Promise<void> {
         const keyValueService = context.getServiceById(
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the ServiceProvider1 KV scope
-        expect(keyValueService.hasKey("name")).toBeFalse();
-        keyValueService.setKey("name", "defaultService2");
+        expect(await keyValueService.hasKey("name")).toBeFalse();
+        await keyValueService.setKey("name", "defaultService2");
 
-        // take a copy to check later when service is accessed via a command
         this.defaultService1!.copyOfKeyValueService = keyValueService;
 
         serviceProvider1Initialised = true;
-        return Promise.resolve(undefined);
       }
     }
 
@@ -242,7 +245,7 @@ describe("BaseCLI tests", () => {
 
       defaultService2: DefaultService2 | undefined;
 
-      provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+      getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
         this.defaultService2 = new DefaultService2();
         return Promise.resolve({
           service: this.defaultService2,
@@ -250,20 +253,17 @@ describe("BaseCLI tests", () => {
         });
       }
 
-      initService(context: Context): Promise<void> {
+      async initService(context: Context): Promise<void> {
         const keyValueService = context.getServiceById(
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the ServiceProvider2 KV scope
-        expect(keyValueService.hasKey("name")).toBeFalse();
-        keyValueService.setKey("name", "defaultService2");
+        expect(await keyValueService.hasKey("name")).toBeFalse();
+        await keyValueService.setKey("name", "defaultService2");
 
-        // take a copy to check later when service is accessed via a command
         this.defaultService2!.copyOfKeyValueService = keyValueService;
 
         serviceProvider2Initialised = true;
-        return Promise.resolve(undefined);
       }
     }
 
@@ -282,37 +282,33 @@ describe("BaseCLI tests", () => {
     };
     const subCommand = getSubCommand("command", [option], []);
 
-    modifierCommand.execute = (context): Promise<void> => {
+    modifierCommand.execute = async (context): Promise<void> => {
       const keyValueService = context.getServiceById(
         KEY_VALUE_SERVICE_ID,
       ) as KeyValueService;
 
-      // should only have access to the modifierCommand KV scope
-      expect(keyValueService.hasKey("name")).toBeFalse();
-      keyValueService.setKey("name", "modifierCommand");
+      expect(await keyValueService.hasKey("name")).toBeFalse();
+      await keyValueService.setKey("name", "modifierCommand");
 
       const service1 = context.getServiceById(SERVICE_1) as ServiceInterface;
 
-      service1.serviceMethod(context);
+      await service1.serviceMethod(context);
 
       modifierHasRun = true;
-      return Promise.resolve();
     };
-    subCommand.execute = (context): Promise<void> => {
+    subCommand.execute = async (context): Promise<void> => {
       const keyValueService = context.getServiceById(
         KEY_VALUE_SERVICE_ID,
       ) as KeyValueService;
 
-      // should only have access to the subCommand KV scope
-      expect(keyValueService.hasKey("name")).toBeFalse();
-      keyValueService.setKey("name", "subCommand");
+      expect(await keyValueService.hasKey("name")).toBeFalse();
+      await keyValueService.setKey("name", "subCommand");
 
       const service2 = context.getServiceById(SERVICE_2) as ServiceInterface;
 
-      service2.serviceMethod(context);
+      await service2.serviceMethod(context);
 
       subHasRun = true;
-      return Promise.resolve();
     };
 
     baseCLI.addServiceProvider(new ServiceProvider1());

package/tests/command/CompletionCommand.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import {
+  CompletionCompleteSubCommand,
+  CompletionGroupCommand,
+  CompletionIntegrationSubCommand,
+} from "../../src/command/CompletionCommand.ts";
+
+describe("CompletionIntegrationSubCommand", () => {
+  test("has correct name", () => {
+    const cmd = new CompletionIntegrationSubCommand();
+    expect(cmd.name).toEqual("integration");
+  });
+
+  test("has shell positional with allowable values", () => {
+    const cmd = new CompletionIntegrationSubCommand();
+    expect(cmd.positionals.length).toEqual(1);
+    expect(cmd.positionals[0]!.name).toEqual("shell");
+    expect(cmd.positionals[0]!.allowableValues).toEqual([
+      "bash",
+      "zsh",
+      "fish",
+      "powershell",
+    ]);
+  });
+
+  test("has optional config-path option", () => {
+    const cmd = new CompletionIntegrationSubCommand();
+    expect(cmd.options.length).toEqual(1);
+    expect(cmd.options[0]!.name).toEqual("config-path");
+    expect(cmd.options[0]!.isOptional).toEqual(true);
+  });
+});
+
+describe("CompletionCompleteSubCommand", () => {
+  test("has correct name", () => {
+    const cmd = new CompletionCompleteSubCommand();
+    expect(cmd.name).toEqual("complete");
+  });
+
+  test("has shell positional and vararg args positional", () => {
+    const cmd = new CompletionCompleteSubCommand();
+    expect(cmd.positionals.length).toEqual(2);
+    expect(cmd.positionals[0]!.name).toEqual("shell");
+    expect(cmd.positionals[1]!.name).toEqual("args");
+    expect(cmd.positionals[1]!.isVarargMultiple).toEqual(true);
+    expect(cmd.positionals[1]!.isVarargOptional).toEqual(true);
+  });
+});
+
+describe("CompletionGroupCommand", () => {
+  test("has correct name", () => {
+    const cmd = new CompletionGroupCommand(
+      new CompletionIntegrationSubCommand(),
+      new CompletionCompleteSubCommand(),
+    );
+    expect(cmd.name).toEqual("completions");
+  });
+
+  test("has two member sub-commands", () => {
+    const cmd = new CompletionGroupCommand(
+      new CompletionIntegrationSubCommand(),
+      new CompletionCompleteSubCommand(),
+    );
+    expect(cmd.memberSubCommands.length).toEqual(2);
+    expect(cmd.memberSubCommands[0]!.name).toEqual("integration");
+    expect(cmd.memberSubCommands[1]!.name).toEqual("complete");
+  });
+});

package/tests/command/UsageCommand.test.ts

@@ -9,8 +9,8 @@ import type Context from "../../src/api/Context.ts";
 import type Command from "../../src/api/command/Command.ts";
 import StreamString from "../fixtures/StreamString.ts";
 import { expectStringEquals } from "../fixtures/util.ts";
-import TtyTerminal from "../../src/service/printer/terminal/TtyTerminal.ts";
-import TtyStyler from "../../src/service/printer/terminal/TtyStyler.ts";
+import TtyTerminal from "../../src/terminal/TtyTerminal.ts";
+import TtyStyler from "../../src/terminal/TtyStyler.ts";
 
 describe("UsageCommand tests", () => {
   test("Usage works", async () => {
@@ -21,6 +21,7 @@ describe("UsageCommand tests", () => {
       dummyStderr.writableStream,
       true,
       true,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
     );