@mseep/claudian 2.0.25

package/src/providers/claude/history/ClaudeHistoryStore.ts

@@ -0,0 +1,170 @@
+import { isSubagentToolName } from '../../../core/tools/toolNames';
+import type { ChatMessage, SubagentInfo, ToolCallInfo } from '../../../core/types';
+import { buildAsyncSubagentInfo } from './sdkAsyncSubagent';
+import { filterActiveBranch } from './sdkBranchFilter';
+import type { SDKSessionLoadResult } from './sdkHistoryTypes';
+import {
+  collectAsyncSubagentResults,
+  collectStructuredPatchResults,
+  collectToolResults,
+  extractXmlTag,
+  hydrateFallbackAskUserAnswers,
+  hydrateStructuredToolResults,
+  isSystemInjectedMessage,
+  mergeAssistantMessage,
+  parseSDKMessageToChat,
+} from './sdkMessageParsing';
+import {
+  deleteSDKSession,
+  encodeVaultPathForSDK,
+  getSDKProjectsPath,
+  getSDKSessionPath,
+  isValidSessionId,
+  readSDKSession,
+  sdkSessionExists,
+} from './sdkSessionPaths';
+import {
+  isValidAgentId,
+  loadSubagentFinalResult,
+  loadSubagentToolCalls,
+} from './sdkSubagentSidecar';
+
+export type {
+  AsyncSubagentResult,
+  ResolvedAsyncStatus,
+  SDKNativeContentBlock,
+  SDKNativeMessage,
+  SDKSessionLoadResult,
+  SDKSessionReadResult,
+} from './sdkHistoryTypes';
+export {
+  collectAsyncSubagentResults,
+  deleteSDKSession,
+  encodeVaultPathForSDK,
+  extractXmlTag,
+  filterActiveBranch,
+  getSDKProjectsPath,
+  getSDKSessionPath,
+  isValidSessionId,
+  loadSubagentFinalResult,
+  loadSubagentToolCalls,
+  parseSDKMessageToChat,
+  readSDKSession,
+  sdkSessionExists,
+};
+export {
+  extractAgentIdFromToolUseResult,
+  resolveToolUseResultStatus,
+} from './sdkAsyncSubagent';
+
+export async function loadSDKSessionMessages(
+  vaultPath: string,
+  sessionId: string,
+  resumeAtMessageId?: string
+): Promise<SDKSessionLoadResult> {
+  const result = await readSDKSession(vaultPath, sessionId);
+
+  if (result.error) {
+    return { messages: [], skippedLines: result.skippedLines, error: result.error };
+  }
+
+  const filteredEntries = filterActiveBranch(result.messages, resumeAtMessageId);
+
+  const toolResults = collectToolResults(filteredEntries);
+  const toolUseResults = collectStructuredPatchResults(filteredEntries);
+  const asyncSubagentResults = collectAsyncSubagentResults(filteredEntries);
+
+  const chatMessages: ChatMessage[] = [];
+  let pendingAssistant: ChatMessage | null = null;
+
+  // Merge consecutive assistant messages until an actual user message appears
+  for (const sdkMsg of filteredEntries) {
+    if (isSystemInjectedMessage(sdkMsg)) continue;
+
+    // Skip synthetic assistant messages (e.g., "No response requested." after /compact)
+    if (sdkMsg.type === 'assistant' && sdkMsg.message?.model === '<synthetic>') continue;
+
+    const chatMsg = parseSDKMessageToChat(sdkMsg, toolResults);
+    if (!chatMsg) continue;
+
+    if (chatMsg.role === 'assistant') {
+      // context_compacted must not merge with previous assistant (it's a standalone separator)
+      const isCompactBoundary = chatMsg.contentBlocks?.some(b => b.type === 'context_compacted');
+      if (isCompactBoundary) {
+        if (pendingAssistant) {
+          chatMessages.push(pendingAssistant);
+        }
+        chatMessages.push(chatMsg);
+        pendingAssistant = null;
+      } else if (pendingAssistant) {
+        mergeAssistantMessage(pendingAssistant, chatMsg);
+      } else {
+        pendingAssistant = chatMsg;
+      }
+    } else {
+      if (pendingAssistant) {
+        chatMessages.push(pendingAssistant);
+        pendingAssistant = null;
+      }
+      chatMessages.push(chatMsg);
+    }
+  }
+
+  if (pendingAssistant) {
+    chatMessages.push(pendingAssistant);
+  }
+
+  hydrateStructuredToolResults(chatMessages, toolUseResults);
+  hydrateFallbackAskUserAnswers(chatMessages);
+
+  // Build SubagentInfo for async Agent tool calls from toolUseResult + queue-operation data
+  if (toolUseResults.size > 0 || asyncSubagentResults.size > 0) {
+    const sidecarLoads: Array<{ subagent: SubagentInfo; promise: Promise<ToolCallInfo[]> }> = [];
+
+    for (const msg of chatMessages) {
+      if (msg.role !== 'assistant' || !msg.toolCalls) continue;
+      for (const toolCall of msg.toolCalls) {
+        if (!isSubagentToolName(toolCall.name)) continue;
+        if (toolCall.subagent) continue;
+        if (toolCall.input?.run_in_background !== true) continue;
+
+        const toolUseResult = toolUseResults.get(toolCall.id);
+        const subagent = buildAsyncSubagentInfo(
+          toolCall,
+          toolUseResult,
+          asyncSubagentResults
+        );
+        if (subagent) {
+          toolCall.subagent = subagent;
+          if (subagent.result !== undefined) {
+            toolCall.result = subagent.result;
+          }
+          toolCall.status = subagent.status;
+
+          // Load tool calls from subagent sidecar JSONL in parallel
+          if (subagent.agentId && isValidAgentId(subagent.agentId)) {
+            sidecarLoads.push({
+              subagent,
+              promise: loadSubagentToolCalls(vaultPath, sessionId, subagent.agentId),
+            });
+          }
+        }
+      }
+    }
+
+    // Hydrate subagent tool calls from sidecar files
+    if (sidecarLoads.length > 0) {
+      const results = await Promise.all(sidecarLoads.map(s => s.promise));
+      for (let i = 0; i < sidecarLoads.length; i++) {
+        const toolCalls = results[i];
+        if (toolCalls.length > 0) {
+          sidecarLoads[i].subagent.toolCalls = toolCalls;
+        }
+      }
+    }
+  }
+
+  chatMessages.sort((a, b) => a.timestamp - b.timestamp);
+
+  return { messages: chatMessages, skippedLines: result.skippedLines };
+}

package/src/providers/claude/history/sdkAsyncSubagent.ts

@@ -0,0 +1,92 @@
+import type { SubagentInfo, ToolCallInfo } from '../../../core/types';
+import type { AsyncSubagentResult, ResolvedAsyncStatus } from './sdkHistoryTypes';
+
+export function extractAgentIdFromToolUseResult(toolUseResult: unknown): string | null {
+  if (!toolUseResult || typeof toolUseResult !== 'object') {
+    return null;
+  }
+
+  const record = toolUseResult as Record<string, unknown>;
+  const directAgentId = record.agentId ?? record.agent_id;
+  if (typeof directAgentId === 'string' && directAgentId.length > 0) {
+    return directAgentId;
+  }
+
+  const data = record.data;
+  if (data && typeof data === 'object') {
+    const nested = data as Record<string, unknown>;
+    const nestedAgentId = nested.agent_id ?? nested.agentId;
+    if (typeof nestedAgentId === 'string' && nestedAgentId.length > 0) {
+      return nestedAgentId;
+    }
+  }
+
+  return null;
+}
+
+export function resolveToolUseResultStatus(
+  toolUseResult: unknown,
+  fallbackStatus: ResolvedAsyncStatus,
+): ResolvedAsyncStatus {
+  if (!toolUseResult || typeof toolUseResult !== 'object') {
+    return fallbackStatus;
+  }
+
+  const record = toolUseResult as Record<string, unknown>;
+  const rawStatus = record.retrieval_status ?? record.status;
+  const status = typeof rawStatus === 'string' ? rawStatus.toLowerCase() : '';
+
+  if (status === 'error' || status === 'failed' || status === 'stopped' || status === 'killed') {
+    return 'error';
+  }
+  if (status === 'completed' || status === 'success') {
+    return 'completed';
+  }
+  if (record.isAsync === true || status === 'async_launched') {
+    return 'running';
+  }
+
+  return fallbackStatus;
+}
+
+export function buildAsyncSubagentInfo(
+  toolCall: ToolCallInfo,
+  toolUseResult: unknown,
+  asyncResults: Map<string, AsyncSubagentResult>,
+): SubagentInfo | null {
+  const agentId = extractAgentIdFromToolUseResult(toolUseResult);
+  if (!agentId) {
+    return null;
+  }
+
+  const queueResult = asyncResults.get(agentId);
+  const description = (toolCall.input?.description as string) || 'Background task';
+  const prompt = (toolCall.input?.prompt as string) || '';
+  const finalResult = queueResult?.result ?? toolCall.result;
+
+  let toolCallFallback: ResolvedAsyncStatus = 'running';
+  if (toolCall.status === 'error') {
+    toolCallFallback = 'error';
+  } else if (toolCall.status === 'completed') {
+    toolCallFallback = 'completed';
+  }
+
+  const status = queueResult
+    ? resolveToolUseResultStatus({ status: queueResult.status }, 'completed')
+    : resolveToolUseResultStatus(toolUseResult, toolCallFallback);
+
+  const taskStatus = status === 'orphaned' ? 'error' : status;
+
+  return {
+    id: toolCall.id,
+    description,
+    prompt,
+    mode: 'async',
+    isExpanded: false,
+    status: taskStatus,
+    toolCalls: [],
+    asyncStatus: status,
+    agentId,
+    result: finalResult,
+  };
+}

package/src/providers/claude/history/sdkBranchFilter.ts

@@ -0,0 +1,271 @@
+import type { SDKNativeMessage } from './sdkHistoryTypes';
+
+export function filterActiveBranch(
+  entries: SDKNativeMessage[],
+  resumeAtMessageId?: string,
+): SDKNativeMessage[] {
+  if (entries.length === 0) {
+    return [];
+  }
+
+  function isRealUserBranchChild(entry: SDKNativeMessage | undefined): boolean {
+    return !!entry
+      && entry.type === 'user'
+      && !('toolUseResult' in entry)
+      && !entry.isMeta
+      && !('sourceToolUseID' in entry);
+  }
+
+  function isDirectRealUserBranchChild(parentUuid: string, entry: SDKNativeMessage | undefined): boolean {
+    return !!entry && entry.parentUuid === parentUuid && isRealUserBranchChild(entry);
+  }
+
+  const seen = new Set<string>();
+  const deduped: SDKNativeMessage[] = [];
+  for (const entry of entries) {
+    if (entry.uuid) {
+      if (seen.has(entry.uuid)) {
+        continue;
+      }
+      seen.add(entry.uuid);
+    }
+    deduped.push(entry);
+  }
+
+  const progressUuids = new Set<string>();
+  const progressParentOf = new Map<string, string | null>();
+  for (const entry of deduped) {
+    if ((entry.type as string) === 'progress' && entry.uuid) {
+      progressUuids.add(entry.uuid);
+      progressParentOf.set(entry.uuid, entry.parentUuid ?? null);
+    }
+  }
+
+  function resolveParent(parentUuid: string | null | undefined): string | null | undefined {
+    if (!parentUuid) {
+      return parentUuid;
+    }
+
+    let current: string | null = parentUuid;
+    let guard = progressUuids.size + 1;
+    while (current && progressUuids.has(current)) {
+      if (--guard < 0) {
+        break;
+      }
+      current = progressParentOf.get(current) ?? null;
+    }
+
+    return current;
+  }
+
+  const conversationEntries = deduped.filter(entry => (entry.type as string) !== 'progress');
+  const byUuid = new Map<string, SDKNativeMessage>();
+  const childrenOf = new Map<string, Set<string>>();
+
+  for (const entry of conversationEntries) {
+    if (entry.uuid) {
+      byUuid.set(entry.uuid, entry);
+    }
+
+    const effectiveParent = resolveParent(entry.parentUuid) ?? null;
+    if (effectiveParent && entry.uuid) {
+      let children = childrenOf.get(effectiveParent);
+      if (!children) {
+        children = new Set();
+        childrenOf.set(effectiveParent, children);
+      }
+      children.add(entry.uuid);
+    }
+  }
+
+  function findLatestLeaf(): SDKNativeMessage | undefined {
+    for (let i = conversationEntries.length - 1; i >= 0; i--) {
+      const uuid = conversationEntries[i].uuid;
+      if (uuid && !childrenOf.has(uuid)) {
+        return conversationEntries[i];
+      }
+    }
+    return undefined;
+  }
+
+  const latestLeaf = findLatestLeaf();
+  const latestBranchUuids = new Set<string>();
+  const activeChildOf = new Map<string, string>();
+
+  let latestCurrent = latestLeaf;
+  while (latestCurrent?.uuid) {
+    latestBranchUuids.add(latestCurrent.uuid);
+    const parent = resolveParent(latestCurrent.parentUuid);
+    if (parent) {
+      activeChildOf.set(parent, latestCurrent.uuid);
+    }
+    latestCurrent = parent ? byUuid.get(parent) : undefined;
+  }
+
+  const conversationContentCache = new Map<string, boolean>();
+  function hasConversationContent(uuid: string): boolean {
+    const cached = conversationContentCache.get(uuid);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const entry = byUuid.get(uuid);
+    let result = false;
+    if (entry?.type === 'assistant') {
+      result = true;
+    } else if (entry?.type === 'user' && !entry.isMeta && !('sourceToolUseID' in entry)) {
+      result = true;
+    } else {
+      const children = childrenOf.get(uuid);
+      if (children) {
+        for (const childUuid of children) {
+          if (hasConversationContent(childUuid)) {
+            result = true;
+            break;
+          }
+        }
+      }
+    }
+
+    conversationContentCache.set(uuid, result);
+    return result;
+  }
+
+  const hasBranching = [...latestBranchUuids].some(uuid => {
+    const children = childrenOf.get(uuid);
+    if (!children || children.size <= 1) {
+      return false;
+    }
+
+    const activeChildUuid = activeChildOf.get(uuid);
+    let sawRealUserChild = false;
+    let sawAlternateConversationChild = false;
+
+    for (const childUuid of children) {
+      const child = byUuid.get(childUuid);
+      if (isDirectRealUserBranchChild(uuid, child)) {
+        sawRealUserChild = true;
+      }
+      if (childUuid !== activeChildUuid && hasConversationContent(childUuid)) {
+        sawAlternateConversationChild = true;
+      }
+      if (sawRealUserChild && sawAlternateConversationChild) {
+        return true;
+      }
+    }
+
+    return false;
+  });
+
+  let leaf: SDKNativeMessage | undefined;
+  if (hasBranching) {
+    leaf = latestLeaf;
+    if (resumeAtMessageId && leaf?.uuid && byUuid.has(resumeAtMessageId)) {
+      let current: SDKNativeMessage | undefined = leaf;
+      while (current?.uuid) {
+        if (current.uuid === resumeAtMessageId) {
+          leaf = current;
+          break;
+        }
+        const parent = resolveParent(current.parentUuid);
+        current = parent ? byUuid.get(parent) : undefined;
+      }
+    }
+  } else if (resumeAtMessageId) {
+    leaf = byUuid.get(resumeAtMessageId);
+  } else {
+    return conversationEntries;
+  }
+
+  if (!leaf?.uuid) {
+    return conversationEntries;
+  }
+
+  const activeUuids = new Set<string>();
+  let current: SDKNativeMessage | undefined = leaf;
+  while (current?.uuid) {
+    activeUuids.add(current.uuid);
+    const parent = resolveParent(current.parentUuid);
+    current = parent ? byUuid.get(parent) : undefined;
+  }
+
+  if (hasBranching) {
+    const ancestorUuids = [...activeUuids];
+    const pending: string[] = [];
+
+    for (const uuid of ancestorUuids) {
+      const children = childrenOf.get(uuid);
+      if (!children || children.size <= 1) {
+        continue;
+      }
+
+      const activeChildUuid = activeChildOf.get(uuid);
+      if (activeChildUuid && isDirectRealUserBranchChild(uuid, byUuid.get(activeChildUuid))) {
+        continue;
+      }
+
+      for (const childUuid of children) {
+        if (activeUuids.has(childUuid)) {
+          continue;
+        }
+
+        const child = byUuid.get(childUuid);
+        if (!child || isRealUserBranchChild(child)) {
+          continue;
+        }
+
+        activeUuids.add(childUuid);
+        pending.push(childUuid);
+      }
+    }
+
+    while (pending.length > 0) {
+      const parentUuid = pending.pop()!;
+      const children = childrenOf.get(parentUuid);
+      if (!children) {
+        continue;
+      }
+
+      for (const childUuid of children) {
+        if (activeUuids.has(childUuid)) {
+          continue;
+        }
+
+        const child = byUuid.get(childUuid);
+        if (!child || isRealUserBranchChild(child)) {
+          continue;
+        }
+
+        activeUuids.add(childUuid);
+        pending.push(childUuid);
+      }
+    }
+  }
+
+  const entryCount = conversationEntries.length;
+  const prevIsActive = new Array<boolean>(entryCount);
+  const nextIsActive = new Array<boolean>(entryCount);
+
+  let lastPrevActive = false;
+  for (let i = 0; i < entryCount; i++) {
+    if (conversationEntries[i].uuid) {
+      lastPrevActive = activeUuids.has(conversationEntries[i].uuid!);
+    }
+    prevIsActive[i] = lastPrevActive;
+  }
+
+  let lastNextActive = false;
+  for (let i = entryCount - 1; i >= 0; i--) {
+    if (conversationEntries[i].uuid) {
+      lastNextActive = activeUuids.has(conversationEntries[i].uuid!);
+    }
+    nextIsActive[i] = lastNextActive;
+  }
+
+  return conversationEntries.filter((entry, idx) => {
+    if (entry.uuid) {
+      return activeUuids.has(entry.uuid);
+    }
+    return prevIsActive[idx] && nextIsActive[idx];
+  });
+}

package/src/providers/claude/history/sdkHistoryTypes.ts

@@ -0,0 +1,61 @@
+import type { AsyncSubagentStatus, ChatMessage } from '../../../core/types';
+
+export interface SDKSessionReadResult {
+  messages: SDKNativeMessage[];
+  skippedLines: number;
+  error?: string;
+}
+
+/** Stored in session JSONL files. Based on Claude Agent SDK internal format. */
+export interface SDKNativeMessage {
+  type: 'user' | 'assistant' | 'system' | 'result' | 'file-history-snapshot' | 'queue-operation';
+  parentUuid?: string | null;
+  sessionId?: string;
+  uuid?: string;
+  timestamp?: string;
+  requestId?: string;
+  message?: {
+    role?: string;
+    content?: string | SDKNativeContentBlock[];
+    model?: string;
+  };
+  subtype?: string;
+  duration_ms?: number;
+  duration_api_ms?: number;
+  toolUseResult?: unknown;
+  sourceToolAssistantUUID?: string;
+  sourceToolUseID?: string;
+  isMeta?: boolean;
+  operation?: string;
+  content?: string;
+}
+
+export interface SDKNativeContentBlock {
+  type: 'text' | 'tool_use' | 'tool_result' | 'thinking' | 'image';
+  text?: string;
+  thinking?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: unknown;
+  is_error?: boolean;
+  source?: {
+    type: 'base64';
+    media_type: string;
+    data: string;
+  };
+}
+
+export interface SDKSessionLoadResult {
+  messages: ChatMessage[];
+  skippedLines: number;
+  error?: string;
+}
+
+export interface AsyncSubagentResult {
+  result: string;
+  status: string;
+}
+
+export type ResolvedAsyncStatus = Exclude<AsyncSubagentStatus, 'pending'>;