index.test.ts

import { test, expect, describe } from "bun:test";
import { formatOutput, formatMessage, formatContentBlock } from "./src/format";
import { projectDirToPath } from "./src/data";
import type { MessageEntry, ShowOptions } from "./src/types";

const defaultOptions: ShowOptions = {
  noTools: false,
  noSystem: false,
  compact: false,
};

describe("projectDirToPath", () => {
  test("converts dash-separated dir to path", () => {
    expect(projectDirToPath("-Users-defrex-code-foo")).toBe(
      "/Users/defrex/code/foo"
    );
  });

  test("handles single segment", () => {
    expect(projectDirToPath("-tmp")).toBe("/tmp");
  });
});

describe("formatOutput", () => {
  test("renders YAML frontmatter and body", () => {
    const result = formatOutput({ title: "test", count: 5 }, "hello world");
    expect(result).toBe("---\ntitle: test\ncount: 5\n---\n\nhello world");
  });

  test("escapes special characters in YAML values", () => {
    const result = formatOutput({ msg: 'has "quotes"' }, "body");
    expect(result).toContain('msg: "has \\"quotes\\""');
  });
});

describe("formatContentBlock", () => {
  test("renders text block", () => {
    const result = formatContentBlock(
      { type: "text", text: "hello" },
      defaultOptions
    );
    expect(result).toBe("hello");
  });

  test("renders tool_use block", () => {
    const result = formatContentBlock(
      { type: "tool_use", id: "1", name: "Read", input: { path: "/tmp" } },
      defaultOptions
    );
    expect(result).toContain("**Tool: Read**");
    expect(result).toContain('"path": "/tmp"');
  });

  test("hides tool_use with noTools", () => {
    const result = formatContentBlock(
      { type: "tool_use", id: "1", name: "Read", input: {} },
      { ...defaultOptions, noTools: true }
    );
    expect(result).toBeNull();
  });

  test("truncates tool_use input in compact mode", () => {
    const longInput = { data: "x".repeat(500) };
    const result = formatContentBlock(
      { type: "tool_use", id: "1", name: "Read", input: longInput },
      { ...defaultOptions, compact: true }
    );
    expect(result).toContain("(truncated)");
  });

  test("renders tool_result as collapsible", () => {
    const result = formatContentBlock(
      { type: "tool_result", tool_use_id: "1", content: "output here" },
      defaultOptions
    );
    expect(result).toContain("<details>");
    expect(result).toContain("output here");
  });

  test("hides thinking in compact mode", () => {
    const result = formatContentBlock(
      { type: "thinking", thinking: "hmm" },
      { ...defaultOptions, compact: true }
    );
    expect(result).toBeNull();
  });
});

describe("formatMessage", () => {
  const userEntry: MessageEntry = {
    type: "user",
    message: { role: "user", content: "hello" },
  };

  const assistantEntry: MessageEntry = {
    type: "assistant",
    message: {
      role: "assistant",
      content: [{ type: "text", text: "hi there" }],
      model: "claude-opus-4-6",
    },
  };

  test("renders user message", () => {
    const result = formatMessage(userEntry, defaultOptions);
    expect(result).toBe("## User\n\nhello");
  });

  test("renders assistant message with content blocks", () => {
    const result = formatMessage(assistantEntry, defaultOptions);
    expect(result).toContain("## Assistant");
    expect(result).toContain("hi there");
  });

  test("filters by type", () => {
    const result = formatMessage(userEntry, {
      ...defaultOptions,
      type: "assistant",
    });
    expect(result).toBeNull();
  });

  test("hides system with noSystem", () => {
    const systemEntry: MessageEntry = {
      type: "system" as any,
      message: { role: "system", content: "init" },
    };
    const result = formatMessage(systemEntry, {
      ...defaultOptions,
      noSystem: true,
    });
    expect(result).toBeNull();
  });
});