@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.1

package/tests/service/prompter/command/NoPromptCommand.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+import NoPromptCommand from "../../../../src/service/prompter/command/NoPromptCommand.ts";
+import PrompterServiceProvider from "../../../../src/service/prompter/PrompterServiceProvider.ts";
+import { ArgumentValueTypeName } from "../../../../src/api/argument/ArgumentValueTypes.ts";
+import type PrompterService from "../../../../src/api/service/core/PrompterService.ts";
+import type Context from "../../../../src/api/Context.ts";
+
+function getMockPrompterService(): PrompterService {
+  return {
+    promptEnabled: true,
+    prompt: () => Promise.resolve({ name: "", value: "" }),
+    promptAll: () => Promise.resolve([]),
+  };
+}
+
+describe("NoPromptCommand tests", () => {
+  test("NoPromptCommand has correct properties", () => {
+    const prompterService = getMockPrompterService();
+    const provider = new PrompterServiceProvider(100, prompterService);
+    const command = new NoPromptCommand(provider, 100);
+
+    expect(command.name).toEqual("no-prompt");
+    expect(command.description).toEqual("Disable interactive prompting");
+    expect(command.enableConfiguration).toBeTrue();
+    expect(command.executePriority).toEqual(100);
+  });
+
+  test("NoPromptCommand has correct argument", () => {
+    const prompterService = getMockPrompterService();
+    const provider = new PrompterServiceProvider(100, prompterService);
+    const command = new NoPromptCommand(provider, 100);
+
+    expect(command.argument.type).toEqual(ArgumentValueTypeName.BOOLEAN);
+    expect(command.argument.defaultValue).toEqual(false);
+    expect(command.argument.configurationKey).toEqual("NO_PROMPT");
+  });
+
+  test("NoPromptCommand execute with true disables prompting", async () => {
+    const prompterService = getMockPrompterService();
+    const provider = new PrompterServiceProvider(100, prompterService);
+    const command = new NoPromptCommand(provider, 100);
+
+    await command.execute({} as Context, true);
+
+    expect(provider.prompterService.promptEnabled).toBeFalse();
+  });
+
+  test("NoPromptCommand execute with false enables prompting", async () => {
+    const prompterService = getMockPrompterService();
+    prompterService.promptEnabled = false;
+    const provider = new PrompterServiceProvider(100, prompterService);
+    const command = new NoPromptCommand(provider, 100);
+
+    await command.execute({} as Context, false);
+
+    expect(provider.prompterService.promptEnabled).toBeTrue();
+  });
+});

package/tests/service/shutdown/ShutdownServiceProvider.test.ts

@@ -3,9 +3,11 @@ import ShutdownServiceProvider from "../../../src/service/shutdown/ShutdownServi
 import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
 
 describe("ShutdownServiceProvider tests", () => {
-  test("ShutdownServiceProvider provide works", async () => {
+  test("ShutdownServiceProvider getServiceInfo works", async () => {
     const shutdownServiceProvider = new ShutdownServiceProvider(100);
-    const serviceInfo = await shutdownServiceProvider.provide(getCLIConfig());
+    const serviceInfo = await shutdownServiceProvider.getServiceInfo(
+      getCLIConfig(),
+    );
     expect(serviceInfo.commands.length).toEqual(0);
 
     await ShutdownServiceProvider.shutdown();

package/tests/service/syntaxHighlighter/DefaultSyntaxHighlighterService.test.ts

@@ -3,8 +3,8 @@ import { expectBytesEquals } from "../../fixtures/util.ts";
 import DefaultSyntaxHighlighterService from "../../../src/service/syntaxHighlighter/DefaultSyntaxHighlighterService.ts";
 import yaml from "highlight.js/lib/languages/yaml";
 import DefaultPrinterService from "../../../src/service/printer/DefaultPrinterService.ts";
-import TtyStyler from "../../../src/service/printer/terminal/TtyStyler.ts";
-import TtyTerminal from "../../../src/service/printer/terminal/TtyTerminal.ts";
+import TtyStyler from "../../../src/terminal/TtyStyler.ts";
+import TtyTerminal from "../../../src/terminal/TtyTerminal.ts";
 import StreamString from "../../fixtures/StreamString.ts";
 
 describe("DefaultSyntaxHighlighterService tests", () => {
@@ -80,6 +80,7 @@ describe("DefaultSyntaxHighlighterService tests", () => {
       dummyStderr.writableStream,
       true,
       true,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
     );

package/tests/service/syntaxHighlighter/SyntaxHighlighterServiceProvider.test.ts

@@ -5,11 +5,11 @@ import SyntaxHighlighterServiceProvider from "../../../src/service/syntaxHighlig
 import { PRINTER_SERVICE_ID } from "../../../src/api/service/core/PrinterService.ts";
 import DefaultPrinterService from "../../../src/service/printer/DefaultPrinterService.ts";
 import StreamString from "../../fixtures/StreamString.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("SyntaxHighlighterServiceProvider tests", () => {
-  test("SyntaxHighlighterServiceProvider provide and initService works", async () => {
+  test("SyntaxHighlighterServiceProvider getServiceInfo and initService works", async () => {
     const dummyStdout = new StreamString();
     const dummyStderr = new StreamString();
     const syntaxHighlighterServiceProvider =
@@ -26,12 +26,13 @@ describe("SyntaxHighlighterServiceProvider tests", () => {
         dummyStderr.writableStream,
         true,
         true,
+        new TtyTerminal(dummyStdout.writeStream),
         new TtyTerminal(dummyStderr.writeStream),
         new TtyStyler(3),
       ),
     );
 
-    const serviceInfo = await syntaxHighlighterServiceProvider.provide(
+    const serviceInfo = await syntaxHighlighterServiceProvider.getServiceInfo(
       cliConfig,
     );
     expect(serviceInfo.commands.length).toEqual(0);

package/tests/service/tableGenerator/DefaultTableGeneratorService.test.ts

@@ -0,0 +1,363 @@
+import { describe, expect, test } from "bun:test";
+import DefaultTableGeneratorService from "../../../src/service/tableGenerator/DefaultTableGeneratorService.ts";
+import Table from "../../../src/api/service/core/Table.ts";
+import { Align } from "../../../src/api/service/core/TableGeneratorService.ts";
+
+describe("DefaultTableGeneratorService tests", () => {
+  function createService(): DefaultTableGeneratorService {
+    const service = new DefaultTableGeneratorService();
+    service.colorEnabled = false;
+    return service;
+  }
+
+  test("2x2 table with border renders correct box-drawing chars", () => {
+    const service = createService();
+    const table = new Table(2, 2, { maxWidth: 20, padding: 1 })
+      .cell(0, 0, "A")
+      .cell(0, 1, "B")
+      .cell(1, 0, "C")
+      .cell(1, 1, "D");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+
+    // Top border
+    expect(lines[0]).toMatch(/^┌─+┬─+┐$/);
+    // Content rows have │ separators
+    expect(lines[1]).toMatch(/^│.*│.*│$/);
+    // Middle border
+    expect(lines[2]).toMatch(/^├─+┼─+┤$/);
+    // Bottom border
+    expect(lines[4]).toMatch(/^└─+┴─+┘$/);
+  });
+
+  test("2x2 table without border renders space-separated columns", () => {
+    const service = createService();
+    const table = new Table(2, 2, { border: false, maxWidth: 20, padding: 1 })
+      .cell(0, 0, "A")
+      .cell(0, 1, "B")
+      .cell(1, 0, "C")
+      .cell(1, 1, "D");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+
+    expect(lines.length).toBe(2);
+    // No box-drawing characters
+    expect(result).not.toContain("│");
+    expect(result).not.toContain("─");
+    // Content rows should contain the cell values with spacing
+    expect(lines[0]).toContain("A");
+    expect(lines[0]).toContain("B");
+    // Between columns there should be padding*2 = 2 spaces as separator
+    // Format: pad + content + pad + (padding*2 spaces) + pad + content + pad
+    expect(lines[0]).toMatch(/A\s+B/);
+  });
+
+  test("equal flex weights produce equal columns", () => {
+    const service = createService();
+    const table = new Table(1, 2, { maxWidth: 40, padding: 0 })
+      .column(0, { flexWeight: 1 })
+      .column(1, { flexWeight: 1 })
+      .cell(0, 0, "X")
+      .cell(0, 1, "Y");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    // With border, overhead = 3 (columnCount+1 = 3 border chars), padding = 0
+    // Content budget = 40 - 3 = 37
+    // Natural widths: 1 each = 2 total, surplus = 35
+    // Each flex col gets ~17-18 chars
+    // Find content row (second line)
+    const contentLine = lines[1]!;
+    // Extract the two cell widths from between │ chars
+    const parts = contentLine.split("│").filter((s) => s.length > 0);
+    expect(parts.length).toBe(2);
+    const diff = Math.abs(parts[0]!.length - parts[1]!.length);
+    expect(diff).toBeLessThanOrEqual(1);
+  });
+
+  test("flex weight 2:1 gives proportional distribution", () => {
+    const service = createService();
+    const table = new Table(1, 2, { maxWidth: 40, padding: 0 })
+      .column(0, { flexWeight: 2 })
+      .column(1, { flexWeight: 1 })
+      .cell(0, 0, "X")
+      .cell(0, 1, "Y");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    const contentLine = lines[1]!;
+    const parts = contentLine.split("│").filter((s) => s.length > 0);
+    expect(parts.length).toBe(2);
+    // Col 0 should be wider than col 1
+    expect(parts[0]!.length).toBeGreaterThan(parts[1]!.length);
+  });
+
+  test("minWidth prevents shrinking below minimum", () => {
+    const service = createService();
+    // Use a very small maxWidth to force shrinking
+    const table = new Table(1, 2, { maxWidth: 20, padding: 0 })
+      .column(0, { flexWeight: 1, minWidth: 8 })
+      .column(1, { flexWeight: 1 })
+      .cell(0, 0, "ABCDEFGHIJ")
+      .cell(0, 1, "ABCDEFGHIJ");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    const contentLine = lines[1]!;
+    const parts = contentLine.split("│").filter((s) => s.length > 0);
+    // Col 0 should be at least 8 wide
+    expect(parts[0]!.length).toBeGreaterThanOrEqual(8);
+  });
+
+  test("maxWidth caps column width", () => {
+    const service = createService();
+    const table = new Table(1, 2, { maxWidth: 80, padding: 0 })
+      .column(0, { flexWeight: 1, maxWidth: 5 })
+      .column(1, { flexWeight: 1 })
+      .cell(0, 0, "AB")
+      .cell(0, 1, "CD");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    const contentLine = lines[1]!;
+    const parts = contentLine.split("│").filter((s) => s.length > 0);
+    // Col 0 should not exceed maxWidth of 5
+    expect(parts[0]!.length).toBeLessThanOrEqual(5);
+  });
+
+  test("long text wraps at word boundaries", () => {
+    const service = createService();
+    // Column maxWidth=10 forces wrapping of "hello world foo bar"
+    const table = new Table(1, 1, { maxWidth: 20, padding: 1 })
+      .column(0, { maxWidth: 10 })
+      .cell(0, 0, "hello world foo bar");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    const contentLines = lines.filter((l) =>
+      l.startsWith("│") && !l.includes("─")
+    );
+    expect(contentLines.length).toBeGreaterThan(1);
+    // Each content line should have complete words (no mid-word breaks)
+    for (const line of contentLines) {
+      const content = line.replace(/│/g, "").trim();
+      if (content.length > 0) {
+        const words = content.split(/\s+/);
+        for (const word of words) {
+          expect(
+            ["hello", "world", "foo", "bar", ""].includes(word),
+          ).toBe(true);
+        }
+      }
+    }
+  });
+
+  test("single long word hard-breaks", () => {
+    const service = createService();
+    // Column maxWidth=5 forces hard break of "ABCDEFGHIJKLMNOP"
+    const table = new Table(1, 1, { maxWidth: 12, padding: 0 })
+      .column(0, { maxWidth: 5 })
+      .cell(0, 0, "ABCDEFGHIJKLMNOP");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    const contentLines = lines.filter((l) =>
+      l.startsWith("│") && !l.includes("─")
+    );
+    expect(contentLines.length).toBeGreaterThan(1);
+    // Verify all characters are present
+    const allContent = contentLines
+      .map((l) => l.replace(/│/g, "").replace(/ /g, ""))
+      .join("");
+    expect(allContent).toBe("ABCDEFGHIJKLMNOP");
+  });
+
+  test("LEFT/RIGHT/CENTER alignment produces correct padding", () => {
+    const service = createService();
+    // Use minWidth=10 to force column wider than content "AB" (2 chars)
+    // LEFT (default)
+    const tableL = new Table(1, 1, { maxWidth: 20, padding: 0 })
+      .column(0, { minWidth: 10 })
+      .cell(0, 0, "AB");
+    let result = service.render(tableL);
+    let contentLine = result.split("\n")[1]!;
+    let content = contentLine.slice(1, -1); // strip border chars
+    expect(content).toBe("AB" + " ".repeat(8));
+
+    // RIGHT
+    const tableR = new Table(1, 1, {
+      maxWidth: 20,
+      padding: 0,
+      align: Align.RIGHT,
+    })
+      .column(0, { minWidth: 10 })
+      .cell(0, 0, "AB");
+    result = service.render(tableR);
+    contentLine = result.split("\n")[1]!;
+    content = contentLine.slice(1, -1);
+    expect(content).toBe(" ".repeat(8) + "AB");
+
+    // CENTER
+    const tableC = new Table(1, 1, {
+      maxWidth: 20,
+      padding: 0,
+      align: Align.CENTER,
+    })
+      .column(0, { minWidth: 10 })
+      .cell(0, 0, "AB");
+    result = service.render(tableC);
+    contentLine = result.split("\n")[1]!;
+    content = contentLine.slice(1, -1);
+    expect(content).toBe(" ".repeat(4) + "AB" + " ".repeat(4));
+  });
+
+  test("alignment cascade: cell overrides row overrides column overrides table", () => {
+    const service = createService();
+    // Use minWidth=10 so column is wider than content "AB" (2 chars)
+    const table = new Table(3, 1, {
+      maxWidth: 20,
+      padding: 0,
+      align: Align.LEFT,
+    })
+      .column(0, { align: Align.RIGHT, minWidth: 10 })
+      .row(1, { align: Align.CENTER })
+      .cell(0, 0, "AB")
+      .cell(1, 0, "AB")
+      .cell(2, 0, "AB", { align: Align.LEFT });
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+
+    // Row 0: column override (RIGHT)
+    const row0 = lines[1]!.slice(1, -1);
+    expect(row0).toBe(" ".repeat(8) + "AB");
+
+    // Row 1: row override (CENTER) takes precedence over column
+    const row1 = lines[3]!.slice(1, -1);
+    expect(row1).toBe(" ".repeat(4) + "AB" + " ".repeat(4));
+
+    // Row 2: cell override (LEFT) takes precedence over column
+    const row2 = lines[5]!.slice(1, -1);
+    expect(row2).toBe("AB" + " ".repeat(8));
+  });
+
+  test("empty cells render as blank space", () => {
+    const service = createService();
+    const table = new Table(1, 2, { maxWidth: 20, padding: 1 })
+      .cell(0, 0, "Hi");
+    // cell(0, 1) not set
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    const contentLine = lines[1]!;
+    // Should render without error
+    expect(contentLine).toContain("Hi");
+    // The missing cell should render as blank space
+    const parts = contentLine.split("│").filter((s) => s.length > 0);
+    expect(parts.length).toBe(2);
+    expect(parts[1]!.trim()).toBe("");
+  });
+
+  test("multi-line cell content extends row height", () => {
+    const service = createService();
+    const table = new Table(1, 2, { maxWidth: 40, padding: 1 })
+      .cell(0, 0, "line1\nline2\nline3")
+      .cell(0, 1, "single");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    // Filter content lines (between top and bottom borders)
+    const contentLines = lines.filter((l) =>
+      l.startsWith("│") && !l.includes("─")
+    );
+    // Row should have 3 sub-lines due to multi-line content
+    expect(contentLines.length).toBe(3);
+    expect(contentLines[0]).toContain("line1");
+    expect(contentLines[0]).toContain("single");
+    expect(contentLines[1]).toContain("line2");
+    expect(contentLines[2]).toContain("line3");
+  });
+
+  test("border coloring applies color function to border characters", () => {
+    const service = new DefaultTableGeneratorService();
+    service.colorEnabled = true;
+    service.colorFunction = (text, hex) => `[fg:${hex}]${text}[/fg]`;
+    service.backgroundColorFunction = (text, hex) => `[bg:${hex}]${text}[/bg]`;
+
+    const table = new Table(1, 1, {
+      maxWidth: 20,
+      padding: 0,
+      borderColor: "#ff0000",
+      borderBackgroundColor: "#0000ff",
+    }).cell(0, 0, "X");
+
+    const result = service.render(table);
+    // Border chars should be wrapped with both color functions
+    expect(result).toContain("[fg:#ff0000]");
+    expect(result).toContain("[bg:#0000ff]");
+    // Content should NOT be colored by border color function
+    // The "X" itself should appear without color wrappers
+    expect(result).toContain("X");
+  });
+
+  test("1x1 table renders correctly", () => {
+    const service = createService();
+    const table = new Table(1, 1, { maxWidth: 10, padding: 0 })
+      .cell(0, 0, "Hi");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    // Should have 3 lines: top border, content, bottom border
+    expect(lines.length).toBe(3);
+    expect(lines[0]).toMatch(/^┌─+┐$/);
+    expect(lines[1]).toMatch(/^│.*│$/);
+    expect(lines[1]).toContain("Hi");
+    expect(lines[2]).toMatch(/^└─+┘$/);
+  });
+
+  test("padding=0 works", () => {
+    const service = createService();
+    const table = new Table(1, 1, { maxWidth: 10, padding: 0 })
+      .cell(0, 0, "AB");
+
+    const result = service.render(table);
+    const lines = result.split("\n");
+    const contentLine = lines[1]!;
+    // With padding=0, content sits directly against borders
+    // │AB........│
+    expect(contentLine.startsWith("│")).toBe(true);
+    expect(contentLine.endsWith("│")).toBe(true);
+    // No padding space between border and content
+    expect(contentLine[1]).toBe("A");
+  });
+
+  test("out-of-bounds row index throws", () => {
+    const table = new Table(2, 2);
+    expect(() => table.row(5, { align: Align.LEFT })).toThrow(
+      /out of bounds/,
+    );
+    expect(() => table.row(-1, { align: Align.LEFT })).toThrow(
+      /out of bounds/,
+    );
+  });
+
+  test("out-of-bounds column index throws", () => {
+    const table = new Table(2, 2);
+    expect(() => table.column(5, { flexWeight: 1 })).toThrow(
+      /out of bounds/,
+    );
+    expect(() => table.column(-1, { flexWeight: 1 })).toThrow(
+      /out of bounds/,
+    );
+  });
+
+  test("out-of-bounds cell index throws", () => {
+    const table = new Table(2, 2);
+    expect(() => table.cell(5, 0, "X")).toThrow(/out of bounds/);
+    expect(() => table.cell(0, 5, "X")).toThrow(/out of bounds/);
+    expect(() => table.cell(-1, 0, "X")).toThrow(/out of bounds/);
+    expect(() => table.cell(0, -1, "X")).toThrow(/out of bounds/);
+  });
+});

package/tests/service/tableGenerator/TableGeneratorServiceProvider.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import DefaultContext from "../../../src/runtime/DefaultContext.ts";
+import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
+import TableGeneratorServiceProvider from "../../../src/service/tableGenerator/TableGeneratorServiceProvider.ts";
+import { PRINTER_SERVICE_ID } from "../../../src/api/service/core/PrinterService.ts";
+import DefaultPrinterService from "../../../src/service/printer/DefaultPrinterService.ts";
+import StreamString from "../../fixtures/StreamString.ts";
+import TtyTerminal from "../../../src/terminal/TtyTerminal.ts";
+import TtyStyler from "../../../src/terminal/TtyStyler.ts";
+
+describe("TableGeneratorServiceProvider tests", () => {
+  test("getServiceInfo returns service and empty commands", async () => {
+    const provider = new TableGeneratorServiceProvider(100);
+    const cliConfig = getCLIConfig();
+    const serviceInfo = await provider.getServiceInfo(cliConfig);
+    expect(serviceInfo.commands.length).toEqual(0);
+    expect(serviceInfo.service).toBeDefined();
+  });
+
+  test("initService sets colorEnabled and colorFunction from PrinterService", async () => {
+    const dummyStdout = new StreamString();
+    const dummyStderr = new StreamString();
+    const provider = new TableGeneratorServiceProvider(100);
+    const cliConfig = getCLIConfig();
+    const context = new DefaultContext(cliConfig);
+    context.addServiceInstance(
+      PRINTER_SERVICE_ID,
+      new DefaultPrinterService(
+        dummyStdout.writableStream,
+        dummyStderr.writableStream,
+        true,
+        true,
+        new TtyTerminal(dummyStdout.writeStream),
+        new TtyTerminal(dummyStderr.writeStream),
+        new TtyStyler(3),
+      ),
+    );
+    const serviceInfo = await provider.getServiceInfo(cliConfig);
+    expect(serviceInfo.commands.length).toEqual(0);
+    await provider.initService(context);
+    const service = serviceInfo
+      .service as import("../../../src/service/tableGenerator/DefaultTableGeneratorService.ts").default;
+    expect(service.colorEnabled).toBe(true);
+    expect(typeof service.colorFunction).toBe("function");
+    expect(typeof service.backgroundColorFunction).toBe("function");
+  });
+});

package/tests/service/treePrinter/DefaultTreePrinterService.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, test } from "bun:test";
+import DefaultTreePrinterService from "../../../src/service/treePrinter/DefaultTreePrinterService.ts";
+
+describe("DefaultTreePrinterService tests", () => {
+  test("Single root, no children", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = false;
+
+    expect(service.print({ label: "Root" })).toEqual("Root");
+  });
+
+  test("Root with string children uses correct connectors", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = false;
+
+    const result = service.print({
+      label: "Root",
+      children: ["Alpha", "Beta", "Gamma"],
+    });
+
+    const lines = result.split("\n");
+    expect(lines[0]).toEqual("Root");
+    expect(lines[1]).toEqual("├── Alpha");
+    expect(lines[2]).toEqual("├── Beta");
+    expect(lines[3]).toEqual("└── Gamma");
+  });
+
+  test("Root with TreeNode children uses correct connectors", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = false;
+
+    const result = service.print({
+      label: "Root",
+      children: [
+        { label: "Child1", children: ["Leaf1", "Leaf2"] },
+        { label: "Child2" },
+      ],
+    });
+
+    const lines = result.split("\n");
+    expect(lines[0]).toEqual("Root");
+    expect(lines[1]).toEqual("├── Child1");
+    expect(lines[2]).toEqual("│   ├── Leaf1");
+    expect(lines[3]).toEqual("│   └── Leaf2");
+    expect(lines[4]).toEqual("└── Child2");
+  });
+
+  test("Mixed children (strings and nodes at same level)", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = false;
+
+    const result = service.print({
+      label: "Root",
+      children: [
+        "StringChild",
+        { label: "NodeChild", children: ["Nested"] },
+        "Last",
+      ],
+    });
+
+    const lines = result.split("\n");
+    expect(lines[0]).toEqual("Root");
+    expect(lines[1]).toEqual("├── StringChild");
+    expect(lines[2]).toEqual("├── NodeChild");
+    expect(lines[3]).toEqual("│   └── Nested");
+    expect(lines[4]).toEqual("└── Last");
+  });
+
+  test("Deep nesting propagates continuation chars correctly", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = false;
+
+    const result = service.print({
+      label: "Root",
+      children: [
+        {
+          label: "L1",
+          children: [
+            {
+              label: "L2",
+              children: ["L3a", "L3b"],
+            },
+            "L2sibling",
+          ],
+        },
+        "RootSibling",
+      ],
+    });
+
+    const lines = result.split("\n");
+    expect(lines[0]).toEqual("Root");
+    expect(lines[1]).toEqual("├── L1");
+    expect(lines[2]).toEqual("│   ├── L2");
+    expect(lines[3]).toEqual("│   │   ├── L3a");
+    expect(lines[4]).toEqual("│   │   └── L3b");
+    expect(lines[5]).toEqual("│   └── L2sibling");
+    expect(lines[6]).toEqual("└── RootSibling");
+  });
+
+  test("Last child uses └── and others use ├──", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = false;
+
+    const result = service.print({
+      label: "Root",
+      children: ["A", "B", "C"],
+    });
+
+    const lines = result.split("\n");
+    expect(lines[1]!.startsWith("├── ")).toBe(true);
+    expect(lines[2]!.startsWith("├── ")).toBe(true);
+    expect(lines[3]!.startsWith("└── ")).toBe(true);
+  });
+
+  test("colorEnabled=true wraps labels via colorFunction", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = true;
+    service.colorFunction = (text, _color) => `[${text}]`;
+
+    const result = service.print({
+      label: "Root",
+      children: ["Child"],
+    });
+
+    const lines = result.split("\n");
+    expect(lines[0]).toEqual("[Root]");
+    expect(lines[1]).toEqual("└── [Child]");
+  });
+
+  test("colorEnabled=false returns plain text", () => {
+    const service = new DefaultTreePrinterService();
+    service.colorEnabled = false;
+    service.colorFunction = (text, _color) => `[${text}]`;
+
+    const result = service.print({
+      label: "Root",
+      children: ["Child"],
+    });
+
+    const lines = result.split("\n");
+    expect(lines[0]).toEqual("Root");
+    expect(lines[1]).toEqual("└── Child");
+  });
+});