session-viewer/tests/unit/session-parser.test.ts

import { describe, it, expect } from "vitest";
import { parseSessionContent } from "../../src/server/services/session-parser.js";
import fs from "fs/promises";
import path from "path";

describe("session-parser", () => {
  it("parses user messages with string content", () => {
    const line = JSON.stringify({
      type: "user",
      message: { role: "user", content: "Hello world" },
      uuid: "u-1",
      timestamp: "2025-10-15T10:00:00Z",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("user_message");
    expect(msgs[0].content).toBe("Hello world");
    expect(msgs[0].uuid).toBe("u-1");
    expect(msgs[0].timestamp).toBe("2025-10-15T10:00:00Z");
  });

  it("parses user messages with tool_result array content", () => {
    const line = JSON.stringify({
      type: "user",
      message: {
        role: "user",
        content: [
          { type: "tool_result", tool_use_id: "toolu_01", content: "File contents here" },
        ],
      },
      uuid: "u-2",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("tool_result");
    expect(msgs[0].content).toBe("File contents here");
  });

  it("parses assistant text blocks", () => {
    const line = JSON.stringify({
      type: "assistant",
      message: {
        role: "assistant",
        content: [{ type: "text", text: "Here is my response" }],
      },
      uuid: "a-1",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("assistant_text");
    expect(msgs[0].content).toBe("Here is my response");
  });

  it("parses thinking blocks", () => {
    const line = JSON.stringify({
      type: "assistant",
      message: {
        role: "assistant",
        content: [{ type: "thinking", thinking: "Let me think about this..." }],
      },
      uuid: "a-2",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("thinking");
    expect(msgs[0].content).toBe("Let me think about this...");
  });

  it("parses tool_use blocks", () => {
    const line = JSON.stringify({
      type: "assistant",
      message: {
        role: "assistant",
        content: [
          { type: "tool_use", name: "Read", input: { file_path: "/src/index.ts" } },
        ],
      },
      uuid: "a-3",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("tool_call");
    expect(msgs[0].toolName).toBe("Read");
    expect(msgs[0].toolInput).toContain("/src/index.ts");
  });

  it("parses progress messages from data field", () => {
    const line = JSON.stringify({
      type: "progress",
      data: { type: "hook", hookEvent: "PreToolUse", hookName: "security_check" },
      uuid: "p-1",
      timestamp: "2025-10-15T10:00:00Z",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("hook_progress");
    expect(msgs[0].content).toContain("PreToolUse");
    expect(msgs[0].content).toContain("security_check");
  });

  it("parses file-history-snapshot messages", () => {
    const line = JSON.stringify({
      type: "file-history-snapshot",
      messageId: "snap-1",
      snapshot: { messageId: "snap-1", trackedFileBackups: [], timestamp: "2025-10-15T10:00:00Z" },
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("file_snapshot");
  });

  it("parses summary messages from summary field", () => {
    const line = JSON.stringify({
      type: "summary",
      summary: "Session summary here",
      leafUuid: "msg-10",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("summary");
    expect(msgs[0].content).toBe("Session summary here");
  });

  it("skips system metadata lines (turn_duration)", () => {
    const line = JSON.stringify({
      type: "system",
      subtype: "turn_duration",
      durationMs: 50000,
      uuid: "sys-1",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(0);
  });

  it("skips queue-operation lines", () => {
    const line = JSON.stringify({
      type: "queue-operation",
      uuid: "qo-1",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(0);
  });

  it("detects system-reminder content in user messages", () => {
    const line = JSON.stringify({
      type: "user",
      message: {
        role: "user",
        content: "<system-reminder>Some reminder</system-reminder>",
      },
      uuid: "u-sr",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("system_message");
  });

  it("skips malformed JSONL lines without crashing", () => {
    const content = [
      "not valid json",
      JSON.stringify({
        type: "user",
        message: { role: "user", content: "Valid message" },
        uuid: "u-valid",
      }),
      "{broken}",
    ].join("\n");
    const msgs = parseSessionContent(content);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].content).toBe("Valid message");
  });

  it("returns empty array for empty files", () => {
    const msgs = parseSessionContent("");
    expect(msgs).toEqual([]);
  });

  it("uses uuid from the JSONL line, not random", () => {
    const line = JSON.stringify({
      type: "user",
      message: { role: "user", content: "Test" },
      uuid: "my-specific-uuid-123",
    });
    const msgs = parseSessionContent(line);
    expect(msgs[0].uuid).toBe("my-specific-uuid-123");
  });

  it("parses the full sample session fixture", async () => {
    const fixturePath = path.join(
      __dirname,
      "../fixtures/sample-session.jsonl"
    );
    const content = await fs.readFile(fixturePath, "utf-8");
    const msgs = parseSessionContent(content);

    const categories = new Set(msgs.map((m) => m.category));
    expect(categories.has("user_message")).toBe(true);
    expect(categories.has("assistant_text")).toBe(true);
    expect(categories.has("thinking")).toBe(true);
    expect(categories.has("tool_call")).toBe(true);
    expect(categories.has("tool_result")).toBe(true);
    expect(categories.has("system_message")).toBe(true);
    expect(categories.has("hook_progress")).toBe(true);
    expect(categories.has("summary")).toBe(true);
    expect(categories.has("file_snapshot")).toBe(true);
  });

  it("handles edge-cases fixture (corrupt lines)", async () => {
    const fixturePath = path.join(
      __dirname,
      "../fixtures/edge-cases.jsonl"
    );
    const content = await fs.readFile(fixturePath, "utf-8");
    const msgs = parseSessionContent(content);
    expect(msgs).toHaveLength(2);
    expect(msgs[0].category).toBe("user_message");
    expect(msgs[1].category).toBe("assistant_text");
  });

  it("extracts toolUseId from tool_use blocks with id field", () => {
    const line = JSON.stringify({
      type: "assistant",
      message: {
        role: "assistant",
        content: [
          { type: "tool_use", id: "toolu_abc123", name: "Read", input: { file_path: "/src/index.ts" } },
        ],
      },
      uuid: "a-tu-1",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("tool_call");
    expect(msgs[0].toolUseId).toBe("toolu_abc123");
  });

  it("toolUseId is undefined when tool_use block has no id field", () => {
    const line = JSON.stringify({
      type: "assistant",
      message: {
        role: "assistant",
        content: [
          { type: "tool_use", name: "Read", input: { file_path: "/src/index.ts" } },
        ],
      },
      uuid: "a-tu-2",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].toolUseId).toBeUndefined();
  });

  it("extracts parentToolUseId and progressSubtype from hook_progress", () => {
    const line = JSON.stringify({
      type: "progress",
      data: { type: "hook_progress", hookEvent: "PreToolUse", hookName: "check" },
      parentToolUseID: "toolu_abc123",
      uuid: "p-linked",
      timestamp: "2025-10-15T10:00:00Z",
    });
    const msgs = parseSessionContent(line);
    expect(msgs).toHaveLength(1);
    expect(msgs[0].category).toBe("hook_progress");
    expect(msgs[0].parentToolUseId).toBe("toolu_abc123");
    expect(msgs[0].progressSubtype).toBe("hook");
  });

  it("derives progressSubtype 'bash' from bash_progress data type", () => {
    const line = JSON.stringify({
      type: "progress",
      data: { type: "bash_progress", status: "running" },
      parentToolUseID: "toolu_bash1",
      uuid: "p-bash",
    });
    const msgs = parseSessionContent(line);
    expect(msgs[0].progressSubtype).toBe("bash");
    expect(msgs[0].parentToolUseId).toBe("toolu_bash1");
  });

  it("derives progressSubtype 'mcp' from mcp_progress data type", () => {
    const line = JSON.stringify({
      type: "progress",
      data: { type: "mcp_progress", serverName: "morph-mcp" },
      parentToolUseID: "toolu_mcp1",
      uuid: "p-mcp",
    });
    const msgs = parseSessionContent(line);
    expect(msgs[0].progressSubtype).toBe("mcp");
  });

  it("derives progressSubtype 'agent' from agent_progress data type", () => {
    const line = JSON.stringify({
      type: "progress",
      data: { type: "agent_progress", status: "started" },
      parentToolUseID: "toolu_agent1",
      uuid: "p-agent",
    });
    const msgs = parseSessionContent(line);
    expect(msgs[0].progressSubtype).toBe("agent");
  });

  it("parentToolUseId is undefined when progress has no parentToolUseID", () => {
    const line = JSON.stringify({
      type: "progress",
      data: { type: "hook_progress", hookEvent: "SessionStart" },
      uuid: "p-orphan",
    });
    const msgs = parseSessionContent(line);
    expect(msgs[0].parentToolUseId).toBeUndefined();
    expect(msgs[0].progressSubtype).toBe("hook");
  });

  it("progressSubtype defaults to 'hook' for unknown data types", () => {
    const line = JSON.stringify({
      type: "progress",
      data: { type: "unknown_thing", status: "ok" },
      uuid: "p-unknown",
    });
    const msgs = parseSessionContent(line);
    expect(msgs[0].progressSubtype).toBe("hook");
  });
});