ocwatch 0.3.0 → 0.5.0

package/src/server/services/sessionService.ts

@@ -1,83 +1,151 @@
-import type { 
-  SessionMetadata, 
-  MessageMeta, 
-  ActivitySession, 
-  TreeNode, 
-  TreeEdge, 
-  SessionTree, 
-  AgentPhase,
+import type {
+  SessionMetadata,
+  MessageMeta,
+  ActivitySession,
+  TreeNode,
+  TreeEdge,
+  SessionTree,
   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;
+  deriveActivityType,
+  detectAgentPhases,
+  isAssistantFinished,
+  getSessionStatusInfo,
+  type SessionStatusInfo,
+} from "../logic";
+import {
+  querySessionChildren,
+  queryMessages,
+  queryParts,
+} from "../storage/queries";
+import { getStatusFromTimestamp } from "../utils/sessionStatus";
+import {
+  toSessionMetadata as parseSessionRow,
+  toMessageMeta as parseMessageRow,
+  toPartMeta as parsePartRow,
+  getLatestAssistantMessage,
+  getMostRecentPendingPart,
+} from "./parsing";
+
+export { detectAgentPhases, isAssistantFinished };
+
+/** Max messages to load per session for hierarchy building (effectively unlimited) */
+const MAX_MESSAGE_QUERY_LIMIT = 100_000;
+
+interface SessionContext {
+  allowedSessionIds: Set<string>;
+  sessionById: Map<string, SessionMetadata>;
+  messagesBySession: Map<string, MessageMeta[]>;
+  partsBySession: Map<string, PartMeta[]>;
+  childrenBySession: Map<string, SessionMetadata[]>;
+}
+
+
+function createSessionContext(allSessions: SessionMetadata[]): SessionContext {
+  const sessionById = new Map<string, SessionMetadata>();
+  for (const session of allSessions) {
+    sessionById.set(session.id, session);
   }
 
-  const lastMessage = messages.reduce((latest, current) =>
-    current.createdAt.getTime() > latest.createdAt.getTime() ? current : latest
-  );
+  return {
+    allowedSessionIds: new Set(allSessions.map((session) => session.id)),
+    sessionById,
+    messagesBySession: new Map<string, MessageMeta[]>(),
+    partsBySession: new Map<string, PartMeta[]>(),
+    childrenBySession: new Map<string, SessionMetadata[]>(),
+  };
+}
+
+function getSessionFromContext(sessionId: string, context: SessionContext): SessionMetadata | undefined {
+  return context.sessionById.get(sessionId);
+}
+
+function getSessionMessages(sessionId: string, context: SessionContext): MessageMeta[] {
+  const cached = context.messagesBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
 
-  return lastMessage.role === "assistant" && lastMessage.finish === "stop";
+  const messages = queryMessages(sessionId, MAX_MESSAGE_QUERY_LIMIT).map(parseMessageRow);
+  context.messagesBySession.set(sessionId, messages);
+  return messages;
 }
 
-function getLatestAssistantMessage(messages: MessageMeta[]): MessageMeta | undefined {
-  return messages
-    .filter((message) => message.role === "assistant")
-    .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())[0];
+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;
 }
 
-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 getSessionChildren(sessionId: string, context: SessionContext): SessionMetadata[] {
+  const cached = context.childrenBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
+
+  const children = querySessionChildren(sessionId)
+    .map(parseSessionRow)
+    .filter((child) => context.allowedSessionIds.has(child.id));
+
+  for (const child of children) {
+    if (!context.sessionById.has(child.id)) {
+      context.sessionById.set(child.id, child);
+    }
+  }
+
+  context.childrenBySession.set(sessionId, children);
+  return children;
 }
 
+
 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,
+
+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 {
+        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",
       };
-    } else {
-      currentPhase.endTime = msg.createdAt;
-      currentPhase.tokens += msg.tokens || 0;
-      currentPhase.messageCount++;
-    }
-  }
-  if (currentPhase) phases.push(currentPhase);
-  
-  return phases;
+    });
+
+  toolCalls.sort((a, b) => {
+    const timeA = new Date(a.timestamp).getTime();
+    const timeB = new Date(b.timestamp).getTime();
+    return timeB - timeA;
+  });
+
+  return toolCalls.slice(0, 50);
 }
 
 export function buildAgentHierarchy(messages: MessageMeta[]): Record<string, string[]> {
@@ -107,6 +175,7 @@ export async function buildSessionTree(
   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) {
@@ -118,15 +187,22 @@ export async function buildSessionTree(
     }
     visited.add(sessionID);
 
-    const session = allSessions.find((s) => s.id === sessionID);
+    const session = getSessionFromContext(sessionID, context);
     if (!session) {
       return;
     }
 
-    const messages = await listMessages(sessionID);
+    const messages = getSessionMessages(sessionID, context);
     const lastAssistantFinished = isAssistantFinished(messages);
     const isSubagent = !!session.parentID;
-    const status = getSessionStatus(messages, false, undefined, undefined, lastAssistantFinished, isSubagent);
+    const status = getSessionStatusInfo(
+      messages,
+      false,
+      undefined,
+      undefined,
+      lastAssistantFinished,
+      isSubagent
+    ).status;
 
     const lastMessage = messages.sort(
       (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
@@ -150,7 +226,7 @@ export async function buildSessionTree(
       await processSession(session.parentID, depth + 1);
     }
 
-    const children = allSessions.filter((s) => s.parentID === sessionID);
+    const children = getSessionChildren(sessionID, context);
     await Promise.all(
       children.map((child) => {
         edges.push({
@@ -173,15 +249,15 @@ export async function getSessionHierarchy(
 ): Promise<ActivitySession[]> {
   const result: ActivitySession[] = [];
   const processed = new Set<string>();
+  const context = 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 +267,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,7 +314,7 @@ 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,
@@ -262,11 +336,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 +348,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,7 +413,7 @@ 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,
@@ -362,7 +434,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);
       }
     }
   }
@@ -376,7 +448,8 @@ export async function processChildSession(
   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 +458,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 +476,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,7 +520,7 @@ 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,
@@ -470,7 +542,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/storage/db.ts

@@ -0,0 +1,71 @@
+import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const SQLITE_BUSY_TIMEOUT_MS = 5000;
+const SQLITE_CACHE_SIZE = -20000;
+
+let dbSingleton: Database | null | undefined;
+
+function getStorageRootPath(): string {
+  const xdgDataHome = process.env.XDG_DATA_HOME;
+  if (xdgDataHome) {
+    return xdgDataHome;
+  }
+
+  return join(homedir(), ".local", "share");
+}
+
+function getDbPath(): string {
+  return join(getStorageRootPath(), "opencode", "opencode.db");
+}
+
+function configureConnectionPragmas(db: Database): void {
+  db.query("PRAGMA busy_timeout = 5000;").run();
+  db.query("PRAGMA cache_size = -20000;").run();
+
+  try {
+    db.query("PRAGMA journal_mode = WAL;").run();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.warn(`[storage/db] Failed to enforce WAL journal mode: ${reason}`);
+  }
+}
+
+export function checkDbExists(): boolean {
+  return existsSync(getDbPath());
+}
+
+export function getDb(): Database | null {
+  if (dbSingleton !== undefined) {
+    return dbSingleton;
+  }
+
+  if (!checkDbExists()) {
+    dbSingleton = null;
+    return dbSingleton;
+  }
+
+  try {
+    const db = new Database(getDbPath(), { readonly: true });
+    configureConnectionPragmas(db);
+    dbSingleton = db;
+    return dbSingleton;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.warn(`[storage/db] Failed to open SQLite database: ${reason}`);
+    dbSingleton = null;
+    return dbSingleton;
+  }
+}
+
+export function closeDb(): void {
+  if (!dbSingleton) {
+    return;
+  }
+
+  dbSingleton.close();
+  dbSingleton = undefined;
+}
+

package/src/server/storage/index.ts

@@ -0,0 +1,22 @@
+export { checkDbExists, closeDb, getDb } from "./db";
+export {
+  queryMaxTimestamp,
+  queryMessages,
+  queryPart,
+  queryParts,
+  queryProjects,
+  querySession,
+  querySessionChildren,
+  querySessions,
+  queryTodos,
+  listProjects,
+  listAllSessions,
+} from "./queries";
+export type {
+  DbMessageRow,
+  DbPartRow,
+  DbProjectRow,
+  DbSessionRow,
+  DbTodoRow,
+} from "./queries";
+export { parseBoulder, calculatePlanProgress } from "./boulderParser";