@aria-cli/tools 1.0.0

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

@@ -0,0 +1,561 @@
+/**
+ * @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");
+    });
+  });
+});