@aria-cli/tools 1.0.9 → 1.0.10

package/tests/executors/session-transcript.test.ts

@@ -1,561 +0,0 @@
-/**
- * @aria/tools - Session transcript tests
- *
- * Tests for the real getSessionTranscript implementation that reads
- * Claude Code session transcripts from ~/.claude/projects/ JSONL files.
- *
- * Uses temporary directories with mock JSONL files to test:
- * - Reading from JSONL files
- * - Handling missing/empty directories
- * - Handling malformed JSONL
- * - Symlink safety (skips them)
- * - Correct turn count
- * - Content truncation to 500 chars
- * - Most-recent-first sorting by mtime
- * - sessionId matching
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "node:fs";
-import fsp from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-
-// We need to test getSessionTranscript which reads from ~/.claude/projects/
-// To avoid touching real files, we mock the filesystem paths via os.homedir()
-import { getSessionTranscript } from "../../src/executors/memory.js";
-
-describe("getSessionTranscript", () => {
-  let tmpDir: string;
-  let originalHomedir: () => string;
-  let projectsDir: string;
-
-  beforeEach(() => {
-    // Create a temp directory to act as the home directory
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "aria-transcript-test-"));
-    projectsDir = path.join(tmpDir, ".claude", "projects");
-    fs.mkdirSync(projectsDir, { recursive: true });
-
-    // Mock os.homedir() to return our temp directory
-    originalHomedir = os.homedir;
-    vi.spyOn(os, "homedir").mockReturnValue(tmpDir);
-  });
-
-  afterEach(() => {
-    // Restore os.homedir
-    vi.restoreAllMocks();
-    // Clean up temp directory
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  // ── Helpers ──────────────────────────────────────────────────────────
-
-  function createProjectDir(name: string): string {
-    const dir = path.join(projectsDir, name);
-    fs.mkdirSync(dir, { recursive: true });
-    return dir;
-  }
-
-  function writeSessionFile(
-    projectDir: string,
-    filename: string,
-    lines: string[],
-    mtime?: Date,
-  ): string {
-    const filePath = path.join(projectDir, filename);
-    fs.writeFileSync(filePath, lines.join("\n"), "utf-8");
-    if (mtime) {
-      fs.utimesSync(filePath, mtime, mtime);
-    }
-    return filePath;
-  }
-
-  function makeUserEntry(content: string): string {
-    return JSON.stringify({
-      type: "user",
-      sessionId: "test-session",
-      uuid: "uuid-1",
-      timestamp: new Date().toISOString(),
-      message: { role: "user", content },
-    });
-  }
-
-  function makeAssistantEntry(content: string): string {
-    return JSON.stringify({
-      type: "assistant",
-      sessionId: "test-session",
-      uuid: "uuid-2",
-      timestamp: new Date().toISOString(),
-      message: { role: "assistant", content },
-    });
-  }
-
-  function makeUserEntryWithBlocks(blocks: Array<{ type: string; text?: string }>): string {
-    return JSON.stringify({
-      type: "user",
-      sessionId: "test-session",
-      uuid: "uuid-1",
-      timestamp: new Date().toISOString(),
-      message: { role: "user", content: blocks },
-    });
-  }
-
-  function makeAssistantEntryWithBlocks(blocks: Array<{ type: string; text?: string }>): string {
-    return JSON.stringify({
-      type: "assistant",
-      sessionId: "test-session",
-      uuid: "uuid-2",
-      timestamp: new Date().toISOString(),
-      message: { role: "assistant", content: blocks },
-    });
-  }
-
-  // ── Tests ────────────────────────────────────────────────────────────
-
-  describe("basic functionality", () => {
-    it("reads user and assistant messages from a JSONL file", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session-abc.jsonl", [
-        makeUserEntry("Hello"),
-        makeAssistantEntry("Hi there!"),
-        makeUserEntry("What is 2+2?"),
-        makeAssistantEntry("4"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(4);
-      expect(result[0]).toEqual({ role: "user", content: "Hello" });
-      expect(result[1]).toEqual({ role: "assistant", content: "Hi there!" });
-      expect(result[2]).toEqual({ role: "user", content: "What is 2+2?" });
-      expect(result[3]).toEqual({ role: "assistant", content: "4" });
-    });
-
-    it("parses content block arrays (text blocks)", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session-blocks.jsonl", [
-        makeUserEntryWithBlocks([
-          { type: "text", text: "First part" },
-          { type: "text", text: "Second part" },
-        ]),
-        makeAssistantEntryWithBlocks([
-          { type: "text", text: "Response text" },
-          { type: "tool_use" }, // Non-text blocks should be skipped
-        ]),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({ role: "user", content: "First part\nSecond part" });
-      expect(result[1]).toEqual({ role: "assistant", content: "Response text" });
-    });
-
-    it("skips non-user/assistant entry types", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session-mixed.jsonl", [
-        makeUserEntry("Hello"),
-        JSON.stringify({ type: "progress", message: { content: "thinking..." } }),
-        JSON.stringify({ type: "system", message: { content: "init" } }),
-        makeAssistantEntry("Hi!"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0].role).toBe("user");
-      expect(result[1].role).toBe("assistant");
-    });
-  });
-
-  describe("turn count", () => {
-    it("returns last N turns (default 10 = 20 messages)", async () => {
-      const dir = createProjectDir("my-project");
-      const lines: string[] = [];
-      for (let i = 0; i < 25; i++) {
-        lines.push(makeUserEntry(`Question ${i}`));
-        lines.push(makeAssistantEntry(`Answer ${i}`));
-      }
-      writeSessionFile(dir, "big-session.jsonl", lines);
-
-      // Default is 10 turns = 20 messages
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(20);
-      // Should start from message index 30 (50 - 20)
-      expect(result[0]).toEqual({ role: "user", content: "Question 15" });
-      expect(result[19]).toEqual({ role: "assistant", content: "Answer 24" });
-    });
-
-    it("returns last 2 turns (4 messages) when turns=2", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [
-        makeUserEntry("Q1"),
-        makeAssistantEntry("A1"),
-        makeUserEntry("Q2"),
-        makeAssistantEntry("A2"),
-        makeUserEntry("Q3"),
-        makeAssistantEntry("A3"),
-      ]);
-
-      const result = await getSessionTranscript({ turns: 2 });
-
-      expect(result).toHaveLength(4);
-      expect(result[0]).toEqual({ role: "user", content: "Q2" });
-      expect(result[3]).toEqual({ role: "assistant", content: "A3" });
-    });
-
-    it("returns all messages when turns exceeds available", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [makeUserEntry("Q1"), makeAssistantEntry("A1")]);
-
-      const result = await getSessionTranscript({ turns: 100 });
-
-      expect(result).toHaveLength(2);
-    });
-
-    it("returns empty array when turns=0", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [makeUserEntry("Q1"), makeAssistantEntry("A1")]);
-
-      const result = await getSessionTranscript({ turns: 0 });
-
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array when turns is negative", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [makeUserEntry("Q1"), makeAssistantEntry("A1")]);
-
-      const result = await getSessionTranscript({ turns: -5 });
-
-      expect(result).toEqual([]);
-    });
-
-    it("tails large session files without using a full read", async () => {
-      const dir = createProjectDir("my-project");
-      const fillerLines = Array.from({ length: 256 }, (_, index) =>
-        index % 2 === 0
-          ? makeUserEntry(`Filler user ${index}: ${"x".repeat(2048)}`)
-          : makeAssistantEntry(`Filler assistant ${index}: ${"y".repeat(2048)}`),
-      );
-      const filePath = writeSessionFile(dir, "large-session.jsonl", [
-        ...fillerLines,
-        makeUserEntry("Tail Q1"),
-        makeAssistantEntry("Tail A1"),
-        makeUserEntry("Tail Q2"),
-        makeAssistantEntry("Tail A2"),
-      ]);
-
-      const originalReadFile = fsp.readFile.bind(fsp) as typeof fsp.readFile;
-      vi.spyOn(fsp, "readFile").mockImplementation(async (target, options) => {
-        if (typeof target === "string" && target === filePath) {
-          throw new Error("getSessionTranscript must not full-read transcript files");
-        }
-        return originalReadFile(target as never, options as never);
-      });
-
-      const result = await getSessionTranscript({ turns: 2 });
-
-      expect(result).toEqual([
-        { role: "user", content: "Tail Q1" },
-        { role: "assistant", content: "Tail A1" },
-        { role: "user", content: "Tail Q2" },
-        { role: "assistant", content: "Tail A2" },
-      ]);
-    });
-  });
-
-  describe("content truncation", () => {
-    it("truncates content to 500 characters", async () => {
-      const longContent = "x".repeat(800);
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [
-        makeUserEntry(longContent),
-        makeAssistantEntry("short"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toHaveLength(500);
-      expect(result[0].content).toBe("x".repeat(500));
-      expect(result[1].content).toBe("short");
-    });
-
-    it("does not truncate content under 500 characters", async () => {
-      const content = "x".repeat(499);
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [makeUserEntry(content)]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result[0].content).toHaveLength(499);
-    });
-
-    it("exactly 500 characters is not truncated", async () => {
-      const content = "x".repeat(500);
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [makeUserEntry(content)]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result[0].content).toHaveLength(500);
-    });
-  });
-
-  describe("mtime sorting (most recent first)", () => {
-    it("selects the most recent session file by mtime", async () => {
-      const dir = createProjectDir("my-project");
-
-      // Old session (1 day ago)
-      writeSessionFile(
-        dir,
-        "old-session.jsonl",
-        [makeUserEntry("Old question"), makeAssistantEntry("Old answer")],
-        new Date(Date.now() - 86400000),
-      );
-
-      // New session (now)
-      writeSessionFile(
-        dir,
-        "new-session.jsonl",
-        [makeUserEntry("New question"), makeAssistantEntry("New answer")],
-        new Date(),
-      );
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("New question");
-      expect(result[1].content).toBe("New answer");
-    });
-
-    it("selects most recent across multiple project directories", async () => {
-      const dirA = createProjectDir("project-a");
-      const dirB = createProjectDir("project-b");
-
-      // project-a has an older session
-      writeSessionFile(
-        dirA,
-        "session-a.jsonl",
-        [makeUserEntry("From project A"), makeAssistantEntry("A response")],
-        new Date(Date.now() - 86400000),
-      );
-
-      // project-b has a newer session
-      writeSessionFile(
-        dirB,
-        "session-b.jsonl",
-        [makeUserEntry("From project B"), makeAssistantEntry("B response")],
-        new Date(),
-      );
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("From project B");
-    });
-  });
-
-  describe("sessionId matching", () => {
-    it("matches session by sessionId substring in path", async () => {
-      const dir = createProjectDir("my-project");
-
-      writeSessionFile(
-        dir,
-        "target-session-xyz.jsonl",
-        [makeUserEntry("Target Q"), makeAssistantEntry("Target A")],
-        new Date(Date.now() - 86400000), // Older
-      );
-
-      writeSessionFile(
-        dir,
-        "other-session.jsonl",
-        [makeUserEntry("Other Q"), makeAssistantEntry("Other A")],
-        new Date(), // Newer
-      );
-
-      // Should match the older one by sessionId, even though it's not the most recent
-      const result = await getSessionTranscript({ sessionId: "target-session-xyz" });
-
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("Target Q");
-    });
-
-    it("returns empty array when sessionId matches nothing", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session-abc.jsonl", [makeUserEntry("Q"), makeAssistantEntry("A")]);
-
-      const result = await getSessionTranscript({ sessionId: "nonexistent-session-id" });
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("symlink safety", () => {
-    it("skips symlinked project directories", async () => {
-      const realDir = createProjectDir("real-project");
-      writeSessionFile(realDir, "session.jsonl", [
-        makeUserEntry("Real Q"),
-        makeAssistantEntry("Real A"),
-      ]);
-
-      // Create a symlink to the real directory
-      const symlinkPath = path.join(projectsDir, "symlinked-project");
-      fs.symlinkSync(realDir, symlinkPath);
-
-      // Should still find the real project's session
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("Real Q");
-    });
-
-    it("skips symlinked JSONL files", async () => {
-      const dir = createProjectDir("my-project");
-      const realFile = writeSessionFile(
-        dir,
-        "real-session.jsonl",
-        [makeUserEntry("Real Q"), makeAssistantEntry("Real A")],
-        new Date(Date.now() - 86400000), // Older
-      );
-
-      // Create a symlinked session file that is "newer"
-      const symlinkFile = path.join(dir, "symlinked-session.jsonl");
-      fs.symlinkSync(realFile, symlinkFile);
-      // Touch the symlink to be "newer" — but lstat won't follow symlinks
-
-      const result = await getSessionTranscript({});
-
-      // Should find the real session (not the symlink)
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("Real Q");
-    });
-  });
-
-  describe("missing/empty directories", () => {
-    it("returns empty array when ~/.claude/projects/ does not exist", async () => {
-      // Remove the projects directory
-      fs.rmSync(projectsDir, { recursive: true, force: true });
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array when projects directory is empty", async () => {
-      // projectsDir exists but has no subdirectories
-      const result = await getSessionTranscript({});
-
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array when project directory has no JSONL files", async () => {
-      createProjectDir("empty-project");
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array when JSONL file is empty", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "empty-session.jsonl", []);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("malformed JSONL handling", () => {
-    it("skips malformed JSON lines and still parses valid ones", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [
-        makeUserEntry("Valid Q1"),
-        "{ this is not valid JSON !!!",
-        "definitely not JSON",
-        makeAssistantEntry("Valid A1"),
-        "",
-        makeUserEntry("Valid Q2"),
-        makeAssistantEntry("Valid A2"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(4);
-      expect(result[0].content).toBe("Valid Q1");
-      expect(result[1].content).toBe("Valid A1");
-      expect(result[2].content).toBe("Valid Q2");
-      expect(result[3].content).toBe("Valid A2");
-    });
-
-    it("handles entries without message field", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [
-        JSON.stringify({ type: "user" }), // No message field
-        makeUserEntry("Valid Q"),
-        makeAssistantEntry("Valid A"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("Valid Q");
-    });
-
-    it("handles entries with empty content", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [
-        JSON.stringify({
-          type: "user",
-          sessionId: "s",
-          uuid: "u",
-          timestamp: new Date().toISOString(),
-          message: { role: "user", content: "" },
-        }),
-        makeUserEntry("Real Q"),
-        makeAssistantEntry("Real A"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      // Empty content entry should be skipped
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("Real Q");
-    });
-
-    it("handles content blocks with no text blocks", async () => {
-      const dir = createProjectDir("my-project");
-      writeSessionFile(dir, "session.jsonl", [
-        makeUserEntryWithBlocks([{ type: "tool_use" }, { type: "tool_result" }]),
-        makeUserEntry("Valid Q"),
-        makeAssistantEntry("Valid A"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      // tool_use/tool_result only entry produces empty text, should be skipped
-      expect(result).toHaveLength(2);
-    });
-  });
-
-  describe("non-.jsonl files are ignored", () => {
-    it("ignores non-JSONL files in project directories", async () => {
-      const dir = createProjectDir("my-project");
-      // Write a non-JSONL file
-      fs.writeFileSync(path.join(dir, "notes.txt"), makeUserEntry("Should not read this"));
-      // Write an actual JSONL file
-      writeSessionFile(dir, "session.jsonl", [
-        makeUserEntry("Real Q"),
-        makeAssistantEntry("Real A"),
-      ]);
-
-      const result = await getSessionTranscript({});
-
-      expect(result).toHaveLength(2);
-      expect(result[0].content).toBe("Real Q");
-    });
-  });
-});