vibepulse 0.2.0 → 0.2.1

package/.next/standalone/src/lib/sessionArchiveOverrides.ts

@@ -0,0 +1,116 @@
+const FORCE_UNARCHIVE_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
+const STICKY_STATUS_BLOCK_RETENTION_MS = 10 * 60 * 1000;
+const MAX_FORCE_UNARCHIVE_ENTRIES = 5000;
+
+type ForceUnarchiveEntry = {
+  markedAt: number;
+  lastSeenAt: number;
+};
+
+const forceUnarchivedSessionIds = new Map<string, ForceUnarchiveEntry>();
+const stickyStatusBlockedSessionIds = new Map<string, number>();
+
+function evictStickyStatusBlocks(now: number): void {
+  for (const [sessionId, markedAt] of stickyStatusBlockedSessionIds) {
+    if (now - markedAt > STICKY_STATUS_BLOCK_RETENTION_MS) {
+      stickyStatusBlockedSessionIds.delete(sessionId);
+    }
+  }
+
+  if (stickyStatusBlockedSessionIds.size <= MAX_FORCE_UNARCHIVE_ENTRIES) {
+    return;
+  }
+
+  const overflow = stickyStatusBlockedSessionIds.size - MAX_FORCE_UNARCHIVE_ENTRIES;
+  const oldest = Array.from(stickyStatusBlockedSessionIds.entries()).sort((a, b) => a[1] - b[1]);
+
+  for (let i = 0; i < overflow; i++) {
+    const [sessionId] = oldest[i] ?? [];
+    if (!sessionId) break;
+    stickyStatusBlockedSessionIds.delete(sessionId);
+  }
+}
+
+function evictStale(now: number): void {
+  for (const [sessionId, entry] of forceUnarchivedSessionIds) {
+    if (now - entry.markedAt > FORCE_UNARCHIVE_RETENTION_MS) {
+      forceUnarchivedSessionIds.delete(sessionId);
+    }
+  }
+
+  if (forceUnarchivedSessionIds.size <= MAX_FORCE_UNARCHIVE_ENTRIES) {
+    return;
+  }
+
+  const overflow = forceUnarchivedSessionIds.size - MAX_FORCE_UNARCHIVE_ENTRIES;
+  const oldestByLastSeen = Array.from(forceUnarchivedSessionIds.entries()).sort(
+    (a, b) => a[1].lastSeenAt - b[1].lastSeenAt
+  );
+
+  for (let i = 0; i < overflow; i++) {
+    const [sessionId] = oldestByLastSeen[i] ?? [];
+    if (!sessionId) break;
+    forceUnarchivedSessionIds.delete(sessionId);
+  }
+}
+
+export function markSessionForceUnarchived(sessionId: string, now: number = Date.now()): void {
+  const current = forceUnarchivedSessionIds.get(sessionId);
+  forceUnarchivedSessionIds.set(sessionId, {
+    markedAt: current?.markedAt ?? now,
+    lastSeenAt: now,
+  });
+  evictStale(now);
+}
+
+export function clearSessionForceUnarchived(sessionId: string): void {
+  forceUnarchivedSessionIds.delete(sessionId);
+}
+
+export function markSessionStickyStatusBlocked(sessionId: string, now: number = Date.now()): void {
+  stickyStatusBlockedSessionIds.set(sessionId, now);
+  evictStickyStatusBlocks(now);
+}
+
+export function clearSessionStickyStatusBlocked(sessionId: string): void {
+  stickyStatusBlockedSessionIds.delete(sessionId);
+}
+
+export function takeSessionStickyStatusBlocked(sessionId: string, now: number = Date.now()): boolean {
+  const markedAt = stickyStatusBlockedSessionIds.get(sessionId);
+  if (typeof markedAt !== 'number') {
+    return false;
+  }
+
+  if (now - markedAt > STICKY_STATUS_BLOCK_RETENTION_MS) {
+    stickyStatusBlockedSessionIds.delete(sessionId);
+    return false;
+  }
+
+  stickyStatusBlockedSessionIds.delete(sessionId);
+  return true;
+}
+
+export function pruneSessionStickyStatusBlocked(now: number = Date.now()): void {
+  evictStickyStatusBlocks(now);
+}
+
+export function shouldForceSessionUnarchived(sessionId: string, now: number = Date.now()): boolean {
+  const entry = forceUnarchivedSessionIds.get(sessionId);
+  if (!entry) return false;
+
+  if (now - entry.markedAt > FORCE_UNARCHIVE_RETENTION_MS) {
+    forceUnarchivedSessionIds.delete(sessionId);
+    return false;
+  }
+
+  forceUnarchivedSessionIds.set(sessionId, {
+    ...entry,
+    lastSeenAt: now,
+  });
+  return true;
+}
+
+export function pruneSessionForceUnarchived(now: number = Date.now()): void {
+  evictStale(now);
+}

package/.next/standalone/src/lib/transform.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { transformSession } from './transform';
+import { OpencodeSession } from '@/types';
+
+type SessionOverrides = Partial<OpencodeSession> & {
+  children?: OpencodeSession[];
+};
+
+function makeSession(overrides: SessionOverrides = {}): OpencodeSession {
+  const now = Date.now();
+  return {
+    id: overrides.id ?? 'session-1',
+    slug: overrides.slug ?? 'session_1_agent',
+    title: overrides.title ?? 'Session 1',
+    directory: overrides.directory ?? '/tmp/project',
+    time: overrides.time ?? {
+      created: now - 5_000,
+      updated: now,
+    },
+    realTimeStatus: overrides.realTimeStatus,
+    waitingForUser: overrides.waitingForUser,
+    children: overrides.children,
+    projectName: overrides.projectName,
+    branch: overrides.branch,
+    messageCount: overrides.messageCount,
+    hasTodos: overrides.hasTodos,
+    hasTranscript: overrides.hasTranscript,
+    debugReason: overrides.debugReason,
+    parentID: overrides.parentID,
+    hostId: overrides.hostId,
+    hostLabel: overrides.hostLabel,
+    hostKind: overrides.hostKind,
+    rawSessionId: overrides.rawSessionId,
+    sourceSessionKey: overrides.sourceSessionKey,
+    readOnly: overrides.readOnly,
+  };
+}
+
+describe('transformSession archive precedence', () => {
+  it('keeps archived session in done even if direct status is busy', () => {
+    const session = makeSession({
+      realTimeStatus: 'busy',
+      time: {
+        created: 100,
+        updated: 200,
+        archived: 300,
+      },
+    });
+
+    const card = transformSession(session);
+
+    expect(card.status).toBe('done');
+    expect(card.archivedAt).toBe(300);
+    expect(card.opencodeStatus).toBe('busy');
+  });
+
+  it('keeps archived parent in done even when a child is active', () => {
+    const child = makeSession({
+      id: 'child-1',
+      slug: 'session_2_child',
+      realTimeStatus: 'busy',
+      time: {
+        created: 100,
+        updated: 200,
+      },
+    });
+
+    const parent = makeSession({
+      realTimeStatus: 'idle',
+      time: {
+        created: 100,
+        updated: 200,
+        archived: 300,
+      },
+      children: [child],
+    });
+
+    const card = transformSession(parent);
+
+    expect(card.status).toBe('done');
+    expect(card.opencodeStatus).toBe('busy');
+  });
+
+  it('keeps archived session in done even when waiting for user', () => {
+    const session = makeSession({
+      realTimeStatus: 'retry',
+      waitingForUser: true,
+      time: {
+        created: 100,
+        updated: 200,
+        archived: 300,
+      },
+    });
+
+    const card = transformSession(session);
+
+    expect(card.status).toBe('done');
+    expect(card.archivedAt).toBe(300);
+    expect(card.waitingForUser).toBe(true);
+  });
+
+  it('does not crash when a remote session is missing slug', () => {
+    const session = {
+      ...makeSession({
+      id: 'remote:session-1',
+      hostId: 'remote-1',
+      hostLabel: 'Remote 1',
+      hostKind: 'remote',
+      readOnly: false,
+      }),
+      slug: undefined,
+    } as unknown as OpencodeSession;
+
+    const card = transformSession(session);
+
+    expect(card.sessionSlug).toBe('');
+    expect(card.agents).toEqual([]);
+    expect(card.hostId).toBe('remote-1');
+    expect(card.readOnly).toBe(false);
+  });
+});

package/.next/standalone/src/lib/transform.ts

@@ -0,0 +1,193 @@
+import { KanbanCard, OpencodeSession, KanbanColumn, SessionDebugReason } from '@/types';
+
+interface EnrichedSession extends OpencodeSession {
+  realTimeStatus?: 'idle' | 'busy' | 'retry';
+  projectName?: string;
+  branch?: string;
+  waitingForUser?: boolean;
+}
+
+type EnrichedChild = NonNullable<EnrichedSession['children']>[number];
+
+const RECENT_ACTIVITY_FALLBACK_MS = 5 * 60 * 1000;
+
+function isRecentlyUpdated(updatedAt: number | undefined, now: number): boolean {
+    return typeof updatedAt === 'number' && updatedAt > 0 && now - updatedAt <= RECENT_ACTIVITY_FALLBACK_MS;
+}
+
+function deriveChildDebugReason(child: EnrichedChild | undefined, now: number): SessionDebugReason | undefined {
+    if (!child) return undefined;
+    if (child.debugReason) return child.debugReason;
+
+    const childStatus = child.realTimeStatus || 'idle';
+    if (child.waitingForUser || childStatus === 'retry') {
+        return 'waiting_for_user';
+    }
+
+    if (childStatus === 'busy') {
+        const childUpdatedAt = child.time?.updated || child.time?.created;
+        return isRecentlyUpdated(childUpdatedAt, now) ? 'child_recent_activity' : 'child_unknown_fallback';
+    }
+
+    return undefined;
+}
+
+function deriveSessionDebugReason({
+    session,
+    waitingForUser,
+    effectiveStatus,
+    firstActiveChild,
+    firstWaitingChild,
+    now,
+}: {
+    session: EnrichedSession;
+    waitingForUser: boolean;
+    effectiveStatus: 'idle' | 'busy' | 'retry';
+    firstActiveChild: EnrichedChild | undefined;
+    firstWaitingChild: EnrichedChild | undefined;
+    now: number;
+}): SessionDebugReason | undefined {
+    if (session.debugReason) {
+        return session.debugReason;
+    }
+
+    if (waitingForUser) {
+        return (
+            deriveChildDebugReason(firstWaitingChild, now) ||
+            deriveChildDebugReason(firstActiveChild, now) ||
+            'waiting_for_user'
+        );
+    }
+
+    if (effectiveStatus === 'busy') {
+        const selfStatus = session.realTimeStatus || 'idle';
+        if (selfStatus === 'busy' || selfStatus === 'retry') {
+            const sessionUpdatedAt = session.time?.updated || session.time?.created;
+            return isRecentlyUpdated(sessionUpdatedAt, now) ? 'direct_status_busy' : 'sticky_busy';
+        }
+
+        if (firstActiveChild) {
+            return 'child_recent_activity';
+        }
+
+        return 'unknown_fallback';
+    }
+
+    return undefined;
+}
+
+export function transformSession(session: EnrichedSession): KanbanCard {
+    let status: KanbanColumn;
+    const children = session.children || [];
+    const sessionSlug = typeof session.slug === 'string' ? session.slug : '';
+
+    // Staleness window: child blockers older than this don't keep parent in review
+    const CHILD_BLOCKER_STALENESS_MS = 10 * 60 * 1000; // 10 minutes
+    const now = Date.now();
+
+    const realTimeStatus = session.realTimeStatus || 'idle';
+    const hasActiveChildren = children.some((child) => {
+        const childStatus = child.realTimeStatus || 'idle';
+        return childStatus === 'busy' || childStatus === 'retry';
+    });
+    const effectiveStatus =
+        realTimeStatus === 'retry'
+            ? 'retry'
+            : (realTimeStatus === 'busy' || hasActiveChildren)
+                ? 'busy'
+                : 'idle';
+    const hasWaitingChildren = children.some((child) => {
+        const childStatus = child.realTimeStatus || 'idle';
+        const isBlocker = childStatus === 'retry' || (childStatus !== 'idle' && !!child.waitingForUser);
+        if (!isBlocker) return false;
+        // Only consider fresh blockers (within staleness window)
+        const childUpdated = child.time?.updated || now;
+        return (now - childUpdated) < CHILD_BLOCKER_STALENESS_MS;
+    });
+    const parentWaiting = !!session.waitingForUser;
+    const waitingForUser =
+        effectiveStatus === 'retry' ||
+        parentWaiting ||
+        (effectiveStatus === 'busy' && hasWaitingChildren);
+    const firstActiveChild = children.find((child) => {
+        const childStatus = child.realTimeStatus || 'idle';
+        return childStatus === 'busy' || childStatus === 'retry';
+    });
+    const firstWaitingChild = children.find((child) => {
+        const childStatus = child.realTimeStatus || 'idle';
+        return childStatus === 'retry' || (childStatus !== 'idle' && !!child.waitingForUser);
+    });
+    const debugReason = deriveSessionDebugReason({
+        session,
+        waitingForUser,
+        effectiveStatus,
+        firstActiveChild,
+        firstWaitingChild,
+        now,
+    });
+    
+    if (session.time?.archived) {
+        status = 'done';
+    } else if (waitingForUser) {
+        status = 'review';  // Needs Attention
+    } else if (effectiveStatus === 'busy') {
+        status = 'busy';
+    } else {
+        status = 'idle';
+    }
+    
+     return {
+         id: session.id,
+         sessionSlug,
+         title: session.title || 'Untitled Session',
+         directory: session.directory,
+         projectName: session.projectName || 'Unknown Project',
+         branch: session.branch,
+         agents: extractAgents(sessionSlug),
+         messageCount: session.messageCount || 0,
+         status: status,
+         opencodeStatus: effectiveStatus,
+         waitingForUser,
+         debugReason,
+         todosTotal: 0,
+         todosCompleted: 0,
+         createdAt: session.time.created,
+         updatedAt: session.time.updated,
+         archivedAt: status === 'done' ? session.time.archived : undefined,
+         sortOrder: 0,
+          hostId: session.hostId,
+          hostLabel: session.hostLabel,
+          hostKind: session.hostKind,
+          hostBaseUrl: session.hostBaseUrl,
+          rawSessionId: session.rawSessionId,
+          sourceSessionKey: session.sourceSessionKey,
+          readOnly: session.readOnly,
+         children: children.map(c => ({
+             id: c.id,
+             title: c.title,
+             realTimeStatus: c.realTimeStatus || 'idle',
+             waitingForUser:
+                 (c.realTimeStatus || 'idle') === 'retry' ||
+                 ((c.realTimeStatus || 'idle') === 'busy' && !!c.waitingForUser),
+              debugReason: deriveChildDebugReason(c, now),
+             createdAt: c.time?.created || 0,
+             updatedAt: c.time?.updated || 0,
+         })),
+     };
+}
+
+function extractAgents(slug?: string): string[] {
+    if (!slug) return [];
+    // Extract agent names from session slug
+    // Slug format: session_<timestamp>_<agent1>-<agent2>...
+    const parts = slug.split('_');
+    if (parts.length >= 3) {
+        const agentsPart = parts[parts.length - 1];
+        return agentsPart.split('-').filter(Boolean);
+    }
+    return [];
+}
+
+export function transformSessions(sessions: EnrichedSession[]): KanbanCard[] {
+    return sessions.map(transformSession);
+}

package/.next/standalone/src/test/setup.ts

@@ -0,0 +1,8 @@
+import '@testing-library/jest-dom/vitest';
+import { cleanup } from '@testing-library/react';
+import { afterEach } from 'vitest';
+
+// Cleanup after each test
+afterEach(() => {
+  cleanup();
+});

package/.next/standalone/src/types/index.ts

@@ -0,0 +1,152 @@
+// Core types
+export type KanbanColumn = 'idle' | 'busy' | 'review' | 'done';
+export type SessionDebugReason =
+  | 'child_recent_activity'
+  | 'child_unknown_fallback'
+  | 'direct_status_busy'
+  | 'recent_activity_fallback'
+  | 'sticky_busy'
+  | 'unknown_fallback'
+  | 'waiting_for_user';
+
+export interface KanbanCard {
+  id: string; // composite key: hostId:sessionId
+  sessionSlug: string;
+  title: string;
+  directory: string;
+  projectName: string;
+  branch?: string;
+  agents: string[];
+  messageCount: number;
+  status: KanbanColumn;
+  opencodeStatus: OpencodeStatus;
+  waitingForUser: boolean;
+  debugReason?: SessionDebugReason;
+  todosTotal: number;
+  todosCompleted: number;
+  createdAt: number;
+  updatedAt: number;
+  archivedAt?: number;
+  sortOrder: number;
+  // Host-aware fields (direct, not nested)
+  hostId?: string;
+  hostLabel?: string;
+  hostKind?: HostSourceKind;
+  hostBaseUrl?: string;
+  rawSessionId?: string; // original session ID without host prefix
+  sourceSessionKey?: string; // alias for id, kept for compatibility
+  readOnly?: boolean;
+   children?: {
+     id: string;
+     title?: string;
+     realTimeStatus: string;
+     waitingForUser: boolean;
+     debugReason?: SessionDebugReason;
+     createdAt: number;
+     updatedAt: number;
+   }[];
+}
+
+// OpenCode event types
+export interface OpencodeSession {
+  id: string; // composite key: hostId:sessionId
+  slug: string;
+  title?: string;
+  directory: string;
+  projectName?: string;
+  branch?: string;
+  parentID?: string;  // Used to filter subagents
+  time: {
+    created: number;
+    updated: number;
+    archived?: number;
+  };
+  messageCount?: number;
+  hasTodos?: boolean;
+  hasTranscript?: boolean;
+  realTimeStatus?: 'idle' | 'busy' | 'retry';  // Real-time status
+  waitingForUser?: boolean;
+  debugReason?: SessionDebugReason;
+  children?: OpencodeSession[];
+  // Host-aware fields (direct, not nested)
+  hostId?: string;
+  hostLabel?: string;
+  hostKind?: HostSourceKind;
+  hostBaseUrl?: string;
+  rawSessionId?: string; // original session ID without host prefix
+  sourceSessionKey?: string; // alias for id, kept for compatibility
+  readOnly?: boolean;
+}
+
+export type OpencodeEventType =
+  | 'session.status'
+  | 'session.updated'
+  | 'session.created'
+  | 'session.deleted'
+  | 'session.archived'
+  | 'question.asked'
+  | 'permission.asked'
+  | 'permission.updated'
+  | 'question.replied'
+  | 'question.rejected'
+  | 'permission.replied'
+  | 'todo.updated';
+
+export interface OpencodeEvent {
+  type: OpencodeEventType;
+  properties?: {
+    sessionID?: string;
+    info?: OpencodeSession;
+    status?: {
+      type?: OpencodeStatus;
+    };
+    [key: string]: unknown;
+  };
+  timestamp: number;
+}
+
+// Status mapping
+export type OpencodeStatus = 'idle' | 'busy' | 'retry';
+
+// Host source types
+export type HostSourceKind = 'local' | 'remote';
+
+export interface BuiltInHostSource {
+  hostId: 'local';
+  hostLabel: 'Local';
+  hostKind: 'local';
+}
+
+export interface RemoteNodeConfig {
+  hostId: string;
+  hostLabel: string;
+  baseUrl: string;
+  enabled: boolean;
+  tokenConfigured?: boolean;
+}
+
+export type RemoteHostConfig = RemoteNodeConfig;
+
+export type HostFilterValue = 'all' | 'local' | string;
+
+export interface HostStatus {
+  hostId: string;
+  hostLabel: string;
+  hostKind: HostSourceKind;
+  online: boolean;
+  degraded?: boolean;
+  reason?: string;
+  baseUrl?: string;
+}
+
+// Host-aware fields that appear directly on sessions/cards
+// (not nested in a wrapper object)
+
+// Type guards
+export function isKanbanColumn(value: string): value is KanbanColumn {
+  return ['idle', 'busy', 'review', 'done'].includes(value);
+}
+
+export function isOpencodeStatus(value: string): value is OpencodeStatus {
+  return ['idle', 'busy', 'retry'].includes(value);
+}