ocwatch 0.1.1

package/src/server/services/statsService.ts

@@ -0,0 +1,53 @@
+import type { SessionStats, ActivitySession, MessageMeta } from "../../shared/types";
+
+/**
+ * Aggregate session statistics from activity sessions and their messages
+ * @param activitySessions - Array of activity sessions
+ * @param allMessages - Map of sessionID to messages
+ * @returns SessionStats with total tokens, cost, and model breakdown
+ */
+export function aggregateSessionStats(
+  activitySessions: ActivitySession[],
+  allMessages: Map<string, MessageMeta[]>
+): SessionStats {
+  let totalTokens = 0;
+  let totalCost = 0;
+  let hasCost = false;
+  const modelTokensMap = new Map<string, { modelID: string; providerID?: string; tokens: number }>();
+
+  for (const session of activitySessions) {
+    const messages = allMessages.get(session.id) || [];
+    
+    for (const msg of messages) {
+      if (msg.tokens) {
+        totalTokens += msg.tokens;
+        
+        const modelKey = `${msg.modelID || 'unknown'}:${msg.providerID || ''}`;
+        const existing = modelTokensMap.get(modelKey);
+        if (existing) {
+          existing.tokens += msg.tokens;
+        } else {
+          modelTokensMap.set(modelKey, {
+            modelID: msg.modelID || 'unknown',
+            providerID: msg.providerID,
+            tokens: msg.tokens,
+          });
+        }
+      }
+      
+      if (msg.cost !== undefined) {
+        totalCost += msg.cost;
+        hasCost = true;
+      }
+    }
+  }
+
+  const modelBreakdown = Array.from(modelTokensMap.values())
+    .sort((a, b) => b.tokens - a.tokens);
+
+  return {
+    totalTokens,
+    totalCost: hasCost ? totalCost : undefined,
+    modelBreakdown,
+  };
+}

package/src/server/storage/boulderParser.ts

@@ -0,0 +1,113 @@
+/**
+ * Boulder Parser - Parse .sisyphus/boulder.json for plan progress
+ * Reads plan state and calculates progress from markdown checkboxes
+ */
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Boulder, PlanProgress } from "../../shared/types";
+
+/**
+ * Internal JSON structure from .sisyphus/boulder.json
+ */
+interface BoulderJSON {
+  activePlan?: string;
+  sessionIDs: string[];
+  status: string;
+  startedAt: number;
+  planName: string;
+}
+
+/**
+ * Parse boulder.json file
+ * @param projectDir - Project directory containing .sisyphus/boulder.json
+ * @returns Boulder or null if file doesn't exist or is invalid
+ */
+export async function parseBoulder(projectDir: string): Promise<Boulder | null> {
+  try {
+    const filePath = join(projectDir, ".sisyphus", "boulder.json");
+    const content = await readFile(filePath, "utf-8");
+    const json: BoulderJSON = JSON.parse(content);
+
+    let activePlan = json.activePlan;
+    if (activePlan && !activePlan.startsWith("/")) {
+      activePlan = join(projectDir, activePlan);
+    }
+
+    return {
+      activePlan,
+      sessionIDs: json.sessionIDs,
+      status: json.status,
+      startedAt: new Date(json.startedAt),
+      planName: json.planName,
+    };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      console.warn(`Corrupted boulder.json: ${projectDir}/.sisyphus/boulder.json`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Calculate progress from markdown plan file
+ * Counts checkboxes: - [ ] (incomplete) vs - [x] or - [X] (complete)
+ * @param planPath - Absolute path to plan markdown file
+ * @returns PlanProgress or null if file doesn't exist
+ */
+export async function calculatePlanProgress(
+  planPath: string
+): Promise<PlanProgress | null> {
+  try {
+    const content = await readFile(planPath, "utf-8");
+    const { completed, total, tasks } = parseCheckboxes(content);
+
+    const progress = total > 0 ? (completed / total) * 100 : 0;
+
+    return {
+      completed,
+      total,
+      progress,
+      tasks,
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Parse markdown checkboxes from plan content
+ * @param content - Markdown content
+ * @returns Object with completed count, total count, and task list
+ */
+function parseCheckboxes(content: string): {
+  completed: number;
+  total: number;
+  tasks: Array<{ description: string; completed: boolean }>;
+} {
+  const checkboxRegex = /-\s+\[([ xX])\]\s*(.+)/g;
+  const matches = [...content.matchAll(checkboxRegex)];
+
+  let completed = 0;
+  const tasks: Array<{ description: string; completed: boolean }> = [];
+
+  for (const match of matches) {
+    const isChecked = match[1] === "x" || match[1] === "X";
+    const taskText = match[2].trim();
+
+    if (isChecked) {
+      completed++;
+    }
+
+    tasks.push({
+      description: taskText,
+      completed: isChecked,
+    });
+  }
+
+  return {
+    completed,
+    total: matches.length,
+    tasks,
+  };
+}

package/src/server/storage/messageParser.ts

@@ -0,0 +1,169 @@
+/**
+ * Message Parser - Parse OpenCode message JSON files
+ * Reads from ~/.local/share/opencode/storage/message/{sessionID}/{messageID}.json
+ */
+
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { MessageMeta } from "../../shared/types";
+import { getStoragePath } from "./sessionParser";
+
+/**
+ * Internal JSON structure from OpenCode storage
+ */
+interface MessageJSON {
+  id: string;
+  sessionID: string;
+  role: string;
+  time: {
+    created: number;
+    completed?: number;
+  };
+  parentID?: string;
+  modelID?: string;
+  model?: {
+    modelID?: string;
+    providerID?: string;
+  };
+  providerID?: string;
+  mode?: string;
+  agent?: string;
+  path?: {
+    cwd: string;
+    root: string;
+  };
+  cost?: number;
+  tokens?: {
+    input: number;
+    output: number;
+    reasoning?: number;
+    cache?: {
+      read: number;
+      write: number;
+    };
+  };
+  finish?: string;
+}
+
+/**
+ * Parse a single message JSON file
+ * @param filePath - Absolute path to message JSON file
+ * @returns MessageMeta or null if file doesn't exist or is invalid
+ */
+export async function parseMessage(
+  filePath: string
+): Promise<MessageMeta | null> {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const json: MessageJSON = JSON.parse(content);
+
+    const totalTokens = json.tokens
+      ? json.tokens.input + json.tokens.output
+      : undefined;
+
+    return {
+      id: json.id,
+      sessionID: json.sessionID,
+      role: json.role,
+      agent: json.agent,
+      mode: json.mode,
+      modelID: json.modelID || json.model?.modelID,
+      providerID: json.providerID || json.model?.providerID,
+      parentID: json.parentID,
+      tokens: totalTokens,
+      cost: json.cost,
+      createdAt: new Date(json.time.created),
+      finish: json.finish,
+    };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      console.warn(`Corrupted JSON file: ${filePath}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Get a specific message by messageID and sessionID
+ * @param messageID - Message ID
+ * @param sessionID - Session ID
+ * @param storagePath - Optional custom storage path (defaults to XDG path)
+ * @returns MessageMeta or null if not found
+ */
+export async function getMessage(
+  messageID: string,
+  sessionID: string,
+  storagePath?: string
+): Promise<MessageMeta | null> {
+  const basePath = storagePath || getStoragePath();
+  const filePath = join(
+    basePath,
+    "opencode",
+    "storage",
+    "message",
+    sessionID,
+    `${messageID}.json`
+  );
+
+  return parseMessage(filePath);
+}
+
+/**
+ * List all messages for a given session
+ * @param sessionID - Session ID to filter by
+ * @param storagePath - Optional custom storage path (defaults to XDG path)
+ * @returns Array of MessageMeta (empty array if directory doesn't exist)
+ */
+export async function listMessages(
+  sessionID: string,
+  storagePath?: string
+): Promise<MessageMeta[]> {
+  const basePath = storagePath || getStoragePath();
+  const messageDir = join(basePath, "opencode", "storage", "message", sessionID);
+
+  try {
+    const entries = await readdir(messageDir);
+    const messages: MessageMeta[] = [];
+
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) {
+        continue;
+      }
+
+      const messageID = entry.slice(0, -5);
+      const message = await getMessage(messageID, sessionID, storagePath);
+
+      if (message) {
+        messages.push(message);
+      }
+    }
+
+    return messages;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Get the first assistant message in a session
+ * @param sessionID - Session ID to search
+ * @param storagePath - Optional custom storage path (defaults to XDG path)
+ * @returns First assistant message or null if none found
+ */
+export async function getFirstAssistantMessage(
+  sessionID: string,
+  storagePath?: string
+): Promise<MessageMeta | null> {
+  const messages = await listMessages(sessionID, storagePath);
+  const sorted = messages.sort(
+    (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+  );
+
+  for (const message of sorted) {
+    if (message.role === "assistant") {
+      return message;
+    }
+  }
+
+  return null;
+}