ocwatch 0.4.0 → 0.6.0

package/src/server/services/sessionContext.ts

@@ -0,0 +1,97 @@
+import type { SessionMetadata, MessageMeta, PartMeta } from "../../shared/types";
+import { MESSAGE_SCAN_LIMIT } from "../../shared/constants";
+import {
+  queryMessages,
+  queryParts,
+} from "../storage/queries";
+import {
+  toMessageMeta as parseMessageRow,
+  toPartMeta as parsePartRow,
+} from "./parsing";
+
+export interface SessionContext {
+  allowedSessionIds: Set<string>;
+  sessionById: Map<string, SessionMetadata>;
+  messagesBySession: Map<string, MessageMeta[]>;
+  partsBySession: Map<string, PartMeta[]>;
+  childrenBySession: Map<string, SessionMetadata[]>;
+}
+
+interface SessionContextSeed {
+  messagesBySession?: Map<string, MessageMeta[]>;
+  partsBySession?: Map<string, PartMeta[]>;
+}
+
+export function createSessionContext(allSessions: SessionMetadata[], seed: SessionContextSeed = {}): SessionContext {
+  const sessionById = new Map<string, SessionMetadata>();
+  const childrenBySession = new Map<string, SessionMetadata[]>();
+  for (const session of allSessions) {
+    sessionById.set(session.id, session);
+    if (!session.parentID) {
+      continue;
+    }
+
+    const siblings = childrenBySession.get(session.parentID);
+    if (siblings) {
+      siblings.push(session);
+    } else {
+      childrenBySession.set(session.parentID, [session]);
+    }
+  }
+
+  for (const children of childrenBySession.values()) {
+    children.sort((a, b) => {
+      const createdDiff = a.createdAt.getTime() - b.createdAt.getTime();
+      if (createdDiff !== 0) {
+        return createdDiff;
+      }
+
+      return a.id.localeCompare(b.id);
+    });
+  }
+
+  return {
+    allowedSessionIds: new Set(allSessions.map((session) => session.id)),
+    sessionById,
+    messagesBySession: new Map<string, MessageMeta[]>(seed.messagesBySession),
+    partsBySession: new Map<string, PartMeta[]>(seed.partsBySession),
+    childrenBySession,
+  };
+}
+
+export function getSessionFromContext(sessionId: string, context: SessionContext): SessionMetadata | undefined {
+  return context.sessionById.get(sessionId);
+}
+
+export function getSessionMessages(sessionId: string, context: SessionContext): MessageMeta[] {
+  const cached = context.messagesBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
+
+  const messages = queryMessages(sessionId, MESSAGE_SCAN_LIMIT).map(parseMessageRow);
+  context.messagesBySession.set(sessionId, messages);
+  return messages;
+}
+
+export function getSessionParts(sessionId: string, context: SessionContext): PartMeta[] {
+  const cached = context.partsBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
+
+  const parts = queryParts(sessionId).map(parsePartRow);
+  context.partsBySession.set(sessionId, parts);
+  return parts;
+}
+
+export function getSessionChildren(sessionId: string, context: SessionContext): SessionMetadata[] {
+  const cached = context.childrenBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
+
+  const children: SessionMetadata[] = [];
+  context.childrenBySession.set(sessionId, children);
+  return children;
+}

package/src/server/services/sessionService.ts

@@ -1,187 +1,92 @@
-import type { 
-  SessionMetadata, 
-  MessageMeta, 
-  ActivitySession, 
-  TreeNode, 
-  TreeEdge, 
-  SessionTree, 
-  AgentPhase,
+import type {
+  SessionMetadata,
+  ActivitySession,
   PartMeta,
   SessionStatus,
+  ToolCallSummary,
 } from "../../shared/types";
 import { MAX_RECURSION_DEPTH } from "../../shared/constants";
-import { listMessages } from "../storage/messageParser";
-import { 
-  getPartsForSession, 
+import {
+  formatCurrentAction,
+  isPendingToolCall,
+  generateActivityMessage,
   getSessionActivityState,
-  isPendingToolCall, 
-  getToolCallsForSession, 
-  generateActivityMessage
-} from "../storage/partParser";
-import { getSessionStatus, getSessionStatusInfo, getStatusFromTimestamp, type SessionStatusInfo } from "../utils/sessionStatus";
-import { deriveActivityType } from "../storage/partParser";
-
-export function isAssistantFinished(messages: MessageMeta[]): boolean {
-  if (messages.length === 0) {
-    return false;
-  }
-
-  const lastMessage = messages.reduce((latest, current) =>
-    current.createdAt.getTime() > latest.createdAt.getTime() ? current : latest
-  );
-
-  return lastMessage.role === "assistant" && lastMessage.finish === "stop";
-}
+  deriveActivityType,
+  detectAgentPhases,
+  isAssistantFinished,
+  getSessionStatusInfo,
+  type SessionStatusInfo,
+} from "../logic";
+import { getStatusFromTimestamp } from "../utils/sessionStatus";
+import {
+  getLatestAssistantMessage,
+  getMostRecentPendingPart,
+} from "./parsing";
+import {
+  type SessionContext,
+  createSessionContext,
+  getSessionFromContext,
+  getSessionMessages,
+  getSessionParts,
+  getSessionChildren,
+} from "./sessionContext";
+
+export { detectAgentPhases, isAssistantFinished };
 
-function getLatestAssistantMessage(messages: MessageMeta[]): MessageMeta | undefined {
-  return messages
-    .filter((message) => message.role === "assistant")
-    .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())[0];
-}
-
-function getMostRecentPendingPart(parts: PartMeta[]): PartMeta | undefined {
-  return parts
-    .filter((part) => isPendingToolCall(part))
-    .sort((a, b) => (b.startedAt?.getTime() || 0) - (a.startedAt?.getTime() || 0))[0];
-}
 
 function countBlockingChildren(statuses: SessionStatus[]): number {
   return statuses.filter((status) => status === "working" || status === "waiting").length;
 }
 
-export function detectAgentPhases(messages: MessageMeta[]): AgentPhase[] {
-  const sorted = messages
-    .filter(m => m.role === 'assistant' && m.agent)
-    .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-  
-  if (sorted.length === 0) return [];
-  
-  const phases: AgentPhase[] = [];
-  let currentPhase: AgentPhase | null = null;
-  
-  for (const msg of sorted) {
-    if (!currentPhase || currentPhase.agent !== msg.agent) {
-      if (currentPhase) phases.push(currentPhase);
-      currentPhase = {
-        agent: msg.agent!,
-        startTime: msg.createdAt,
-        endTime: msg.createdAt,
-        tokens: msg.tokens || 0,
-        messageCount: 1,
-      };
-    } else {
-      currentPhase.endTime = msg.createdAt;
-      currentPhase.tokens += msg.tokens || 0;
-      currentPhase.messageCount++;
-    }
-  }
-  if (currentPhase) phases.push(currentPhase);
-  
-  return phases;
-}
-
-export function buildAgentHierarchy(messages: MessageMeta[]): Record<string, string[]> {
-  const hierarchy: Record<string, string[]> = {};
 
-  for (const msg of messages) {
-    if (msg.agent && msg.parentID) {
-      const parentMsg = messages.find((m) => m.id === msg.parentID);
-      if (parentMsg?.agent) {
-        if (!hierarchy[parentMsg.agent]) {
-          hierarchy[parentMsg.agent] = [];
-        }
-        if (!hierarchy[parentMsg.agent].includes(msg.agent)) {
-          hierarchy[parentMsg.agent].push(msg.agent);
-        }
+function buildToolCalls(parts: PartMeta[], messageAgent: Map<string, string>): ToolCallSummary[] {
+  const toolCalls = parts
+    .filter((part) => part.type === "tool" && part.tool)
+    .map((part): ToolCallSummary => {
+      let state: "pending" | "complete" | "error" = "complete";
+      if (isPendingToolCall(part)) {
+        state = "pending";
+      } else if (part.state === "error" || part.state === "failed") {
+        state = "error";
       }
-    }
-  }
-
-  return hierarchy;
-}
 
-export async function buildSessionTree(
-  rootSessionID: string,
-  allSessions: SessionMetadata[]
-): Promise<SessionTree> {
-  const nodes: TreeNode[] = [];
-  const edges: TreeEdge[] = [];
-  const visited = new Set<string>();
-
-  async function processSession(sessionID: string, depth = 0) {
-    if (depth > MAX_RECURSION_DEPTH) {
-      console.warn(`Max recursion depth reached for session ${sessionID}`);
-      return;
-    }
-    if (visited.has(sessionID)) {
-      return;
-    }
-    visited.add(sessionID);
-
-    const session = allSessions.find((s) => s.id === sessionID);
-    if (!session) {
-      return;
-    }
-
-    const messages = await listMessages(sessionID);
-    const lastAssistantFinished = isAssistantFinished(messages);
-    const isSubagent = !!session.parentID;
-    const status = getSessionStatus(messages, false, undefined, undefined, lastAssistantFinished, isSubagent);
-
-    const lastMessage = messages.sort(
-      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-    )[0];
-
-    nodes.push({
-      id: session.id,
-      data: {
-        title: session.title,
-        agent: lastMessage?.agent,
-        model: lastMessage?.modelID,
-        isActive: status === "working" || status === "idle",
-      },
+      return {
+        id: part.id,
+        name: part.tool || "unknown",
+        state,
+        summary: formatCurrentAction(part) || part.tool || "Unknown tool",
+        input: part.input || {},
+        error: part.error,
+        timestamp: (part.completedAt || part.startedAt)?.toISOString() || "",
+        agentName: messageAgent.get(part.messageID) || "unknown",
+      };
     });
 
-    if (session.parentID) {
-      edges.push({
-        source: session.parentID,
-        target: session.id,
-      });
-      await processSession(session.parentID, depth + 1);
-    }
-
-    const children = allSessions.filter((s) => s.parentID === sessionID);
-    await Promise.all(
-      children.map((child) => {
-        edges.push({
-          source: sessionID,
-          target: child.id,
-        });
-        return processSession(child.id, depth + 1);
-      })
-    );
-  }
-
-  await processSession(rootSessionID, 0);
+  toolCalls.sort((a, b) => {
+    const timeA = new Date(a.timestamp).getTime();
+    const timeB = new Date(b.timestamp).getTime();
+    return timeB - timeA;
+  });
 
-  return { nodes, edges };
+  return toolCalls.slice(0, 50);
 }
 
 export async function getSessionHierarchy(
   rootSessionId: string,
-  allSessions: SessionMetadata[]
+  allSessions: SessionMetadata[],
+  contextArg?: SessionContext,
 ): Promise<ActivitySession[]> {
   const result: ActivitySession[] = [];
   const processed = new Set<string>();
+  const context = contextArg ?? createSessionContext(allSessions);
 
-  const rootSession = allSessions.find((s) => s.id === rootSessionId);
+  const rootSession = getSessionFromContext(rootSessionId, context);
   if (!rootSession) return result;
 
-  const rootMessages = await listMessages(rootSessionId);
+  const rootMessages = getSessionMessages(rootSessionId, context);
   const phases = detectAgentPhases(rootMessages);
-  const childSessions = allSessions.filter((s) => s.parentID === rootSessionId);
+  const childSessions = getSessionChildren(rootSessionId, context);
 
-  // Build messageAgent map for tool calls
   const messageAgent = new Map<string, string>();
   for (const msg of rootMessages) {
     if (msg.agent) {
@@ -191,30 +96,28 @@ export async function getSessionHierarchy(
 
   if (phases.length <= 1) {
     const latestAssistantMsg = getLatestAssistantMessage(rootMessages);
-    
+
     const totalTokens = rootMessages
       .filter((m) => m.tokens !== undefined)
       .reduce((sum, m) => sum + (m.tokens || 0), 0);
 
-    const parts = await getPartsForSession(rootSessionId);
+    const parts = getSessionParts(rootSessionId, context);
     const activityState = getSessionActivityState(parts);
-    
+
     const childStatuses = await Promise.all(
       childSessions.map(async (child) => {
-        const [childMessages, childParts] = await Promise.all([
-          listMessages(child.id),
-          getPartsForSession(child.id),
-        ]);
+        const childMessages = getSessionMessages(child.id, context);
+        const childParts = getSessionParts(child.id, context);
         const childActivityState = getSessionActivityState(childParts);
         const childLastAssistantFinished = isAssistantFinished(childMessages);
-        return getSessionStatus(
+        return getSessionStatusInfo(
           childMessages,
           childActivityState.hasPendingToolCall,
           childActivityState.lastToolCompletedAt || undefined,
           undefined,
           childLastAssistantFinished,
           true
-        );
+        ).status;
       })
     );
     const workingChildCount = countBlockingChildren(childStatuses);
@@ -240,12 +143,13 @@ export async function getSessionHierarchy(
     );
     const activityType = deriveActivityType(activityState, rootLastAssistantFinished, false, status, statusInfo.waitingReason);
 
-    const toolCalls = await getToolCallsForSession(rootSessionId, messageAgent, undefined, parts);
+    const toolCalls = buildToolCalls(parts, messageAgent);
 
     result.push({
       id: rootSession.id,
       title: rootSession.title,
       agent: latestAssistantMsg?.agent || "unknown",
+      nodeKind: "session",
       modelID: latestAssistantMsg?.modelID,
       providerID: latestAssistantMsg?.providerID,
       parentID: rootSession.parentID,
@@ -262,11 +166,11 @@ export async function getSessionHierarchy(
     processed.add(rootSessionId);
 
     for (const child of childSessions) {
-      await processChildSession(child.id, rootSession.id, allSessions, result, processed, 1);
+      await processChildSession(child.id, rootSession.id, allSessions, result, processed, 1, context);
     }
   } else {
-    const rootParts = await getPartsForSession(rootSessionId);
-    const allToolCalls = await getToolCallsForSession(rootSessionId, messageAgent, undefined, rootParts);
+    const rootParts = getSessionParts(rootSessionId, context);
+    const allToolCalls = buildToolCalls(rootParts, messageAgent);
 
     for (let i = 0; i < phases.length; i++) {
       const phase = phases[i];
@@ -274,31 +178,29 @@ export async function getSessionHierarchy(
       const virtualId = `${rootSessionId}-phase-${i}-${phase.agent}`;
 
       const phaseMessages = rootMessages.filter(
-        m => m.role === 'assistant' && m.agent === phase.agent &&
+        (m) => m.role === "assistant" && m.agent === phase.agent &&
              m.createdAt >= phase.startTime && m.createdAt <= phase.endTime
       );
       const latestPhaseMsg = phaseMessages[phaseMessages.length - 1];
 
-      const phaseChildren = childSessions.filter(child =>
+      const phaseChildren = childSessions.filter((child) =>
         child.createdAt >= phase.startTime && child.createdAt < nextPhaseStart
       );
 
       const childStatuses = await Promise.all(
         phaseChildren.map(async (child) => {
-          const [childMessages, childParts] = await Promise.all([
-            listMessages(child.id),
-            getPartsForSession(child.id),
-          ]);
+          const childMessages = getSessionMessages(child.id, context);
+          const childParts = getSessionParts(child.id, context);
           const childActivityState = getSessionActivityState(childParts);
           const childLastAssistantFinished = isAssistantFinished(childMessages);
-          return getSessionStatus(
+          return getSessionStatusInfo(
             childMessages,
             childActivityState.hasPendingToolCall,
             childActivityState.lastToolCompletedAt || undefined,
             undefined,
             childLastAssistantFinished,
             true
-          );
+          ).status;
         })
       );
       const workingChildCount = countBlockingChildren(childStatuses);
@@ -341,12 +243,13 @@ export async function getSessionHierarchy(
         ? deriveActivityType(phaseActivityState, phaseLastAssistantFinished, false, status, statusInfo.waitingReason)
         : "idle";
 
-      const toolCalls = allToolCalls.filter(tc => tc.agentName === phase.agent);
+      const toolCalls = allToolCalls.filter((tc) => tc.agentName === phase.agent);
 
       result.push({
         id: virtualId,
         title: rootSession.title,
         agent: phase.agent,
+        nodeKind: "phase",
         modelID: latestPhaseMsg?.modelID,
         providerID: latestPhaseMsg?.providerID,
         parentID: undefined,
@@ -362,7 +265,7 @@ export async function getSessionHierarchy(
       });
 
       for (const child of phaseChildren) {
-        await processChildSession(child.id, virtualId, allSessions, result, processed, 1);
+        await processChildSession(child.id, virtualId, allSessions, result, processed, 1, context);
       }
     }
   }
@@ -370,13 +273,14 @@ export async function getSessionHierarchy(
   return result;
 }
 
-export async function processChildSession(
+async function processChildSession(
   sessionId: string,
   parentId: string,
   allSessions: SessionMetadata[],
   result: ActivitySession[],
   processed: Set<string>,
-  depth = 0
+  depth = 0,
+  contextArg?: SessionContext
 ): Promise<void> {
   if (depth > MAX_RECURSION_DEPTH) {
     console.warn(`Max recursion depth reached for child session ${sessionId}`);
@@ -385,10 +289,11 @@ export async function processChildSession(
   if (processed.has(sessionId)) return;
   processed.add(sessionId);
 
-  const session = allSessions.find((s) => s.id === sessionId);
+  const context = contextArg ?? createSessionContext(allSessions);
+  const session = getSessionFromContext(sessionId, context);
   if (!session) return;
 
-  const messages = await listMessages(sessionId);
+  const messages = getSessionMessages(sessionId, context);
   const latestAssistantMsg = getLatestAssistantMessage(messages);
 
   const totalTokens = messages
@@ -402,26 +307,24 @@ export async function processChildSession(
     }
   }
 
-  const parts = await getPartsForSession(sessionId);
+  const parts = getSessionParts(sessionId, context);
   const activityState = getSessionActivityState(parts);
-  
-  const childSessions = allSessions.filter((s) => s.parentID === sessionId);
+
+  const childSessions = getSessionChildren(sessionId, context);
   const childStatuses = await Promise.all(
     childSessions.map(async (child) => {
-      const [childMessages, childParts] = await Promise.all([
-        listMessages(child.id),
-        getPartsForSession(child.id),
-      ]);
+      const childMessages = getSessionMessages(child.id, context);
+      const childParts = getSessionParts(child.id, context);
       const childActivityState = getSessionActivityState(childParts);
       const childLastAssistantFinished = isAssistantFinished(childMessages);
-      return getSessionStatus(
+      return getSessionStatusInfo(
         childMessages,
         childActivityState.hasPendingToolCall,
         childActivityState.lastToolCompletedAt || undefined,
         undefined,
         childLastAssistantFinished,
         true
-      );
+      ).status;
     })
   );
   const workingChildCount = countBlockingChildren(childStatuses);
@@ -448,12 +351,13 @@ export async function processChildSession(
   );
   const activityType = deriveActivityType(activityState, lastAssistantFinished, true, status, statusInfo.waitingReason);
 
-  const toolCalls = await getToolCallsForSession(sessionId, messageAgent, undefined, parts);
+  const toolCalls = buildToolCalls(parts, messageAgent);
 
   result.push({
     id: session.id,
     title: session.title,
     agent: latestAssistantMsg?.agent || "unknown",
+    nodeKind: "session",
     modelID: latestAssistantMsg?.modelID,
     providerID: latestAssistantMsg?.providerID,
     parentID: parentId,
@@ -470,7 +374,7 @@ export async function processChildSession(
 
   await Promise.all(
     childSessions.map((child) =>
-      processChildSession(child.id, session.id, allSessions, result, processed, depth + 1)
+      processChildSession(child.id, session.id, allSessions, result, processed, depth + 1, context)
     )
   );
 }

package/src/server/services/sessionTree.ts

@@ -0,0 +1,92 @@
+import type {
+  SessionMetadata,
+  TreeNode,
+  TreeEdge,
+  SessionTree,
+} from "../../shared/types";
+import { MAX_RECURSION_DEPTH } from "../../shared/constants";
+import {
+  isAssistantFinished,
+  getSessionStatusInfo,
+} from "../logic";
+import {
+  createSessionContext,
+  getSessionFromContext,
+  getSessionMessages,
+  getSessionChildren,
+} from "./sessionContext";
+
+export async function buildSessionTree(
+  rootSessionID: string,
+  allSessions: SessionMetadata[]
+): Promise<SessionTree> {
+  const nodes: TreeNode[] = [];
+  const edges: TreeEdge[] = [];
+  const visited = new Set<string>();
+  const context = createSessionContext(allSessions);
+
+  async function processSession(sessionID: string, depth = 0) {
+    if (depth > MAX_RECURSION_DEPTH) {
+      console.warn(`Max recursion depth reached for session ${sessionID}`);
+      return;
+    }
+    if (visited.has(sessionID)) {
+      return;
+    }
+    visited.add(sessionID);
+
+    const session = getSessionFromContext(sessionID, context);
+    if (!session) {
+      return;
+    }
+
+    const messages = getSessionMessages(sessionID, context);
+    const lastAssistantFinished = isAssistantFinished(messages);
+    const isSubagent = !!session.parentID;
+    const status = getSessionStatusInfo(
+      messages,
+      false,
+      undefined,
+      undefined,
+      lastAssistantFinished,
+      isSubagent
+    ).status;
+
+    const lastMessage = messages.sort(
+      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+    )[0];
+
+    nodes.push({
+      id: session.id,
+      data: {
+        title: session.title,
+        agent: lastMessage?.agent,
+        model: lastMessage?.modelID,
+        isActive: status === "working" || status === "idle",
+      },
+    });
+
+    if (session.parentID) {
+      edges.push({
+        source: session.parentID,
+        target: session.id,
+      });
+      await processSession(session.parentID, depth + 1);
+    }
+
+    const children = getSessionChildren(sessionID, context);
+    await Promise.all(
+      children.map((child) => {
+        edges.push({
+          source: sessionID,
+          target: child.id,
+        });
+        return processSession(child.id, depth + 1);
+      })
+    );
+  }
+
+  await processSession(rootSessionID, 0);
+
+  return { nodes, edges };
+}