@gswangg/duncan-cc 0.1.0

package/src/tree.ts

@@ -0,0 +1,371 @@
+/**
+ * CC Session Tree Operations
+ * 
+ * Implements tree walk, preserved segment relinking, leaf detection,
+ * and post-processing.
+ * 
+ * Equivalent to CC's relink + walk + post-process + strip + slice pipeline
+ */
+
+import type { CCMessage, ParsedSession } from "./parser.js";
+import { isCompactBoundary } from "./parser.js";
+
+// ============================================================================
+// Preserved Segment Relinking — CC's wHY()
+// ============================================================================
+
+/**
+ * Relink preserved segments after compaction.
+ * 
+ * When compaction preserves messages (messagesToKeep), the boundary marker
+ * stores a preservedSegment with headUuid/tailUuid/anchorUuid. This function
+ * relinks the tree so preserved messages are accessible via parentUuid walk.
+ * 
+ * Mutates the messages Map in place.
+ */
+export function relinkPreservedSegments(messages: Map<string, CCMessage>): void {
+  // Find the last compact boundary and its index in insertion order
+  let lastBoundary: CCMessage | undefined;
+  let lastBoundaryIndex = -1;
+  let preservedSegment: { headUuid: string; tailUuid: string; anchorUuid: string } | undefined;
+  let index = 0;
+
+  for (const entry of messages.values()) {
+    if (isCompactBoundary(entry)) {
+      lastBoundaryIndex = index;
+      const seg = entry.compactMetadata?.preservedSegment;
+      if (seg) {
+        preservedSegment = seg;
+        lastBoundary = entry;
+      }
+    }
+    index++;
+  }
+
+  if (!preservedSegment || !lastBoundary) return;
+
+  const totalEntries = messages.size;
+  const isLastBoundary = lastBoundaryIndex === totalEntries - 1 ||
+    // Check if this is the last boundary (no later boundaries exist)
+    (() => {
+      let idx = 0;
+      let lastBIdx = -1;
+      for (const entry of messages.values()) {
+        if (isCompactBoundary(entry)) lastBIdx = idx;
+        idx++;
+      }
+      return lastBIdx === lastBoundaryIndex;
+    })();
+
+  // Identify preserved segment by walking from tail to head
+  const preservedUuids = new Set<string>();
+  if (isLastBoundary) {
+    const visited = new Set<string>();
+    let current = messages.get(preservedSegment.tailUuid);
+    let foundHead = false;
+
+    while (current && !visited.has(current.uuid)) {
+      visited.add(current.uuid);
+      preservedUuids.add(current.uuid);
+      if (current.uuid === preservedSegment.headUuid) {
+        foundHead = true;
+        break;
+      }
+      current = current.parentUuid ? messages.get(current.parentUuid) : undefined;
+    }
+
+    if (!foundHead) {
+      // Walk broken — can't relink
+      return;
+    }
+  }
+
+  if (isLastBoundary) {
+    // Relink head: head.parentUuid = anchorUuid
+    const head = messages.get(preservedSegment.headUuid);
+    if (head) {
+      messages.set(preservedSegment.headUuid, {
+        ...head,
+        parentUuid: preservedSegment.anchorUuid,
+      });
+    }
+
+    // Relink followers: messages with parentUuid === anchorUuid (except head) → parentUuid = tailUuid
+    for (const [uuid, msg] of messages) {
+      if (msg.parentUuid === preservedSegment.anchorUuid && uuid !== preservedSegment.headUuid) {
+        messages.set(uuid, {
+          ...msg,
+          parentUuid: preservedSegment.tailUuid,
+        });
+      }
+    }
+
+    // Zero out usage for assistant messages in preserved segment
+    for (const uuid of preservedUuids) {
+      const msg = messages.get(uuid);
+      if (msg?.type !== "assistant") continue;
+      messages.set(uuid, {
+        ...msg,
+        message: {
+          ...msg.message,
+          usage: {
+            ...msg.message.usage,
+            input_tokens: 0,
+            output_tokens: 0,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: 0,
+          },
+        },
+      });
+    }
+  }
+
+  // Delete pre-boundary messages not in preserved segment
+  const toDelete: string[] = [];
+  let idx = 0;
+  for (const [uuid] of messages) {
+    if (idx < lastBoundaryIndex && !preservedUuids.has(uuid)) {
+      toDelete.push(uuid);
+    }
+    idx++;
+  }
+  for (const uuid of toDelete) {
+    messages.delete(uuid);
+  }
+}
+
+// ============================================================================
+// Leaf Detection
+// ============================================================================
+
+/** Find all leaf messages (messages not referenced as parentUuid by any other) */
+export function findLeaves(messages: Map<string, CCMessage>): CCMessage[] {
+  const referenced = new Set<string>();
+  for (const msg of messages.values()) {
+    if (msg.parentUuid) referenced.add(msg.parentUuid);
+  }
+  return [...messages.values()].filter((msg) => !referenced.has(msg.uuid));
+}
+
+/** Find the "best" leaf — the latest user or assistant message that's a leaf */
+export function findBestLeaf(messages: Map<string, CCMessage>): CCMessage | undefined {
+  const leaves = findLeaves(messages);
+  let best: CCMessage | undefined;
+  let bestTime = -Infinity;
+
+  for (const leaf of leaves) {
+    // Walk up to find the first user/assistant message
+    const visited = new Set<string>();
+    let current: CCMessage | undefined = leaf;
+    while (current) {
+      if (visited.has(current.uuid)) break;
+      visited.add(current.uuid);
+      if (current.type === "user" || current.type === "assistant") {
+        const time = Date.parse(current.timestamp);
+        if (time > bestTime) {
+          bestTime = time;
+          best = current;
+        }
+        break;
+      }
+      current = current.parentUuid ? messages.get(current.parentUuid) : undefined;
+    }
+  }
+
+  return best;
+}
+
+// ============================================================================
+// Tree Walk
+// ============================================================================
+
+/**
+ * Walk parentUuid chain from leaf to root, return root→leaf order.
+ * Walks the parentUuid chain from leaf to root with cycle detection.
+ */
+export function walkChain(messages: Map<string, CCMessage>, leaf: CCMessage): CCMessage[] {
+  const chain: CCMessage[] = [];
+  const visited = new Set<string>();
+  let current: CCMessage | undefined = leaf;
+
+  while (current) {
+    if (visited.has(current.uuid)) {
+      // Cycle detected
+      break;
+    }
+    visited.add(current.uuid);
+    chain.push(current);
+    current = current.parentUuid ? messages.get(current.parentUuid) : undefined;
+  }
+
+  chain.reverse();
+  return postProcessChain(messages, chain, visited);
+}
+
+// ============================================================================
+// Post-processing
+// ============================================================================
+
+/**
+ * Post-process the chain: handle split assistant messages and orphan tool results.
+ * Post-process: handle orphan tool results, deduplicate split assistant messages.
+ */
+function postProcessChain(
+  messages: Map<string, CCMessage>,
+  chain: CCMessage[],
+  visited: Set<string>,
+): CCMessage[] {
+  // Find assistant messages with API response IDs on the chain
+  const assistants = chain.filter((m) => m.type === "assistant");
+  if (assistants.length === 0) return chain;
+
+  const byResponseId = new Map<string, CCMessage>();
+  for (const a of assistants) {
+    if (a.message.id) byResponseId.set(a.message.id, a);
+  }
+
+  // Find all assistant messages with same response IDs (potential splits)
+  const allByResponseId = new Map<string, CCMessage[]>();
+  const toolResultsByParent = new Map<string, CCMessage[]>();
+
+  for (const msg of messages.values()) {
+    if (msg.type === "assistant" && msg.message.id) {
+      const existing = allByResponseId.get(msg.message.id);
+      if (existing) existing.push(msg);
+      else allByResponseId.set(msg.message.id, [msg]);
+    } else if (
+      msg.type === "user" &&
+      msg.parentUuid &&
+      Array.isArray(msg.message.content) &&
+      msg.message.content.some((c: any) => c.type === "tool_result")
+    ) {
+      const existing = toolResultsByParent.get(msg.parentUuid);
+      if (existing) existing.push(msg);
+      else toolResultsByParent.set(msg.parentUuid, [msg]);
+    }
+  }
+
+  // For now, return chain as-is. Split merging and orphan tool result
+  // reattachment are edge cases we'll handle when we have test data for them.
+  // The core tree walk is correct.
+  return chain;
+}
+
+// ============================================================================
+// Field Stripping — remove internal-only fields
+// ============================================================================
+
+/** Strip internal fields not needed by the API */
+export function stripInternalFields(messages: CCMessage[]): CCMessage[] {
+  return messages.map((msg) => {
+    const { isSidechain, parentUuid, ...rest } = msg;
+    return rest as CCMessage;
+  });
+}
+
+// ============================================================================
+// Boundary Slicing
+// ============================================================================
+
+/** Find last compact boundary index in array */
+function findLastBoundaryIndex(messages: CCMessage[]): number {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (isCompactBoundary(messages[i])) return i;
+  }
+  return -1;
+}
+
+/** Slice from last compact boundary onward */
+export function sliceFromBoundary(messages: CCMessage[]): CCMessage[] {
+  const idx = findLastBoundaryIndex(messages);
+  if (idx === -1) return messages;
+  return messages.slice(idx);
+}
+
+// ============================================================================
+// Compaction Windows
+// ============================================================================
+
+export interface CompactionWindow {
+  windowIndex: number;
+  messages: CCMessage[];
+  modelInfo?: { provider: string; modelId: string };
+}
+
+/**
+ * Split a session's message chain into compaction windows.
+ * Each window is independently queryable.
+ * 
+ * For sessions with no compaction: single window with all messages.
+ * For sessions with N boundaries: N+1 windows.
+ */
+export function getCompactionWindows(chain: CCMessage[]): CompactionWindow[] {
+  // Find all boundary indices
+  const boundaryIndices: number[] = [];
+  for (let i = 0; i < chain.length; i++) {
+    if (isCompactBoundary(chain[i])) {
+      boundaryIndices.push(i);
+    }
+  }
+
+  const resolveModel = (start: number, end: number): { provider: string; modelId: string } | undefined => {
+    let info: { provider: string; modelId: string } | undefined;
+    for (let i = start; i < end; i++) {
+      const msg = chain[i];
+      if (msg.type === "assistant" && msg.message?.model) {
+        info = { provider: "anthropic", modelId: msg.message.model };
+      }
+    }
+    return info;
+  };
+
+  // No boundaries — single window
+  if (boundaryIndices.length === 0) {
+    const modelInfo = resolveModel(0, chain.length);
+    return chain.length > 0 ? [{ windowIndex: 0, messages: chain, modelInfo }] : [];
+  }
+
+  const windows: CompactionWindow[] = [];
+
+  // Window 0: messages before first boundary
+  const w0 = chain.slice(0, boundaryIndices[0]);
+  if (w0.length > 0) {
+    windows.push({ windowIndex: 0, messages: w0, modelInfo: resolveModel(0, boundaryIndices[0]) });
+  }
+
+  // Windows 1..N: boundary + messages until next boundary
+  for (let k = 0; k < boundaryIndices.length; k++) {
+    const start = boundaryIndices[k];
+    const end = k + 1 < boundaryIndices.length ? boundaryIndices[k + 1] : chain.length;
+    const windowMessages = chain.slice(start, end);
+    if (windowMessages.length > 0) {
+      windows.push({
+        windowIndex: k + 1,
+        messages: windowMessages,
+        modelInfo: resolveModel(0, end),
+      });
+    }
+  }
+
+  return windows;
+}
+
+// ============================================================================
+// High-level: Build session context from file content
+// ============================================================================
+
+/**
+ * Full pipeline: parse → relink → find leaf → walk → return chain.
+ * Returns the raw chain (before normalization).
+ */
+export function buildRawChain(parsed: ParsedSession): CCMessage[] {
+  // Step 1: Relink preserved segments (mutates the map)
+  relinkPreservedSegments(parsed.messages);
+
+  // Step 2: Find the best leaf
+  const leaf = findBestLeaf(parsed.messages);
+  if (!leaf) return [];
+
+  // Step 3: Walk the chain
+  return walkChain(parsed.messages, leaf);
+}

package/tests/_skip-if-no-corpus.ts

@@ -0,0 +1,12 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const TESTDATA = join(import.meta.dirname, "..", "testdata", "projects");
+
+export function requireCorpus(): string {
+  if (!existsSync(TESTDATA)) {
+    console.log("⊘ skipped (no testdata/ — corpus tests require session data)");
+    process.exit(0);
+  }
+  return TESTDATA;
+}

package/tests/compaction.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Synthetic tests for compaction boundaries, preserved segments, and windowing.
+ * Tests wHY relinking, vk slicing, and getCompactionWindows.
+ */
+
+import { parseSession } from "../src/parser.js";
+import { relinkPreservedSegments, findBestLeaf, walkChain, sliceFromBoundary, getCompactionWindows } from "../src/tree.js";
+
+let passed = 0;
+let failed = 0;
+function assert(c: boolean, m: string) { if (c) passed++; else { failed++; console.error(`  ✗ ${m}`); } }
+function ok(m: string) { passed++; console.log(`  ✓ ${m}`); }
+
+// Helper: build a JSONL session string
+function buildSession(entries: any[]): string {
+  return entries.map(e => JSON.stringify(e)).join("\n");
+}
+
+let uuid = 0;
+function id() { return `uuid-${++uuid}`; }
+
+function userMsg(uid: string, parent: string | null, text: string) {
+  return { type: "user", uuid: uid, parentUuid: parent, timestamp: new Date().toISOString(), message: { role: "user", content: text } };
+}
+
+function assistantMsg(uid: string, parent: string, text: string) {
+  return { type: "assistant", uuid: uid, parentUuid: parent, timestamp: new Date().toISOString(), message: { role: "assistant", content: [{ type: "text", text }], model: "claude-sonnet-4" } };
+}
+
+function compactBoundary(uid: string, parent: string, preserved?: { headUuid: string; tailUuid: string; anchorUuid: string }) {
+  return {
+    type: "system", subtype: "compact_boundary", uuid: uid, parentUuid: parent,
+    timestamp: new Date().toISOString(),
+    message: { role: "system", content: "Compact boundary" },
+    ...(preserved ? { compactMetadata: { preservedSegment: preserved } } : {}),
+  };
+}
+
+function summaryEntry(leafUuid: string, text: string) {
+  return { type: "summary", leafUuid, summary: text };
+}
+
+// ============================================================================
+
+console.log("\n--- No compaction: single window ---");
+{
+  const u1 = id(), a1 = id(), u2 = id(), a2 = id();
+  const content = buildSession([
+    userMsg(u1, null, "hello"),
+    assistantMsg(a1, u1, "hi"),
+    userMsg(u2, a1, "how are you"),
+    assistantMsg(a2, u2, "good"),
+  ]);
+  const parsed = parseSession(content);
+  const leaf = findBestLeaf(parsed.messages)!;
+  const chain = walkChain(parsed.messages, leaf);
+  const windows = getCompactionWindows(chain);
+
+  assert(windows.length === 1, "1 window");
+  assert(windows[0].messages.length === 4, "4 messages");
+  ok("no compaction: single window with all messages");
+}
+
+console.log("\n--- One boundary, no preserved segment ---");
+{
+  const u1 = id(), a1 = id(), b = id(), u2 = id(), a2 = id();
+  const content = buildSession([
+    userMsg(u1, null, "old message"),
+    assistantMsg(a1, u1, "old reply"),
+    compactBoundary(b, a1),
+    summaryEntry(b, "Summary of old conversation"),
+    userMsg(u2, b, "new message"),
+    assistantMsg(a2, u2, "new reply"),
+  ]);
+  const parsed = parseSession(content);
+  const leaf = findBestLeaf(parsed.messages)!;
+  const chain = walkChain(parsed.messages, leaf);
+
+  // vk slicing: should start from boundary
+  const sliced = sliceFromBoundary(chain);
+  assert(sliced[0].uuid === b, "sliced starts at boundary");
+  assert(sliced.length === 3, "boundary + 2 new messages");
+
+  const windows = getCompactionWindows(chain);
+  assert(windows.length === 2, "2 windows");
+  assert(windows[0].messages.length === 2, "window 0: old messages");
+  assert(windows[1].messages.length === 3, "window 1: boundary + new messages");
+  ok("one boundary: correct windowing");
+}
+
+console.log("\n--- One boundary with preserved segment ---");
+{
+  const u1 = id(), a1 = id(), u2 = id(), a2 = id();
+  const b = id(), u3 = id(), a3 = id();
+
+  // u1 → a1 → u2 → a2 → boundary(preserves u2,a2) → u3 → a3
+  const content = buildSession([
+    userMsg(u1, null, "very old"),
+    assistantMsg(a1, u1, "very old reply"),
+    userMsg(u2, a1, "kept message"),
+    assistantMsg(a2, u2, "kept reply"),
+    compactBoundary(b, a2, { headUuid: u2, tailUuid: a2, anchorUuid: b }),
+    userMsg(u3, b, "new message"),
+    assistantMsg(a3, u3, "new reply"),
+  ]);
+  const parsed = parseSession(content);
+
+  // Before relinking
+  assert(parsed.messages.has(u1), "u1 exists before relink");
+
+  // Relink
+  relinkPreservedSegments(parsed.messages);
+
+  // After relinking: u1 and a1 should be deleted (pre-boundary, not preserved)
+  assert(!parsed.messages.has(u1), "u1 deleted after relink");
+  assert(!parsed.messages.has(a1), "a1 deleted after relink");
+
+  // Preserved messages should still exist
+  assert(parsed.messages.has(u2), "u2 preserved");
+  assert(parsed.messages.has(a2), "a2 preserved");
+
+  // u2 should now point to boundary as parent (relinked)
+  const u2msg = parsed.messages.get(u2)!;
+  assert(u2msg.parentUuid === b, "u2.parentUuid = boundary (relinked)");
+
+  // u3 should point to a2 (tail of preserved segment)
+  const u3msg = parsed.messages.get(u3)!;
+  assert(u3msg.parentUuid === a2, "u3.parentUuid = a2 (relinked to tail)");
+
+  // Walk should work: boundary → u2 → a2 → u3 → a3
+  // Wait, the walk goes from leaf (a3) up: a3 → u3 → a2 → u2 → boundary
+  const leaf = findBestLeaf(parsed.messages)!;
+  const chain = walkChain(parsed.messages, leaf);
+
+  assert(chain.length === 5, `chain length 5 (got ${chain.length})`);
+  assert(chain[0].uuid === b, "chain starts at boundary");
+  assert(chain[1].uuid === u2, "chain[1] = preserved u2");
+  assert(chain[2].uuid === a2, "chain[2] = preserved a2");
+  assert(chain[3].uuid === u3, "chain[3] = new u3");
+  assert(chain[4].uuid === a3, "chain[4] = new a3");
+
+  ok("preserved segment: relinked correctly, walk correct");
+}
+
+console.log("\n--- Two boundaries: three windows ---");
+{
+  const u1 = id(), a1 = id(), b1 = id();
+  const u2 = id(), a2 = id(), b2 = id();
+  const u3 = id(), a3 = id();
+
+  const content = buildSession([
+    userMsg(u1, null, "first"),
+    assistantMsg(a1, u1, "first reply"),
+    compactBoundary(b1, a1),
+    userMsg(u2, b1, "second"),
+    assistantMsg(a2, u2, "second reply"),
+    compactBoundary(b2, a2),
+    userMsg(u3, b2, "third"),
+    assistantMsg(a3, u3, "third reply"),
+  ]);
+  const parsed = parseSession(content);
+  const leaf = findBestLeaf(parsed.messages)!;
+  const chain = walkChain(parsed.messages, leaf);
+
+  const windows = getCompactionWindows(chain);
+  assert(windows.length === 3, `3 windows (got ${windows.length})`);
+  assert(windows[0].messages.length === 2, "window 0: 2 msgs (u1, a1)");
+  assert(windows[1].messages.length === 3, "window 1: 3 msgs (b1, u2, a2)");
+  assert(windows[2].messages.length === 3, "window 2: 3 msgs (b2, u3, a3)");
+
+  // vk should slice from last boundary
+  const sliced = sliceFromBoundary(chain);
+  assert(sliced[0].uuid === b2, "sliced from last boundary");
+  assert(sliced.length === 3, "3 messages after last boundary");
+
+  ok("two boundaries: three windows, correct slicing");
+}
+
+console.log("\n--- Model extraction per window ---");
+{
+  const u1 = id(), a1 = id(), b1 = id(), u2 = id(), a2 = id();
+
+  // a1 uses opus, a2 uses sonnet
+  const content = buildSession([
+    userMsg(u1, null, "hello"),
+    { ...assistantMsg(a1, u1, "hi"), message: { role: "assistant", content: [{ type: "text", text: "hi" }], model: "claude-opus-4-6" } },
+    compactBoundary(b1, a1),
+    userMsg(u2, b1, "hello again"),
+    { ...assistantMsg(a2, u2, "hi again"), message: { role: "assistant", content: [{ type: "text", text: "hi again" }], model: "claude-sonnet-4-20250514" } },
+  ]);
+  const parsed = parseSession(content);
+  const leaf = findBestLeaf(parsed.messages)!;
+  const chain = walkChain(parsed.messages, leaf);
+  const windows = getCompactionWindows(chain);
+
+  assert(windows[0].modelInfo?.modelId === "claude-opus-4-6", "window 0: opus");
+  assert(windows[1].modelInfo?.modelId === "claude-sonnet-4-20250514", "window 1: sonnet");
+  ok("model extraction per window");
+}
+
+// ============================================================================
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed > 0) { console.log("❌ Some tests failed"); process.exit(1); }
+else console.log("✅ All tests passed");