@gswangg/duncan-cc 0.1.0

package/tests/content-replacements.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Tests for content replacements and microcompact.
+ */
+
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, basename, dirname } from "node:path";
+import { parseSession } from "../src/parser.js";
+import { buildRawChain } from "../src/tree.js";
+import { normalizeMessages } from "../src/normalize.js";
+import { applyContentReplacements, microcompact } from "../src/content-replacements.js";
+import { requireCorpus } from "./_skip-if-no-corpus.js";
+
+const TESTDATA = requireCorpus();
+
+function findSessionFiles(): string[] {
+  const files: string[] = [];
+  function walk(dir: string) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "subagents") walk(full);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl") && !dir.includes("subagents")) files.push(full);
+    }
+  }
+  walk(TESTDATA);
+  return files;
+}
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) { passed++; }
+  else { failed++; console.error(`  ✗ ${msg}`); }
+}
+
+function ok(msg: string) { passed++; console.log(`  ✓ ${msg}`); }
+
+// ============================================================================
+
+console.log("\n--- Content Replacements: persisted output resolution ---");
+{
+  // The codex session 630fd2b9 has persisted-output markers and tool-results/ files
+  const sessionFile = join(
+    TESTDATA,
+    "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex",
+    "630fd2b9-d94d-4287-8c24-e225fbedfc5c.jsonl"
+  );
+  const content = readFileSync(sessionFile, "utf-8");
+  const parsed = parseSession(content);
+  const chain = buildRawChain(parsed);
+  const normalized = normalizeMessages(chain);
+
+  // Count persisted-output markers before replacement
+  let markersBefore = 0;
+  for (const msg of normalized) {
+    if (msg.type !== "user") continue;
+    const c = msg.message.content;
+    if (Array.isArray(c)) {
+      for (const block of c) {
+        if (block.type === "tool_result" && typeof block.content === "string" && block.content.includes("<persisted-output>")) {
+          markersBefore++;
+        }
+      }
+    }
+  }
+
+  const replaced = applyContentReplacements(normalized, parsed, sessionFile);
+
+  // Count persisted-output markers after replacement
+  let markersAfter = 0;
+  let resolved = 0;
+  for (const msg of replaced) {
+    if (msg.type !== "user") continue;
+    const c = msg.message.content;
+    if (Array.isArray(c)) {
+      for (const block of c) {
+        if (block.type === "tool_result" && typeof block.content === "string") {
+          if (block.content.includes("<persisted-output>")) markersAfter++;
+          // Check if it was resolved from disk
+          if (block.content.length > 200 && !block.content.includes("<persisted-output>")) resolved++;
+        }
+      }
+    }
+  }
+
+  ok(`630fd2b9: ${markersBefore} persisted-output markers before, ${markersAfter} after, ${resolved} resolved from disk`);
+
+  // Check that tool-results/ directory exists for this session
+  const toolResultsDir = join(
+    dirname(sessionFile),
+    "630fd2b9-d94d-4287-8c24-e225fbedfc5c",
+    "tool-results"
+  );
+  assert(existsSync(toolResultsDir), "tool-results/ dir exists");
+
+  // Check files in it
+  const toolResultFiles = readdirSync(toolResultsDir);
+  ok(`tool-results/ has ${toolResultFiles.length} files: ${toolResultFiles.join(", ")}`);
+}
+
+console.log("\n--- Content Replacements: no-op for sessions without replacements ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const chain = buildRawChain(parsed);
+    const name = basename(file, ".jsonl").slice(0, 12);
+
+    if (chain.length === 0) continue;
+
+    const normalized = normalizeMessages(chain);
+    const replaced = applyContentReplacements(normalized, parsed, file);
+
+    // Should be same length (no messages added/removed)
+    assert(replaced.length === normalized.length, `${name}: same length after replacement`);
+  }
+  ok("all sessions: replacement preserves message count");
+}
+
+console.log("\n--- Microcompact: synthetic test ---");
+{
+  // Create synthetic messages with a time gap
+  const now = new Date();
+  const oldTime = new Date(now.getTime() - 60 * 60 * 1000); // 1 hour ago
+
+  const messages: any[] = [
+    {
+      type: "user", uuid: "u1", parentUuid: null, timestamp: oldTime.toISOString(),
+      message: { role: "user", content: [
+        { type: "tool_result", tool_use_id: "old_tool_1", content: "old result 1" },
+        { type: "tool_result", tool_use_id: "old_tool_2", content: "old result 2" },
+      ]},
+    },
+    {
+      type: "assistant", uuid: "a1", parentUuid: "u1", timestamp: oldTime.toISOString(),
+      message: { role: "assistant", content: [
+        { type: "text", text: "Here's what I found..." },
+        { type: "tool_use", id: "recent_tool_1", name: "Read", input: {} },
+      ]},
+    },
+    {
+      type: "user", uuid: "u2", parentUuid: "a1", timestamp: oldTime.toISOString(),
+      message: { role: "user", content: [
+        { type: "tool_result", tool_use_id: "recent_tool_1", content: "recent result" },
+      ]},
+    },
+    {
+      type: "assistant", uuid: "a2", parentUuid: "u2", timestamp: oldTime.toISOString(),
+      message: { role: "assistant", content: [
+        { type: "text", text: "Done." },
+      ]},
+    },
+  ];
+
+  // keepRecentTurns=2: keeps tool_use IDs from the last 2 assistant messages (a1 + a2)
+  const compacted = microcompact(messages, 30, 2);
+
+  // Old tool results (not from recent assistants) should be truncated
+  const u1 = compacted[0];
+  const u1Content = u1.message.content as any[];
+  assert(
+    u1Content[0].content.includes("truncated"),
+    "old_tool_1 truncated",
+  );
+  assert(
+    u1Content[1].content.includes("truncated"),
+    "old_tool_2 truncated",
+  );
+
+  // Recent tool result (from a1, which is in the last 2 assistants) should be preserved
+  const u2 = compacted[2];
+  const u2Content = u2.message.content as any[];
+  assert(
+    u2Content[0].content === "recent result",
+    "recent_tool_1 preserved",
+  );
+
+  ok("microcompact correctly truncates old, preserves recent");
+}
+
+console.log("\n--- Microcompact: no-op for recent sessions ---");
+{
+  // Create messages that are recent (no gap)
+  const now = new Date();
+
+  const messages: any[] = [
+    {
+      type: "user", uuid: "u1", parentUuid: null, timestamp: now.toISOString(),
+      message: { role: "user", content: [
+        { type: "tool_result", tool_use_id: "t1", content: "result" },
+      ]},
+    },
+    {
+      type: "assistant", uuid: "a1", parentUuid: "u1", timestamp: now.toISOString(),
+      message: { role: "assistant", content: [{ type: "text", text: "ok" }] },
+    },
+  ];
+
+  const compacted = microcompact(messages, 30, 1);
+  const u1Content = compacted[0].message.content as any[];
+  assert(u1Content[0].content === "result", "no truncation for recent session");
+  ok("microcompact no-op for recent sessions");
+}
+
+// ============================================================================
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.log("❌ Some tests failed");
+  process.exit(1);
+} else {
+  console.log("✅ All tests passed");
+}

package/tests/discovery.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Tests for session discovery.
+ */
+
+import { join, basename } from "node:path";
+import { listSessionFiles, listSubagentFiles, listAllSessionFiles, resolveSessionFiles } from "../src/discovery.js";
+import { requireCorpus } from "./_skip-if-no-corpus.js";
+
+const TESTDATA = requireCorpus();
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) { passed++; }
+  else { failed++; console.error(`  ✗ ${msg}`); }
+}
+
+function ok(msg: string) { passed++; console.log(`  ✓ ${msg}`); }
+
+// ============================================================================
+
+console.log("\n--- Session Discovery: list project sessions ---");
+{
+  const codexDir = join(TESTDATA, "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex");
+  const sessions = listSessionFiles(codexDir);
+  assert(sessions.length > 0, `found ${sessions.length} codex sessions`);
+
+  // Verify sorted by mtime (newest first)
+  for (let i = 1; i < sessions.length; i++) {
+    assert(
+      sessions[i - 1].mtime >= sessions[i].mtime,
+      `sorted by mtime: ${sessions[i - 1].sessionId.slice(0, 8)} >= ${sessions[i].sessionId.slice(0, 8)}`,
+    );
+  }
+
+  for (const s of sessions) {
+    ok(`${s.sessionId.slice(0, 12)}: ${s.size} bytes, ${s.mtime.toISOString().slice(0, 10)}`);
+  }
+}
+
+console.log("\n--- Session Discovery: list subagents ---");
+{
+  const codexSession = join(
+    TESTDATA,
+    "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex",
+    "630fd2b9-d94d-4287-8c24-e225fbedfc5c.jsonl",
+  );
+  const subagents = listSubagentFiles(codexSession);
+  assert(subagents.length > 0, `found ${subagents.length} subagent files`);
+  ok(`subagents for 630fd2b9: ${subagents.map((s) => s.sessionId.slice(0, 15)).join(", ")}`);
+}
+
+console.log("\n--- Session Discovery: list all sessions ---");
+{
+  // Use testdata as projects dir by overriding — but listAllSessionFiles uses homedir.
+  // We'll test listSessionFiles across multiple dirs instead.
+  const dirs = [
+    join(TESTDATA, "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex"),
+    join(TESTDATA, "-Users-wednesdayniemeyer--claude-skills-inspect-claude-source"),
+    join(TESTDATA, "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-sprites"),
+  ];
+
+  let total = 0;
+  for (const dir of dirs) {
+    const sessions = listSessionFiles(dir);
+    total += sessions.length;
+  }
+  assert(total > 5, `found ${total} sessions across 3 projects`);
+  ok(`${total} total sessions`);
+}
+
+console.log("\n--- Session Discovery: routing ---");
+{
+  // Project routing with explicit projectDir
+  const codexDir = join(TESTDATA, "-Users-wednesdayniemeyer-Documents-gniemeyer-Projects-codex");
+  const projectResult = resolveSessionFiles({
+    mode: "project",
+    projectDir: codexDir,
+  });
+  assert(projectResult.sessions.length > 0, `project routing: ${projectResult.sessions.length} sessions`);
+  assert(projectResult.totalCount === projectResult.sessions.length, "totalCount matches");
+  ok("project routing works");
+
+  // Project routing with subagents
+  const withSubagents = resolveSessionFiles({
+    mode: "project",
+    projectDir: codexDir,
+    includeSubagents: true,
+  });
+  assert(
+    withSubagents.sessions.length > projectResult.sessions.length,
+    `with subagents: ${withSubagents.sessions.length} > ${projectResult.sessions.length}`,
+  );
+  ok("subagent inclusion works");
+
+  // Session routing by path
+  const sessionPath = join(codexDir, "630fd2b9-d94d-4287-8c24-e225fbedfc5c.jsonl");
+  const sessionResult = resolveSessionFiles({
+    mode: "session",
+    sessionId: sessionPath,
+  });
+  assert(sessionResult.sessions.length === 1, "session routing: found 1");
+  assert(sessionResult.sessions[0].sessionId === "630fd2b9-d94d-4287-8c24-e225fbedfc5c", "correct session");
+  ok("session routing works");
+
+  // Pagination
+  const paginated = resolveSessionFiles({
+    mode: "project",
+    projectDir: codexDir,
+    limit: 1,
+    offset: 0,
+  });
+  assert(paginated.sessions.length === 1, "pagination: 1 session");
+  if (projectResult.totalCount > 1) {
+    assert(paginated.hasMore, "pagination: has more");
+    ok("pagination works");
+  }
+}
+
+// ============================================================================
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.log("❌ Some tests failed");
+  process.exit(1);
+} else {
+  console.log("✅ All tests passed");
+}

package/tests/normalize.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Tests for CC message normalization.
+ * Uses real CC session files from testdata/.
+ */
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { parseSession } from "../src/parser.js";
+import { buildRawChain } from "../src/tree.js";
+import { normalizeMessages } from "../src/normalize.js";
+import { requireCorpus } from "./_skip-if-no-corpus.js";
+
+const TESTDATA = requireCorpus();
+
+function findSessionFiles(): string[] {
+  const files: string[] = [];
+  function walk(dir: string) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "subagents") walk(full);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl") && !dir.includes("subagents")) files.push(full);
+    }
+  }
+  walk(TESTDATA);
+  return files;
+}
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string) {
+  if (condition) { passed++; }
+  else { failed++; console.error(`  ✗ ${msg}`); }
+}
+
+function ok(msg: string) { passed++; console.log(`  ✓ ${msg}`); }
+
+// ============================================================================
+
+console.log("\n--- Normalization: filter progress/system ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const chain = buildRawChain(parsed);
+    const name = basename(file, ".jsonl").slice(0, 12);
+
+    if (chain.length === 0) { ok(`${name}: empty, skip`); continue; }
+
+    const normalized = normalizeMessages(chain);
+
+    // No progress messages should remain
+    const hasProgress = normalized.some((m) => m.type === "progress");
+    assert(!hasProgress, `${name}: no progress after normalization`);
+
+    // No non-local-command system messages
+    const hasBadSystem = normalized.some(
+      (m) => m.type === "system" && m.subtype !== "local_command"
+    );
+    assert(!hasBadSystem, `${name}: no non-local system messages`);
+
+    // All messages should be user or assistant (system converted to user)
+    const allUserAssistant = normalized.every(
+      (m) => m.type === "user" || m.type === "assistant"
+    );
+    assert(allUserAssistant, `${name}: all messages are user/assistant`);
+
+    ok(`${name}: ${chain.length} → ${normalized.length} messages`);
+  }
+}
+
+console.log("\n--- Normalization: role alternation ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const chain = buildRawChain(parsed);
+    const name = basename(file, ".jsonl").slice(0, 12);
+
+    if (chain.length === 0) continue;
+
+    const normalized = normalizeMessages(chain);
+    if (normalized.length < 2) continue;
+
+    // Check: no two consecutive messages of the same role
+    let consecutiveSame = 0;
+    for (let i = 1; i < normalized.length; i++) {
+      if (normalized[i].type === normalized[i - 1].type) {
+        consecutiveSame++;
+      }
+    }
+
+    // After normalization, consecutive same-role should be rare (merging handles most cases)
+    // Log any remaining for investigation
+    if (consecutiveSame > 0) {
+      // Find which ones are consecutive
+      const pairs: string[] = [];
+      for (let i = 1; i < normalized.length; i++) {
+        if (normalized[i].type === normalized[i - 1].type) {
+          pairs.push(`[${i - 1}:${normalized[i - 1].type}, ${i}:${normalized[i].type}]`);
+        }
+      }
+      console.log(`  ⚠ ${name}: ${consecutiveSame} consecutive same-role: ${pairs.slice(0, 3).join(", ")}${pairs.length > 3 ? "..." : ""}`);
+    } else {
+      ok(`${name}: perfect role alternation (${normalized.length} msgs)`);
+    }
+  }
+}
+
+console.log("\n--- Normalization: no empty assistant content ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const chain = buildRawChain(parsed);
+    const name = basename(file, ".jsonl").slice(0, 12);
+
+    if (chain.length === 0) continue;
+
+    const normalized = normalizeMessages(chain);
+
+    // Check no assistant has empty content (except possibly the last)
+    for (let i = 0; i < normalized.length - 1; i++) {
+      const msg = normalized[i];
+      if (msg.type !== "assistant") continue;
+      const content = msg.message.content;
+      if (Array.isArray(content)) {
+        assert(content.length > 0, `${name}: assistant[${i}] has content`);
+      }
+    }
+  }
+  ok("no empty non-terminal assistant content");
+}
+
+console.log("\n--- Normalization: user messages have content ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const chain = buildRawChain(parsed);
+    const name = basename(file, ".jsonl").slice(0, 12);
+
+    if (chain.length === 0) continue;
+
+    const normalized = normalizeMessages(chain);
+
+    for (const msg of normalized) {
+      if (msg.type !== "user") continue;
+      const c = msg.message.content;
+      const hasContent =
+        (typeof c === "string" && c.length > 0) ||
+        (Array.isArray(c) && c.length > 0);
+      assert(hasContent, `${name}: user message has content`);
+    }
+  }
+  ok("all user messages have content");
+}
+
+console.log("\n--- Normalization: first message is user ---");
+{
+  const files = findSessionFiles();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const parsed = parseSession(content);
+    const chain = buildRawChain(parsed);
+    const name = basename(file, ".jsonl").slice(0, 12);
+
+    if (chain.length === 0) continue;
+
+    const normalized = normalizeMessages(chain);
+    if (normalized.length === 0) continue;
+
+    assert(
+      normalized[0].type === "user",
+      `${name}: first message is user (got ${normalized[0].type})`
+    );
+  }
+}
+
+// ============================================================================
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.log("❌ Some tests failed");
+  process.exit(1);
+} else {
+  console.log("✅ All tests passed");
+}