@pennyfarthing/cyclist 10.4.0 → 11.0.0

package/src/public/hooks/useComplexity.ts

@@ -1,80 +0,0 @@
-import { useState, useCallback, useRef, useEffect } from 'react';
-
-export interface FileComplexity {
-  path: string;
-  total_lines: number;
-  longest_function: number;
-  avg_cyclomatic_complexity: number;
-  max_nesting_depth: number;
-  function_count: number;
-}
-
-export interface ComplexityData {
-  success: boolean;
-  target_path: string;
-  file_count: number;
-  files: FileComplexity[];
-  error?: string | null;
-}
-
-export interface UseComplexityOptions {
-  path?: string;
-  top?: number;
-}
-
-export interface UseComplexityReturn {
-  data: ComplexityData | null;
-  isLoading: boolean;
-  error: Error | null;
-  refresh: () => void;
-}
-
-export function useComplexity(options: UseComplexityOptions): UseComplexityReturn {
-  const [data, setData] = useState<ComplexityData | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-  const abortRef = useRef<AbortController | null>(null);
-
-  const fetchComplexity = useCallback(() => {
-    if (abortRef.current) {
-      abortRef.current.abort();
-    }
-
-    const controller = new AbortController();
-    abortRef.current = controller;
-
-    setIsLoading(true);
-    setError(null);
-
-    const params = new URLSearchParams();
-    if (options.path) params.set('path', options.path);
-    if (options.top) params.set('top', String(options.top));
-
-    fetch(`/api/complexity?${params}`, { signal: controller.signal })
-      .then((res) => {
-        if (!res.ok) {
-          throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-        }
-        return res.json();
-      })
-      .then((json: ComplexityData) => {
-        setData(json);
-        setIsLoading(false);
-      })
-      .catch((err) => {
-        if (err.name === 'AbortError') return;
-        setError(err instanceof Error ? err : new Error(String(err)));
-        setIsLoading(false);
-      });
-  }, [options.path, options.top]);
-
-  useEffect(() => {
-    return () => {
-      if (abortRef.current) {
-        abortRef.current.abort();
-      }
-    };
-  }, []);
-
-  return { data, isLoading, error, refresh: fetchComplexity };
-}

package/src/public/hooks/useDeadCode.ts

@@ -1,99 +0,0 @@
-import { useState, useCallback, useRef, useEffect } from 'react';
-
-export interface StaleFile {
-  path: string;
-  last_commit_date: string;
-  days_since_last_commit: number;
-  size_bytes: number;
-}
-
-export interface UnusedExport {
-  symbol: string;
-  file: string;
-  line: number;
-  export_type: string;
-}
-
-export interface DeadCodeData {
-  success: boolean;
-  repo_name?: string;
-  repo_path?: string;
-  time_window_days?: number;
-  stale_files?: StaleFile[];
-  unused_exports?: UnusedExport[];
-  stale_file_count?: number;
-  unused_export_count?: number;
-  total_files?: number;
-  total_exports_scanned?: number;
-  repo_results?: DeadCodeData[];
-  error?: string | null;
-}
-
-export interface UseDeadCodeOptions {
-  days: number;
-  repo?: string;
-  layer?: 'stale' | 'exports' | 'all';
-}
-
-export interface UseDeadCodeReturn {
-  data: DeadCodeData | null;
-  isLoading: boolean;
-  error: Error | null;
-  refresh: () => void;
-}
-
-export function useDeadCode(options: UseDeadCodeOptions): UseDeadCodeReturn {
-  const [data, setData] = useState<DeadCodeData | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-  const abortRef = useRef<AbortController | null>(null);
-
-  const fetchDeadCode = useCallback(() => {
-    // Cancel any in-flight request
-    if (abortRef.current) {
-      abortRef.current.abort();
-    }
-
-    const controller = new AbortController();
-    abortRef.current = controller;
-
-    setIsLoading(true);
-    setError(null);
-
-    const params = new URLSearchParams({
-      days: String(options.days),
-      layer: options.layer || 'all',
-    });
-    if (options.repo) {
-      params.set('repo', options.repo);
-    }
-
-    fetch(`/api/dead-code?${params}`, { signal: controller.signal })
-      .then((res) => {
-        if (!res.ok) {
-          throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-        }
-        return res.json();
-      })
-      .then((json: DeadCodeData) => {
-        setData(json);
-        setIsLoading(false);
-      })
-      .catch((err) => {
-        if (err.name === 'AbortError') return;
-        setError(err instanceof Error ? err : new Error(String(err)));
-        setIsLoading(false);
-      });
-  }, [options.days, options.repo, options.layer]);
-
-  // Cleanup abort controller on unmount
-  useEffect(() => {
-    return () => {
-      if (abortRef.current) {
-        abortRef.current.abort();
-      }
-    };
-  }, []);
-
-  return { data, isLoading, error, refresh: fetchDeadCode };
-}

package/src/public/hooks/useDependencies.ts

@@ -1,82 +0,0 @@
-import { useState, useCallback, useRef, useEffect } from 'react';
-
-export interface OutdatedPackage {
-  name: string;
-  current: string;
-  wanted: string;
-  latest: string;
-  type: string;
-}
-
-export interface SecurityAdvisory {
-  severity: string;
-  count: number;
-}
-
-export interface DependenciesData {
-  success: boolean;
-  target_path: string;
-  outdated: OutdatedPackage[];
-  advisories: SecurityAdvisory[];
-  error?: string | null;
-}
-
-export interface UseDependenciesOptions {
-  path?: string;
-}
-
-export interface UseDependenciesReturn {
-  data: DependenciesData | null;
-  isLoading: boolean;
-  error: Error | null;
-  refresh: () => void;
-}
-
-export function useDependencies(options: UseDependenciesOptions): UseDependenciesReturn {
-  const [data, setData] = useState<DependenciesData | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-  const abortRef = useRef<AbortController | null>(null);
-
-  const fetchDependencies = useCallback(() => {
-    if (abortRef.current) {
-      abortRef.current.abort();
-    }
-
-    const controller = new AbortController();
-    abortRef.current = controller;
-
-    setIsLoading(true);
-    setError(null);
-
-    const params = new URLSearchParams();
-    if (options.path) params.set('path', options.path);
-
-    fetch(`/api/dependencies?${params}`, { signal: controller.signal })
-      .then((res) => {
-        if (!res.ok) {
-          throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-        }
-        return res.json();
-      })
-      .then((json: DependenciesData) => {
-        setData(json);
-        setIsLoading(false);
-      })
-      .catch((err) => {
-        if (err.name === 'AbortError') return;
-        setError(err instanceof Error ? err : new Error(String(err)));
-        setIsLoading(false);
-      });
-  }, [options.path]);
-
-  useEffect(() => {
-    return () => {
-      if (abortRef.current) {
-        abortRef.current.abort();
-      }
-    };
-  }, []);
-
-  return { data, isLoading, error, refresh: fetchDependencies };
-}

package/src/public/hooks/useDiffs.ts

@@ -1,143 +0,0 @@
-/**
- * useDiffs Hook
- *
- * React hook for subscribing to diff data via WebSocket.
- * Story MSSCI-12717 - React Migration
- * Story MSSCI-14238 - Git-based diffs (replaces OTEL-based extraction)
- *
- * IPC DEPRECATED - Now uses WebSocket /ws/diffs
- */
-
-import { useState, useEffect, useCallback, useRef } from 'react';
-
-export interface DiffData {
-  id?: string;
-  path: string;
-  /** @deprecated Use `diff` field for raw git diff content */
-  original: string;
-  /** @deprecated Use `diff` field for raw git diff content */
-  modified: string;
-  /** Raw git diff output (MSSCI-14238) */
-  diff?: string;
-  toolName: string;
-  timestamp: number;
-  /** File status from git (MSSCI-14238) */
-  status?: 'modified' | 'added' | 'deleted' | 'renamed';
-  /** Line additions count (MSSCI-14238) */
-  additions?: number;
-  /** Line deletions count (MSSCI-14238) */
-  deletions?: number;
-}
-
-interface UseDiffsResult {
-  diffs: DiffData[];
-  selectedDiff: DiffData | null;
-  selectDiff: (path: string) => void;
-  clearDiffs: () => void;
-}
-
-const WS_RECONNECT_DELAY = 2000;
-
-export function useDiffs(): UseDiffsResult {
-  const [diffs, setDiffs] = useState<DiffData[]>([]);
-  const [selectedDiff, setSelectedDiff] = useState<DiffData | null>(null);
-  const wsRef = useRef<WebSocket | null>(null);
-
-  useEffect(() => {
-    let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-    let mounted = true;
-
-    const connect = () => {
-      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-      const ws = new WebSocket(`${protocol}//${window.location.host}/ws/diffs`);
-      wsRef.current = ws;
-
-      ws.onopen = () => {
-        console.log('[useDiffs] WebSocket connected');
-      };
-
-      ws.onmessage = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-
-          if (data.type === 'init') {
-            // Initial load of existing diffs
-            const initialDiffs = (data.diffs || []) as DiffData[];
-            setDiffs(initialDiffs);
-            if (initialDiffs.length > 0) {
-              setSelectedDiff(initialDiffs[initialDiffs.length - 1]);
-            }
-          } else if (data.type === 'diff') {
-            // New diff arrived
-            const diffData = data.diff as DiffData;
-            setDiffs(prev => {
-              // Update or add diff
-              const existing = prev.findIndex(d => d.path === diffData.path);
-              if (existing >= 0) {
-                const updated = [...prev];
-                updated[existing] = diffData;
-                return updated;
-              }
-              return [...prev, diffData];
-            });
-            // Auto-select new diff
-            setSelectedDiff(diffData);
-          } else if (data.type === 'refresh') {
-            // Full refresh of diffs (MSSCI-14238: git cache refresh)
-            const refreshedDiffs = (data.diffs || []) as DiffData[];
-            setDiffs(refreshedDiffs);
-            // Keep current selection if it still exists
-            if (refreshedDiffs.length > 0) {
-              setSelectedDiff(prev => {
-                if (prev) {
-                  const stillExists = refreshedDiffs.find(d => d.path === prev.path);
-                  if (stillExists) return stillExists;
-                }
-                return refreshedDiffs[refreshedDiffs.length - 1];
-              });
-            } else {
-              setSelectedDiff(null);
-            }
-          }
-        } catch (err) {
-          console.error('[useDiffs] Failed to parse message:', err);
-        }
-      };
-
-      ws.onclose = () => {
-        if (mounted) {
-          reconnectTimer = setTimeout(connect, WS_RECONNECT_DELAY);
-        }
-      };
-
-      ws.onerror = (err) => {
-        console.error('[useDiffs] WebSocket error:', err);
-        ws.close();
-      };
-    };
-
-    connect();
-
-    return () => {
-      mounted = false;
-      if (reconnectTimer) clearTimeout(reconnectTimer);
-      wsRef.current?.close();
-    };
-  }, []);
-
-  const selectDiff = useCallback((path: string) => {
-    const diff = diffs.find(d => d.path === path);
-    setSelectedDiff(diff || null);
-  }, [diffs]);
-
-  const clearDiffs = useCallback(() => {
-    setDiffs([]);
-    setSelectedDiff(null);
-    // Send clear message to server
-    if (wsRef.current?.readyState === WebSocket.OPEN) {
-      wsRef.current.send(JSON.stringify({ type: 'clear' }));
-    }
-  }, []);
-
-  return { diffs, selectedDiff, selectDiff, clearDiffs };
-}

package/src/public/hooks/useFileBrowser.ts

@@ -1,71 +0,0 @@
-/**
- * useFileBrowser Hook
- *
- * Fetches directory listings from /api/files for the full file tree.
- * Lazy-loads subdirectories on demand.
- */
-
-import { useState, useCallback } from 'react';
-
-export interface DirectoryEntry {
-  name: string;
-  path: string;
-  type: 'file' | 'directory';
-  isModified?: boolean;
-  size?: number;
-}
-
-export interface DirectoryListing {
-  path: string;
-  entries: DirectoryEntry[];
-}
-
-interface DirectoryCache {
-  [path: string]: DirectoryEntry[];
-}
-
-interface UseFileBrowserResult {
-  cache: DirectoryCache;
-  loading: Set<string>;
-  error: string | null;
-  fetchDirectory: (dirPath: string) => Promise<void>;
-}
-
-export function useFileBrowser(): UseFileBrowserResult {
-  const [cache, setCache] = useState<DirectoryCache>({});
-  const [loading, setLoading] = useState<Set<string>>(new Set());
-  const [error, setError] = useState<string | null>(null);
-
-  const fetchDirectory = useCallback(async (dirPath: string) => {
-    // Already cached or loading
-    if (cache[dirPath] || loading.has(dirPath)) return;
-
-    setLoading(prev => new Set(prev).add(dirPath));
-    setError(null);
-
-    try {
-      const params = dirPath ? `?path=${encodeURIComponent(dirPath)}` : '';
-      const res = await fetch(`/api/files${params}`);
-      if (!res.ok) throw new Error(`Failed to list directory: ${res.statusText}`);
-      const listing: DirectoryListing = await res.json();
-
-      // Sort: directories first, then files, alphabetical within each
-      const sorted = listing.entries.sort((a, b) => {
-        if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
-        return a.name.localeCompare(b.name);
-      });
-
-      setCache(prev => ({ ...prev, [dirPath || '__root__']: sorted }));
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to load directory');
-    } finally {
-      setLoading(prev => {
-        const next = new Set(prev);
-        next.delete(dirPath);
-        return next;
-      });
-    }
-  }, [cache, loading]);
-
-  return { cache, loading, error, fetchDirectory };
-}

package/src/public/hooks/useGitStatus.ts

@@ -1,233 +0,0 @@
-/**
- * useGitStatus Hook
- *
- * React hook for subscribing to git status data.
- * Story MSSCI-12717 - React Migration
- * Story MSSCI-12781 - Fixed to handle multi-repo response format
- * Story MSSCI-12798 - Expose full repo array for stacked display
- * Story MSSCI-12860 - IPC to WebSocket Migration (Phase 1)
- *
- * Uses WebSocket /ws/git for real-time updates (no polling).
- */
-
-import { useState, useEffect, useRef } from 'react';
-
-export interface GitStatusData {
-  branch: string;
-  ahead?: number;
-  behind?: number;
-  staged?: number;
-  modified?: number;
-  untracked?: number;
-  isDirty?: boolean;
-}
-
-/** Per-repo status data for stacked display */
-export interface RepoStatusData {
-  name: string;
-  path: string;
-  branch: string;
-  ahead?: number;
-  behind?: number;
-  /** Commits origin/develop has that this branch doesn't (needs pull/rebase) */
-  developBehind?: number;
-  staged: number;
-  modified: number;
-  untracked: number;
-  isDirty: boolean;
-  files: DirtyFile[];
-}
-
-/** Dirty file from git status --porcelain */
-export interface DirtyFile {
-  status: string;  // M, A, D, ?, etc.
-  path: string;
-}
-
-/** Raw repo git info from server */
-interface RepoGitInfo {
-  name: string;
-  path: string;
-  branch: string;
-  clean: boolean;
-  ahead: number | null;
-  behind: number | null;
-  developBehind: number | null;
-  dirtyFiles: DirtyFile[];
-}
-
-/** WebSocket message format from /ws/git */
-interface GitMessage {
-  type: 'init' | 'update';
-  repos: RepoGitInfo[];
-}
-
-/**
- * Count files by type from dirty files array
- */
-function countFilesByType(dirtyFiles: DirtyFile[]): { staged: number; modified: number; untracked: number } {
-  let staged = 0;
-  let modified = 0;
-  let untracked = 0;
-
-  for (const file of dirtyFiles) {
-    // Git status codes:
-    // First char = staging area, Second char = working tree
-    // M = modified, A = added (staged), D = deleted, ? = untracked
-    const indexStatus = file.status[0] || ' ';
-    const workTreeStatus = file.status[1] || ' ';
-
-    // Staged files (anything in the index that's not space or ?)
-    if (indexStatus !== ' ' && indexStatus !== '?') {
-      staged++;
-    }
-
-    // Modified in working tree (not staged)
-    if (workTreeStatus === 'M' || workTreeStatus === 'D') {
-      modified++;
-    }
-
-    // Untracked files
-    if (indexStatus === '?' && workTreeStatus === '?') {
-      untracked++;
-    }
-  }
-
-  return { staged, modified, untracked };
-}
-
-/**
- * Transform raw git response to per-repo status array for stacked display
- */
-function transformToRepoArray(repos: RepoGitInfo[]): RepoStatusData[] {
-  if (!repos?.length) {
-    return [];
-  }
-
-  return repos.map(repo => {
-    const counts = countFilesByType(repo.dirtyFiles);
-    return {
-      name: repo.name,
-      path: repo.path,
-      branch: repo.branch,
-      ahead: repo.ahead ?? undefined,
-      behind: repo.behind ?? undefined,
-      developBehind: repo.developBehind ?? undefined,
-      staged: counts.staged,
-      modified: counts.modified,
-      untracked: counts.untracked,
-      isDirty: !repo.clean,
-      files: repo.dirtyFiles,
-    };
-  });
-}
-
-/**
- * Transform raw git response to GitStatusData for display (legacy aggregated view)
- * Uses first repo for branch info, aggregates file counts across all repos
- */
-function transformGitResponse(repos: RepoGitInfo[]): GitStatusData | null {
-  if (!repos?.length) {
-    return null;
-  }
-
-  // Use first repo as primary (usually the orchestrator or main repo)
-  const primaryRepo = repos[0];
-
-  // Count file types across all repos
-  let staged = 0;
-  let modified = 0;
-  let untracked = 0;
-
-  for (const repo of repos) {
-    const counts = countFilesByType(repo.dirtyFiles);
-    staged += counts.staged;
-    modified += counts.modified;
-    untracked += counts.untracked;
-  }
-
-  // Check if any repo is dirty
-  const isDirty = repos.some(repo => !repo.clean);
-
-  return {
-    branch: primaryRepo.branch,
-    ahead: primaryRepo.ahead ?? undefined,
-    behind: primaryRepo.behind ?? undefined,
-    staged: staged > 0 ? staged : undefined,
-    modified: modified > 0 ? modified : undefined,
-    untracked: untracked > 0 ? untracked : undefined,
-    isDirty,
-  };
-}
-
-interface UseGitStatusResult {
-  gitStatus: GitStatusData | null;
-  repos: RepoStatusData[];
-  isLoading: boolean;
-  error: Error | null;
-}
-
-export function useGitStatus(): UseGitStatusResult {
-  const [gitStatus, setGitStatus] = useState<GitStatusData | null>(null);
-  const [repos, setRepos] = useState<RepoStatusData[]>([]);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-  const wsRef = useRef<WebSocket | null>(null);
-  const reconnectTimeoutRef = useRef<ReturnType<typeof setTimeout>>();
-
-  useEffect(() => {
-    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const wsUrl = `${protocol}//${window.location.host}/ws/git`;
-
-    const connect = () => {
-      try {
-        wsRef.current = new WebSocket(wsUrl);
-
-        wsRef.current.onopen = () => {
-          console.debug('[useGitStatus] WebSocket connected');
-        };
-
-        wsRef.current.onmessage = (event) => {
-          try {
-            const msg = JSON.parse(event.data) as GitMessage;
-            if (msg.type === 'init' || msg.type === 'update') {
-              setGitStatus(transformGitResponse(msg.repos));
-              setRepos(transformToRepoArray(msg.repos));
-              setIsLoading(false);
-              setError(null);
-            }
-          } catch (err) {
-            console.error('[useGitStatus] Failed to parse message:', err);
-          }
-        };
-
-        wsRef.current.onclose = () => {
-          console.debug('[useGitStatus] WebSocket closed, reconnecting...');
-          reconnectTimeoutRef.current = setTimeout(connect, 2000);
-        };
-
-        wsRef.current.onerror = (err) => {
-          console.error('[useGitStatus] WebSocket error:', err);
-          setError(new Error('WebSocket connection failed'));
-        };
-      } catch (err) {
-        console.error('[useGitStatus] WebSocket init failed:', err);
-        setError(err instanceof Error ? err : new Error('Failed to connect'));
-        setIsLoading(false);
-      }
-    };
-
-    connect();
-
-    return () => {
-      if (reconnectTimeoutRef.current) {
-        clearTimeout(reconnectTimeoutRef.current);
-      }
-      if (wsRef.current) {
-        wsRef.current.close();
-      }
-    };
-  }, []);
-
-  return { gitStatus, repos, isLoading, error };
-}