jettypod 4.4.120 → 4.4.121

package/apps/dashboard/hooks/useClaudeSessions.ts

@@ -1,299 +0,0 @@
-'use client';
-
-import { useState, useCallback, useRef, useEffect } from 'react';
-import type { ClaudeMessage, StreamStatus } from '../lib/session-stream-manager';
-
-export interface ClaudeSession {
-  workItemId: string;
-  title: string;
-  description?: string;
-  messages: ClaudeMessage[];
-  status: StreamStatus;
-  error: string | null;
-  exitCode: number | null;
-  canRetry: boolean;
-  abortController: AbortController | null;
-}
-
-interface UseClaudeSessionsReturn {
-  sessions: Map<string, ClaudeSession>;
-  activeSessionId: string | null;
-  activeSession: ClaudeSession | null;
-  startSession: (workItemId: string, title: string, description?: string) => void;
-  switchSession: (workItemId: string) => void;
-  stopSession: (workItemId: string) => void;
-  retrySession: (workItemId: string) => void;
-  closeSession: (workItemId: string, dbSessionId?: number) => Promise<void>;
-  closeAllSessions: () => void;
-  isSessionRunning: (workItemId: string) => boolean;
-}
-
-export function useClaudeSessions(): UseClaudeSessionsReturn {
-  const [sessions, setSessions] = useState<Map<string, ClaudeSession>>(new Map());
-  const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
-  const sessionsRef = useRef<Map<string, ClaudeSession>>(new Map());
-
-  // Keep ref in sync with state for cleanup
-  useEffect(() => {
-    sessionsRef.current = sessions;
-  }, [sessions]);
-
-  // Cleanup all sessions on unmount (browser close/refresh)
-  useEffect(() => {
-    return () => {
-      sessionsRef.current.forEach((session) => {
-        if (session.abortController) {
-          session.abortController.abort();
-        }
-      });
-    };
-  }, []);
-
-  const updateSession = useCallback((workItemId: string, updates: Partial<ClaudeSession>) => {
-    setSessions((prev) => {
-      const newMap = new Map(prev);
-      const session = newMap.get(workItemId);
-      if (session) {
-        newMap.set(workItemId, { ...session, ...updates });
-      }
-      return newMap;
-    });
-  }, []);
-
-  const startSession = useCallback(async (workItemId: string, title: string, description?: string) => {
-    // Check if session already exists and is running
-    const existingSession = sessionsRef.current.get(workItemId);
-    if (existingSession?.status === 'streaming') {
-      // Just switch to it
-      setActiveSessionId(workItemId);
-      return;
-    }
-
-    // Create or reset session
-    const controller = new AbortController();
-    const newSession: ClaudeSession = {
-      workItemId,
-      title,
-      description,
-      messages: [],
-      status: 'connecting',
-      error: null,
-      exitCode: null,
-      canRetry: false,
-      abortController: controller,
-    };
-
-    setSessions((prev) => {
-      const newMap = new Map(prev);
-      newMap.set(workItemId, newSession);
-      return newMap;
-    });
-    setActiveSessionId(workItemId);
-
-    try {
-      const response = await fetch(`/api/claude/${workItemId}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ title, description }),
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-        try {
-          const errorData = await response.json();
-          if (errorData.message) {
-            errorMessage = errorData.message;
-          }
-        } catch {
-          // Response wasn't JSON
-        }
-        const retryable = response.status >= 500 || response.status === 503;
-        updateSession(workItemId, {
-          status: 'error',
-          error: errorMessage,
-          canRetry: retryable,
-        });
-        return;
-      }
-
-      if (!response.body) {
-        updateSession(workItemId, {
-          status: 'error',
-          error: 'Response body is null',
-          canRetry: true,
-        });
-        return;
-      }
-
-      updateSession(workItemId, { status: 'streaming' });
-
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = '';
-
-      while (true) {
-        const { done, value } = await reader.read();
-
-        if (done) {
-          updateSession(workItemId, { status: 'done' });
-          break;
-        }
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          if (line.startsWith('data: ')) {
-            const data = line.slice(6);
-            try {
-              const parsed = JSON.parse(data);
-              const message: ClaudeMessage = {
-                ...parsed,
-                timestamp: Date.now(),
-              };
-
-              setSessions((prev) => {
-                const newMap = new Map(prev);
-                const session = newMap.get(workItemId);
-                if (session) {
-                  newMap.set(workItemId, {
-                    ...session,
-                    messages: [...session.messages, message],
-                  });
-                }
-                return newMap;
-              });
-
-              if (parsed.type === 'done') {
-                if (parsed.exitCode !== undefined && parsed.exitCode !== 0) {
-                  updateSession(workItemId, {
-                    status: 'error',
-                    exitCode: parsed.exitCode,
-                    error: `Process exited with code ${parsed.exitCode}`,
-                    canRetry: true,
-                  });
-                } else {
-                  updateSession(workItemId, { status: 'done' });
-                }
-              } else if (parsed.type === 'error') {
-                updateSession(workItemId, {
-                  status: 'error',
-                  error: parsed.content || 'Unknown error',
-                  canRetry: true,
-                });
-              }
-            } catch {
-              // Non-JSON line, skip
-            }
-          }
-        }
-      }
-    } catch (err) {
-      if (err instanceof Error && err.name === 'AbortError') {
-        updateSession(workItemId, { status: 'idle' });
-      } else {
-        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-        const isNetworkError = err instanceof TypeError ||
-          (err instanceof Error && (
-            err.message.includes('network') ||
-            err.message.includes('fetch') ||
-            err.message.includes('Failed to fetch')
-          ));
-
-        updateSession(workItemId, {
-          status: 'error',
-          error: isNetworkError ? 'Connection lost' : errorMessage,
-          canRetry: true,
-        });
-      }
-    }
-  }, [updateSession]);
-
-  const switchSession = useCallback((workItemId: string) => {
-    if (sessions.has(workItemId)) {
-      setActiveSessionId(workItemId);
-    }
-  }, [sessions]);
-
-  const stopSession = useCallback((workItemId: string) => {
-    const session = sessions.get(workItemId);
-    if (session?.abortController) {
-      session.abortController.abort();
-    }
-    updateSession(workItemId, {
-      status: 'idle',
-      abortController: null,
-    });
-  }, [sessions, updateSession]);
-
-  const retrySession = useCallback((workItemId: string) => {
-    const session = sessions.get(workItemId);
-    if (session) {
-      startSession(workItemId, session.title, session.description);
-    }
-  }, [sessions, startSession]);
-
-  const closeSession = useCallback(async (workItemId: string, dbSessionId?: number) => {
-    const session = sessions.get(workItemId);
-
-    // Abort if running
-    if (session?.abortController) {
-      session.abortController.abort();
-    }
-
-    // Call API to mark as completed in DB (if we have a DB session ID)
-    if (dbSessionId) {
-      try {
-        await fetch(`/api/claude/sessions?sessionId=${dbSessionId}`, {
-          method: 'DELETE',
-        });
-      } catch (error) {
-        console.error('Failed to close session in DB:', error);
-      }
-    }
-
-    // Remove from local state
-    setSessions((prev) => {
-      const newMap = new Map(prev);
-      newMap.delete(workItemId);
-      return newMap;
-    });
-
-    // If this was the active session, clear it
-    if (activeSessionId === workItemId) {
-      setActiveSessionId(null);
-    }
-  }, [sessions, activeSessionId]);
-
-  const closeAllSessions = useCallback(() => {
-    sessions.forEach((session) => {
-      if (session.abortController) {
-        session.abortController.abort();
-      }
-    });
-    setSessions(new Map());
-    setActiveSessionId(null);
-  }, [sessions]);
-
-  const isSessionRunning = useCallback((workItemId: string) => {
-    const session = sessions.get(workItemId);
-    return session?.status === 'streaming' || session?.status === 'connecting';
-  }, [sessions]);
-
-  const activeSession = activeSessionId ? sessions.get(activeSessionId) ?? null : null;
-
-  return {
-    sessions,
-    activeSessionId,
-    activeSession,
-    startSession,
-    switchSession,
-    stopSession,
-    retrySession,
-    closeSession,
-    closeAllSessions,
-    isSessionRunning,
-  };
-}

package/apps/dashboard/lib/backlog-parser.ts

@@ -1,50 +0,0 @@
-// Local keyword parser for fast backlog work item creation
-// Avoids spawning Claude CLI for obvious inputs
-
-export interface ParseResult {
-  type: 'epic' | 'feature' | 'chore' | 'bug';
-  title: string;
-}
-
-const FILLER_WORDS = /\b(um|uh|like|basically|we need|we should|can you|i want|i need|let's|or something|you know|kind of|sort of|maybe|probably|just|actually)\b/gi;
-
-const TYPE_PATTERNS: { type: ParseResult['type']; keywords: RegExp }[] = [
-  { type: 'bug', keywords: /\b(bug|broken|doesn't work|not working|crash|error|regression)\b/i },
-  { type: 'epic', keywords: /\b(system|full|complete|epic|initiative|project|roadmap)\b/i },
-  { type: 'chore', keywords: /\b(upgrade|refactor|migrate|update|version|infrastructure|cleanup|clean up|tooling|ci|cd|pipeline|lint|config)\b/i },
-  // feature is the default — no pattern needed
-];
-
-export function parseBacklogInput(input: string): ParseResult | null {
-  const trimmed = input.trim();
-  if (!trimmed || trimmed.length < 3) return null;
-
-  // Clean up filler words
-  let cleaned = trimmed.replace(FILLER_WORDS, ' ').replace(/\s+/g, ' ').trim();
-  if (!cleaned || cleaned.length < 3) return null;
-
-  // Detect type from keywords
-  let type: ParseResult['type'] = 'feature';
-  for (const pattern of TYPE_PATTERNS) {
-    if (pattern.keywords.test(cleaned)) {
-      type = pattern.type;
-      break;
-    }
-  }
-
-  // Check for comma-separated list → epic
-  if (cleaned.includes(',') && cleaned.split(',').filter(s => s.trim()).length >= 3) {
-    type = 'epic';
-  }
-
-  // Clean title: remove trailing period, capitalize first letter
-  let title = cleaned.replace(/\.$/, '').trim();
-  title = title.charAt(0).toUpperCase() + title.slice(1);
-
-  // Truncate to 60 chars
-  if (title.length > 60) {
-    title = title.substring(0, 57) + '...';
-  }
-
-  return { type, title };
-}