ocwatch 0.4.0 → 0.5.0

package/src/server/storage/partParser.ts

@@ -1,532 +0,0 @@
-/**
- * Part Parser - Parse OpenCode part JSON files (lazy loading)
- * Reads from ~/.local/share/opencode/storage/part/{partID}.json
- * 
- * IMPORTANT: With 25,748+ part files, this parser uses lazy loading.
- * Only load individual part files on demand, never read all at once.
- */
-
-import { readFile, readdir } from "node:fs/promises";
-import { join } from "node:path";
-import type { PartMeta, ToolCallSummary } from "../../shared/types";
-import { getStoragePath } from "./sessionParser";
-import { listMessages } from "./messageParser";
-
-interface PartStateJSON {
-  status?: string;
-  input?: Record<string, unknown>;
-  output?: string;
-  error?: string;
-  title?: string;
-  time?: {
-    start: number;
-    end?: number;
-  };
-}
-
-interface PartJSON {
-  id: string;
-  sessionID: string;
-  messageID: string;
-  type: string;
-  callID?: string;
-  tool?: string;
-  state?: string | PartStateJSON;
-  text?: string;
-  time?: {
-    start: number;
-    end?: number;
-  };
-  snapshot?: string;
-  reason?: string;
-  files?: string[];
-  input?: Record<string, unknown>;
-}
-
-/**
- * Parse a single part JSON file (lazy loading)
- * @param filePath - Absolute path to part JSON file
- * @returns PartMeta or null if file doesn't exist or is invalid
- */
-export async function parsePart(filePath: string): Promise<PartMeta | null> {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    const json: PartJSON = JSON.parse(content);
-
-    let state: string | undefined;
-    let input: PartMeta["input"];
-    let title: string | undefined;
-
-    if (typeof json.state === "string") {
-      state = json.state;
-    } else if (json.state && typeof json.state === "object") {
-      state = json.state.status;
-      title = json.state.title;
-      if (json.state.input) {
-        input = { ...json.state.input };
-      }
-    }
-
-    if (!input && json.input) {
-      input = { ...json.input };
-    }
-
-    let error: string | undefined;
-    if (state === "error" || state === "failed") {
-      if (typeof json.state === "object" && json.state !== null) {
-        const errorText = json.state.error || json.state.output;
-        if (errorText && typeof errorText === "string") {
-          error = errorText.length > 500 ? errorText.slice(0, 500) : errorText;
-        }
-      }
-    }
-
-    // Time can be at top level (json.time) or inside state object (json.state.time) for tool parts
-    let timeStart: number | undefined;
-    let timeEnd: number | undefined;
-    
-    if (json.time) {
-      timeStart = json.time.start;
-      timeEnd = json.time.end;
-    } else if (typeof json.state === "object" && json.state !== null && json.state.time) {
-      timeStart = json.state.time.start;
-      timeEnd = json.state.time.end;
-    }
-    
-    const startedAt = timeStart ? new Date(timeStart) : undefined;
-    const completedAt = timeEnd ? new Date(timeEnd) : undefined;
-
-    return {
-      id: json.id,
-      sessionID: json.sessionID,
-      messageID: json.messageID,
-      type: json.type,
-      callID: json.callID,
-      tool: json.tool,
-      state,
-      input,
-      title,
-      error,
-      startedAt,
-      completedAt,
-      stepSnapshot: json.snapshot,
-      stepFinishReason: json.reason === "stop" || json.reason === "tool-calls" ? json.reason : undefined,
-      reasoningText: json.type === "reasoning" ? json.text : undefined,
-      patchFiles: json.files,
-    };
-  } catch (error) {
-    return null;
-  }
-}
-
-/**
- * Get a specific part by partID (lazy loading)
- * @param partID - Part ID
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns PartMeta or null if not found
- */
-export async function getPart(
-  partID: string,
-  storagePath?: string
-): Promise<PartMeta | null> {
-  const basePath = storagePath || getStoragePath();
-  const filePath = join(
-    basePath,
-    "opencode",
-    "storage",
-    "part",
-    `${partID}.json`
-  );
-
-  return parsePart(filePath);
-}
-
-const MAX_PATH_LENGTH = 40;
-
-function truncatePath(path: string): string {
-  if (path.length <= MAX_PATH_LENGTH) {
-    return path;
-  }
-  return "..." + path.slice(-MAX_PATH_LENGTH + 3);
-}
-
-const TOOL_DISPLAY_NAMES: Record<string, string> = {
-  read: "Reading",
-  write: "Writing",
-  edit: "Editing",
-  bash: "Running",
-  grep: "Searching",
-  glob: "Finding",
-  task: "Delegating",
-  webfetch: "Fetching",
-};
-
-function getToolDisplayName(tool: string): string {
-  const normalized = tool.replace(/^mcp_/, "").toLowerCase();
-  return TOOL_DISPLAY_NAMES[normalized] || tool;
-}
-
-export function formatCurrentAction(part: PartMeta): string | null {
-  if (!part.tool) {
-    return null;
-  }
-
-  const toolName = getToolDisplayName(part.tool);
-
-  // Handle specific tools FIRST (before generic input field matching)
-
-  // Handle delegate_task (tool name is "task" or "delegate_task")
-  if (part.tool === "task" || part.tool === "delegate_task") {
-    const input = part.input as { description?: string; subagent_type?: string } | undefined;
-    const desc = input?.description;
-    const agentType = input?.subagent_type;
-    if (desc && agentType) return `${desc} (${agentType})`;
-    if (desc) return desc;
-    if (agentType) return `Delegating (${agentType})`;
-    return "Delegating task";
-  }
-
-  // Handle todowrite
-  if (part.tool === "todowrite") {
-    const input = part.input as { todos?: Array<{ content?: string }> } | undefined;
-    const todos = input?.todos;
-    if (!todos || todos.length === 0) return "Cleared todos";
-    const preview = todos
-      .slice(0, 2)
-      .map(t => (t.content || "").slice(0, 30))
-      .filter(Boolean)
-      .join(", ");
-    return `Updated ${todos.length} todo${todos.length !== 1 ? "s" : ""}: ${preview}${todos.length > 2 ? "..." : ""}`;
-  }
-
-  // Handle todoread
-  if (part.tool === "todoread") {
-    return "Reading todos";
-  }
-
-  // Generic input field matching (fallback for other tools)
-  if (part.input) {
-    if (part.input.filePath) {
-      return `${toolName} ${truncatePath(part.input.filePath)}`;
-    }
-    if (part.input.command) {
-      const cmd = part.input.command.length > 30 
-        ? part.input.command.slice(0, 27) + "..." 
-        : part.input.command;
-      return `${toolName} ${cmd}`;
-    }
-    if (part.input.pattern) {
-      return `${toolName} for "${part.input.pattern}"`;
-    }
-    if (part.input.url) {
-      return `${toolName} ${truncatePath(part.input.url)}`;
-    }
-    if (part.input.query) {
-      return `${toolName} "${part.input.query}"`;
-    }
-  }
-
-  if (part.title) {
-    return part.title;
-  }
-
-  return toolName;
-}
-
-// All states that indicate a tool is currently executing or waiting to execute
-const ACTIVE_TOOL_STATES = ["pending", "running", "in_progress"];
-
-export function isPendingToolCall(part: PartMeta): boolean {
-  if (!part.tool || part.type !== "tool") {
-    return false;
-  }
-
-  if (!part.state) {
-    return false;
-  }
-
-  return ACTIVE_TOOL_STATES.includes(part.state);
-}
-
-export interface SessionToolState {
-  hasPendingToolCall: boolean;
-  pendingCount: number;
-  completedCount: number;
-  lastToolCompletedAt: Date | null;
-}
-
-export function getSessionToolState(parts: PartMeta[]): SessionToolState {
-  let pendingCount = 0;
-  let completedCount = 0;
-  let lastToolCompletedAt: Date | null = null;
-
-  for (const part of parts) {
-    if (part.type !== "tool" || !part.tool) {
-      continue;
-    }
-
-    if (isPendingToolCall(part)) {
-      pendingCount++;
-    } else if (part.state === "completed") {
-      completedCount++;
-      
-      if (part.completedAt) {
-        if (!lastToolCompletedAt || part.completedAt > lastToolCompletedAt) {
-          lastToolCompletedAt = part.completedAt;
-        }
-      }
-    }
-  }
-
-  return {
-    hasPendingToolCall: pendingCount > 0,
-    pendingCount,
-    completedCount,
-    lastToolCompletedAt,
-  };
-}
-
-export interface SessionActivityState {
-  hasPendingToolCall: boolean;
-  pendingCount: number;
-  completedCount: number;
-  lastToolCompletedAt: Date | null;
-  isReasoning: boolean;
-  reasoningPreview: string | null;
-  patchFilesCount: number;
-  stepFinishReason: "stop" | "tool-calls" | null;
-  activeToolNames: string[];
-}
-
-export function getSessionActivityState(parts: PartMeta[]): SessionActivityState {
-  let pendingCount = 0;
-  let completedCount = 0;
-  let lastToolCompletedAt: Date | null = null;
-  let isReasoning = false;
-  let reasoningPreview: string | null = null;
-  let patchFilesCount = 0;
-  let stepFinishReason: "stop" | "tool-calls" | null = null;
-  const activeToolNames: string[] = [];
-
-  const sortedParts = [...parts].sort((a, b) => {
-    const timeA = a.startedAt?.getTime() || 0;
-    const timeB = b.startedAt?.getTime() || 0;
-    return timeB - timeA;
-  });
-
-  for (const part of sortedParts) {
-    if (part.type === "tool" && part.tool) {
-      if (isPendingToolCall(part)) {
-        pendingCount++;
-        activeToolNames.push(part.tool.replace(/^mcp_/, ""));
-      } else if (part.state === "completed") {
-        completedCount++;
-        if (part.completedAt && (!lastToolCompletedAt || part.completedAt > lastToolCompletedAt)) {
-          lastToolCompletedAt = part.completedAt;
-        }
-      }
-    }
-
-    if (part.type === "reasoning" && part.reasoningText && !isReasoning) {
-      isReasoning = true;
-      const text = part.reasoningText.trim();
-      reasoningPreview = text.length > 40 ? text.slice(0, 37) + "..." : text;
-    }
-
-    if (part.type === "patch" && part.patchFiles && !part.completedAt) {
-      patchFilesCount += part.patchFiles.length;
-    }
-
-    if (part.type === "step-finish" && part.stepFinishReason && !stepFinishReason) {
-      stepFinishReason = part.stepFinishReason;
-    }
-  }
-
-  return {
-    hasPendingToolCall: pendingCount > 0,
-    pendingCount,
-    completedCount,
-    lastToolCompletedAt,
-    isReasoning,
-    reasoningPreview,
-    patchFilesCount,
-    stepFinishReason,
-    activeToolNames,
-  };
-}
-
-import type { SessionActivityType, SessionStatus } from "../../shared/types";
-
-export function deriveActivityType(
-  activityState: SessionActivityState,
-  lastAssistantFinished: boolean,
-  isSubagent: boolean,
-  status: SessionStatus,
-  waitingReason?: "user" | "children"
-): SessionActivityType {
-  if (status === "completed") {
-    return "idle";
-  }
-  if ((waitingReason === "user" || (!waitingReason && lastAssistantFinished)) && !isSubagent && status === "waiting") {
-    return "waiting-user";
-  }
-  if (activityState.pendingCount > 0) {
-    return "tool";
-  }
-  if (activityState.isReasoning) {
-    return "reasoning";
-  }
-  if (activityState.patchFilesCount > 0) {
-    return "patch";
-  }
-  if (activityState.stepFinishReason === "tool-calls") {
-    return "waiting-tools";
-  }
-  return "idle";
-}
-
-export function generateActivityMessage(
-  activityState: SessionActivityState,
-  lastAssistantFinished: boolean,
-  isSubagent: boolean,
-  status: SessionStatus,
-  pendingPart?: PartMeta,
-  waitingReason?: "user" | "children"
-): string | null {
-  if (status === "completed") {
-    return null;
-  }
-  if ((waitingReason === "user" || (!waitingReason && lastAssistantFinished)) && !isSubagent && status === "waiting") {
-    return "Waiting for user input";
-  }
-
-  if (activityState.pendingCount > 1) {
-    const toolNames = activityState.activeToolNames.slice(0, 3).join(", ");
-    const firstToolAction = pendingPart ? formatCurrentAction(pendingPart) : null;
-    if (firstToolAction) {
-      return `Running ${activityState.pendingCount} tools (${firstToolAction})`;
-    }
-    return `Running ${activityState.pendingCount} tools: ${toolNames}${activityState.activeToolNames.length > 3 ? "..." : ""}`;
-  }
-
-  if (activityState.pendingCount === 1 && pendingPart) {
-    return formatCurrentAction(pendingPart);
-  }
-
-  if (activityState.isReasoning && activityState.reasoningPreview) {
-    return `Analyzing: ${activityState.reasoningPreview}`;
-  }
-
-  if (activityState.patchFilesCount > 0) {
-    return `Writing ${activityState.patchFilesCount} file${activityState.patchFilesCount !== 1 ? "s" : ""}...`;
-  }
-
-  if (activityState.stepFinishReason === "tool-calls") {
-    return "Waiting for tool results";
-  }
-
-  return null;
-}
-
-export async function getPartsForSession(
-  sessionID: string,
-  storagePath?: string
-): Promise<PartMeta[]> {
-  const basePath = storagePath || getStoragePath();
-  const messages = await listMessages(sessionID, storagePath);
-  const parts: PartMeta[] = [];
-
-  for (const message of messages) {
-    const messagePartDir = join(
-      basePath,
-      "opencode",
-      "storage",
-      "part",
-      message.id
-    );
-
-    try {
-      const entries = await readdir(messagePartDir);
-
-      for (const entry of entries) {
-        if (!entry.endsWith(".json")) {
-          continue;
-        }
-
-        const partPath = join(messagePartDir, entry);
-        const part = await parsePart(partPath);
-
-        if (part) {
-          parts.push(part);
-        }
-      }
-    } catch (error) {
-      continue;
-    }
-  }
-
-  return parts;
-}
-
-/**
- * Get tool call summaries for a session
- * @param sessionID - Session ID
- * @param messageAgent - Map of message ID to agent name
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns Array of ToolCallSummary (max 50, sorted by timestamp desc)
- */
-export async function getToolCallsForSession(
-  sessionID: string,
-  messageAgent: Map<string, string>,
-  storagePath?: string,
-  partsOverride?: PartMeta[]
-): Promise<ToolCallSummary[]> {
-  const parts = partsOverride ?? (await getPartsForSession(sessionID, storagePath));
-
-  // Filter for tool type parts only
-  const toolParts = parts.filter((part) => part.type === "tool" && part.tool);
-
-  // Map to ToolCallSummary
-  const toolCalls: ToolCallSummary[] = toolParts.map((part) => {
-    const agentName = messageAgent.get(part.messageID) || "unknown";
-
-    // Map state to ToolCallSummary state
-    let state: "pending" | "complete" | "error" = "complete";
-    if (part.state) {
-      if (ACTIVE_TOOL_STATES.includes(part.state)) {
-        state = "pending";
-      } else if (part.state === "error" || part.state === "failed") {
-        state = "error";
-      } else {
-        state = "complete";
-      }
-    }
-
-    // Generate summary using formatCurrentAction
-    const summary = formatCurrentAction(part) || part.tool || "Unknown tool";
-
-    // Use completedAt if available, otherwise startedAt for stable hashing
-    const timestamp = (part.completedAt || part.startedAt)?.toISOString() || "";
-
-    return {
-      id: part.id,
-      name: part.tool || "unknown",
-      state,
-      summary,
-      input: part.input || {},
-      error: part.error,
-      timestamp,
-      agentName,
-    };
-  });
-
-  // Sort by timestamp descending (newest first)
-  toolCalls.sort((a, b) => {
-    const timeA = new Date(a.timestamp).getTime();
-    const timeB = new Date(b.timestamp).getTime();
-    return timeB - timeA;
-  });
-
-  // Limit to 50 most recent
-  return toolCalls.slice(0, 50);
-}

package/src/server/storage/sessionParser.ts

@@ -1,180 +0,0 @@
-/**
- * Session Parser - Parse OpenCode session JSON files
- * Reads from ~/.local/share/opencode/storage/session/{projectID}/{sessionID}.json
- */
-
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import type { SessionMetadata } from "../../shared/types";
-
-/**
- * Internal JSON structure from OpenCode storage
- */
-interface SessionJSON {
-  id: string;
-  slug: string;
-  version?: string;
-  projectID: string;
-  directory: string;
-  title: string;
-  parentID?: string;
-  time: {
-    created: number; // Unix timestamp in milliseconds
-    updated: number;
-  };
-}
-
-export function getStoragePath(): string {
-  const xdgDataHome = process.env.XDG_DATA_HOME;
-  if (xdgDataHome) {
-    return xdgDataHome;
-  }
-
-  const home = homedir();
-  return join(home, ".local", "share");
-}
-
-export async function checkStorageExists(): Promise<boolean> {
-  try {
-    const basePath = getStoragePath();
-    const storagePath = join(basePath, "opencode", "storage");
-    await readdir(storagePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Parse a single session JSON file
- * @param filePath - Absolute path to session JSON file
- * @returns SessionMetadata or null if file doesn't exist or is invalid
- */
-export async function parseSession(
-  filePath: string
-): Promise<SessionMetadata | null> {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    const json: SessionJSON = JSON.parse(content);
-
-    return {
-      id: json.id,
-      projectID: json.projectID,
-      directory: json.directory,
-      title: json.title,
-      parentID: json.parentID,
-      createdAt: new Date(json.time.created),
-      updatedAt: new Date(json.time.updated),
-    };
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      console.warn(`Corrupted JSON file: ${filePath}`);
-    }
-    return null;
-  }
-}
-
-/**
- * Get a specific session by projectID and sessionID
- * @param projectID - Project hash ID
- * @param sessionID - Session ID
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns SessionMetadata or null if not found
- */
-export async function getSession(
-  projectID: string,
-  sessionID: string,
-  storagePath?: string
-): Promise<SessionMetadata | null> {
-  const basePath = storagePath || getStoragePath();
-  const filePath = join(
-    basePath,
-    "opencode",
-    "storage",
-    "session",
-    projectID,
-    `${sessionID}.json`
-  );
-
-  return parseSession(filePath);
-}
-
-/**
- * List all sessions for a given project
- * @param projectID - Project hash ID
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns Array of SessionMetadata (empty array if directory doesn't exist)
- */
-export async function listSessions(
-  projectID: string,
-  storagePath?: string
-): Promise<SessionMetadata[]> {
-  const basePath = storagePath || getStoragePath();
-  const sessionDir = join(
-    basePath,
-    "opencode",
-    "storage",
-    "session",
-    projectID
-  );
-
-  try {
-    const entries = await readdir(sessionDir);
-    const results = await Promise.all(
-      entries
-        .filter((entry) => entry.endsWith(".json"))
-        .map((entry) => getSession(projectID, entry.slice(0, -5), storagePath))
-    );
-
-    return results.filter(
-      (session): session is SessionMetadata => session !== null
-    );
-  } catch (error) {
-    // Graceful handling: return empty array if directory doesn't exist
-    return [];
-  }
-}
-
-/**
- * List all project IDs from the session storage
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns Array of project IDs (empty array if directory doesn't exist)
- */
-export async function listProjects(
-  storagePath?: string
-): Promise<string[]> {
-  const basePath = storagePath || getStoragePath();
-  const sessionBaseDir = join(basePath, "opencode", "storage", "session");
-
-  try {
-    const entries = await readdir(sessionBaseDir, { withFileTypes: true });
-    const projectIDs: string[] = [];
-
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        projectIDs.push(entry.name);
-      }
-    }
-
-    return projectIDs;
-  } catch (error) {
-    return [];
-  }
-}
-
-/**
- * List all sessions across all projects
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns Array of SessionMetadata (empty array if directory doesn't exist)
- */
-export async function listAllSessions(
-  storagePath?: string
-): Promise<SessionMetadata[]> {
-  const projectIDs = await listProjects(storagePath);
-  const allResults = await Promise.all(
-    projectIDs.map((projectID) => listSessions(projectID, storagePath))
-  );
-
-  return allResults.flat();
-}