ocwatch 0.1.1

package/src/shared/utils/RingBuffer.ts

@@ -0,0 +1,79 @@
+/**
+ * RingBuffer - Generic circular buffer with fixed capacity
+ * Automatically drops oldest items when capacity is exceeded
+ * 
+ * Used for storing recent logs and tool calls with a maximum size limit.
+ * Ported from Go implementation: internal/state/state.go:50-90
+ */
+
+import { RINGBUFFER_CAPACITY } from "../constants";
+
+export class RingBuffer<T> {
+  private buffer: T[] = [];
+  private capacity: number;
+  private head: number = 0;
+
+  /**
+   * Create a new RingBuffer with specified capacity
+   * @param capacity Maximum number of items to store (default: RINGBUFFER_CAPACITY)
+   */
+  constructor(capacity: number = RINGBUFFER_CAPACITY) {
+    this.capacity = Math.max(1, capacity);
+  }
+
+  /**
+   * Add an item to the buffer
+   * If buffer is full, drops the oldest item
+   * @param item The item to add
+   */
+  push(item: T): void {
+    if (this.buffer.length < this.capacity) {
+      this.buffer.push(item);
+    } else {
+      // Buffer is full, overwrite oldest item
+      this.buffer[this.head] = item;
+      this.head = (this.head + 1) % this.capacity;
+    }
+  }
+
+  /**
+   * Get all items in order (oldest to newest)
+   * @returns Array of all items in chronological order
+   */
+  getAll(): T[] {
+    if (this.buffer.length < this.capacity) {
+      // Buffer not full yet, return as-is
+      return [...this.buffer];
+    }
+    // Buffer is full, reconstruct in order starting from head
+    return [
+      ...this.buffer.slice(this.head),
+      ...this.buffer.slice(0, this.head),
+    ];
+  }
+
+  /**
+   * Get the last n items (newest first)
+   * @param n Number of items to retrieve
+   * @returns Array of last n items in reverse chronological order
+   */
+  getLatest(n: number): T[] {
+    const all = this.getAll();
+    return all.slice(Math.max(0, all.length - n)).reverse();
+  }
+
+  /**
+   * Clear all items from the buffer
+   */
+  clear(): void {
+    this.buffer = [];
+    this.head = 0;
+  }
+
+  /**
+   * Get current number of items in the buffer
+   */
+  get size(): number {
+    return this.buffer.length;
+  }
+}

package/src/shared/utils/activityUtils.ts

@@ -0,0 +1,66 @@
+import type { ActivitySession, ActivityItem } from '../types';
+
+export function synthesizeActivityItems(
+  sessions: ActivitySession[]
+): ActivityItem[] {
+  const items: ActivityItem[] = [];
+  const sessionMap = new Map<string, ActivitySession>();
+  const seenToolCallIds = new Set<string>();
+
+  sessions.forEach((session) => {
+    sessionMap.set(session.id, session);
+  });
+
+  sessions.forEach((session) => {
+    if (session.parentID && sessionMap.has(session.parentID)) {
+      const parent = sessionMap.get(session.parentID)!;
+      items.push({
+        id: `spawn-${session.id}`,
+        type: "agent-spawn",
+        timestamp: session.createdAt,
+        agentName: parent.agent,
+        spawnedAgentName: session.agent,
+      });
+    }
+
+    if (session.toolCalls && session.toolCalls.length > 0) {
+      session.toolCalls.forEach((toolCall) => {
+        if (seenToolCallIds.has(toolCall.id)) return;
+        seenToolCallIds.add(toolCall.id);
+        
+        items.push({
+          id: toolCall.id,
+          type: "tool-call",
+          timestamp: new Date(toolCall.timestamp),
+          agentName: toolCall.agentName,
+          toolName: toolCall.name,
+          state: toolCall.state,
+          summary: toolCall.summary,
+          input: toolCall.input,
+        });
+      });
+    }
+
+    if (session.status === "completed") {
+      const durationMs = session.updatedAt
+        ? new Date(session.updatedAt).getTime() -
+          new Date(session.createdAt).getTime()
+        : undefined;
+
+      items.push({
+        id: `complete-${session.id}`,
+        type: "agent-complete",
+        timestamp: session.updatedAt,
+        agentName: session.agent,
+        status: session.status,
+        durationMs,
+      });
+    }
+  });
+
+  items.sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+
+  return items;
+}

package/src/shared/utils/burstGrouping.ts

@@ -0,0 +1,99 @@
+import type {
+  ActivityItem,
+  BurstEntry,
+  MilestoneEntry,
+  StreamEntry,
+  ToolCallActivity,
+} from "../types";
+
+function isMilestone(item: ActivityItem): boolean {
+  if (item.type === "agent-spawn" || item.type === "agent-complete") {
+    return true;
+  }
+
+  return item.type === "tool-call" && item.state === "error";
+}
+
+function createBurstEntry(items: ToolCallActivity[]): BurstEntry {
+  const first = items[0]!;
+  const last = items[items.length - 1]!;
+  const toolBreakdown: Record<string, number> = {};
+
+  let pendingCount = 0;
+  let errorCount = 0;
+
+  for (const item of items) {
+    toolBreakdown[item.toolName] = (toolBreakdown[item.toolName] ?? 0) + 1;
+
+    if (item.state === "pending") {
+      pendingCount += 1;
+    }
+
+    if (item.state === "error") {
+      errorCount += 1;
+    }
+  }
+
+  return {
+    id: first.id,
+    type: "burst",
+    agentName: first.agentName,
+    items,
+    toolBreakdown,
+    durationMs: new Date(last.timestamp).getTime() - new Date(first.timestamp).getTime(),
+    firstTimestamp: new Date(first.timestamp),
+    lastTimestamp: new Date(last.timestamp),
+    pendingCount,
+    errorCount,
+  };
+}
+
+export function groupIntoBursts(items: ActivityItem[]): StreamEntry[] {
+  const entries: StreamEntry[] = [];
+  let currentBurstItems: ToolCallActivity[] = [];
+  const chronologicalItems = [...items].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+
+  const flushCurrentBurst = () => {
+    if (currentBurstItems.length === 0) {
+      return;
+    }
+
+    entries.push(createBurstEntry(currentBurstItems));
+    currentBurstItems = [];
+  };
+
+  for (const item of chronologicalItems) {
+    if (isMilestone(item)) {
+      flushCurrentBurst();
+
+      const milestone: MilestoneEntry = {
+        id: item.id,
+        type: "milestone",
+        item,
+      };
+
+      entries.push(milestone);
+      continue;
+    }
+
+    if (item.type !== "tool-call") {
+      continue;
+    }
+
+    const currentAgentName = currentBurstItems[0]?.agentName;
+    const shouldStartNewBurst =
+      currentBurstItems.length > 0 && currentAgentName !== item.agentName;
+
+    if (shouldStartNewBurst) {
+      flushCurrentBurst();
+    }
+
+    currentBurstItems.push(item);
+  }
+
+  flushCurrentBurst();
+
+  return entries;
+}

package/src/shared/utils/formatTime.ts

@@ -0,0 +1,27 @@
+/** "<1m", "3m", "2h", "3d", or locale date */
+export function formatRelativeTime(date: Date | string): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  const now = Date.now();
+  const diff = now - d.getTime();
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(minutes / 60);
+  
+  if (minutes < 1) return '<1m';
+  if (minutes < 60) return `${minutes}m`;
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d`;
+  return d.toLocaleDateString();
+}
+
+/** "just now", "3m ago", "2h ago", "3d ago" */
+export function formatRelativeTimeVerbose(date: Date | string): string {
+  const d = new Date(date);
+  const now = new Date();
+  const diffInSeconds = Math.max(0, Math.floor((now.getTime() - d.getTime()) / 1000));
+
+  if (diffInSeconds < 60) return 'just now';
+  if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)}m ago`;
+  if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)}h ago`;
+  return `${Math.floor(diffInSeconds / 86400)}d ago`;
+}