trident-git 0.2.0

package/src/hooks/use-toast.ts

@@ -0,0 +1,280 @@
+"use client"
+
+import * as React from "react"
+
+const TOAST_LIMIT = 5
+const TOAST_REMOVE_DELAY = 5000
+
+// Helper to copy text to clipboard
+async function copyToClipboard(text: string): Promise<boolean> {
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    // Fallback for older browsers
+    const textArea = document.createElement('textarea');
+    textArea.value = text;
+    textArea.style.position = 'fixed';
+    textArea.style.left = '-9999px';
+    document.body.appendChild(textArea);
+    textArea.select();
+    try {
+      document.execCommand('copy');
+      return true;
+    } catch {
+      return false;
+    } finally {
+      document.body.removeChild(textArea);
+    }
+  }
+}
+
+export type ToastType = "default" | "success" | "warning" | "error" | "info"
+
+export interface Toast {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  type?: ToastType
+  variant?: "default" | "destructive" | "warning" // For compatibility
+  duration?: number
+  action?: React.ReactNode
+}
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type Action =
+  | {
+      type: "ADD_TOAST"
+      toast: Toast
+    }
+  | {
+      type: "UPDATE_TOAST"
+      toast: Partial<Toast>
+    }
+  | {
+      type: "DISMISS_TOAST"
+      toastId?: string
+    }
+  | {
+      type: "REMOVE_TOAST"
+      toastId?: string
+    }
+
+interface State {
+  toasts: Toast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+const addToRemoveQueue = (toastId: string, duration = TOAST_REMOVE_DELAY) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId: toastId,
+    })
+  }, duration)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast.id ? { ...t, ...action.toast } : t
+        ),
+      }
+
+    case "DISMISS_TOAST": {
+      const { toastId } = action
+
+      if (toastId) {
+        addToRemoveQueue(toastId, 0) // Remove immediately for dismiss
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id, 0)
+        })
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== toastId && toastId !== undefined),
+      }
+    }
+    case "REMOVE_TOAST":
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach((listener) => {
+    listener(memoryState)
+  })
+}
+
+function toast(props: Omit<Toast, "id">) {
+  const id = genId()
+
+  const update = (props: Toast) =>
+    dispatch({
+      type: "UPDATE_TOAST",
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })
+
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+    },
+  })
+
+  // Auto remove
+  addToRemoveQueue(id, props.duration || TOAST_REMOVE_DELAY)
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
+  }
+}
+
+// Git error toast helper - shows a destructive toast with copy button
+interface GitErrorToastOptions {
+  title?: string;
+  operation?: string;
+  onFix?: () => void | Promise<void>;
+  fixLabel?: string;
+}
+
+function showGitErrorToast(error: Error | string, options: GitErrorToastOptions = {}) {
+  const errorMessage = typeof error === 'string' ? error : error.message;
+  const title = options.title || (options.operation ? `${options.operation} Failed` : 'Git Operation Failed');
+  
+  const id = genId();
+  
+  // Create a stateful component for the copy button
+  const CopyableErrorDescription = () => {
+    const [copied, setCopied] = React.useState(false);
+    const [fixing, setFixing] = React.useState(false);
+    
+    const handleCopy = async (e: React.MouseEvent) => {
+      e.stopPropagation();
+      const success = await copyToClipboard(errorMessage);
+      if (success) {
+        setCopied(true);
+        setTimeout(() => setCopied(false), 2000);
+      }
+    };
+
+    const handleFix = async (e: React.MouseEvent) => {
+      e.stopPropagation();
+      if (!options.onFix) return;
+
+      setFixing(true);
+      try {
+        await options.onFix();
+        dispatch({ type: "DISMISS_TOAST", toastId: id });
+      } catch (err) {
+        console.error("Fix failed", err);
+        setFixing(false);
+      }
+    };
+    
+    // Container
+    return React.createElement('div', { 
+      className: 'mt-2 space-y-3' 
+    },
+      // Error message box
+      React.createElement('div', { 
+        className: 'max-h-[120px] overflow-y-auto whitespace-pre-wrap font-mono text-[11px] leading-relaxed bg-black/20 p-3 rounded-md break-all text-error-content/90 border border-error-content/20'
+      }, errorMessage),
+      // Buttons container
+      React.createElement('div', { className: 'flex gap-2' },
+        // Copy button
+        React.createElement('button', {
+          onClick: handleCopy,
+          type: 'button',
+          className: `btn btn-xs ${copied ? 'btn-success text-white' : 'bg-white/20 hover:bg-white/30 text-white border-white/20'}`,
+        },
+          copied ? 'Copied!' : 'Copy Error'
+        ),
+        // Fix button
+        options.onFix ? React.createElement('button', {
+          onClick: handleFix,
+          type: 'button',
+          disabled: fixing,
+          className: 'btn btn-xs btn-warning text-white',
+        }, fixing ? 'Fixing...' : (options.fixLabel || 'Fix Issue')) : null
+      )
+    );
+  };
+  
+  toast({
+    type: "error",
+    title,
+    description: React.createElement(CopyableErrorDescription),
+    duration: 10000 // Long duration for errors
+  });
+  
+  return {
+    id,
+    dismiss: () => dispatch({ type: "DISMISS_TOAST", toastId: id }),
+  };
+}
+
+export { useToast, toast, showGitErrorToast }

package/src/hooks/use-workspace-title.ts

@@ -0,0 +1,23 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useRepository } from './use-git';
+import { getRepoFolderName, getRepositoryDisplayName } from '@/lib/utils';
+
+/**
+ * Updates the document title with the repo name and page name.
+ * @param repoPath - The full path to the repository (e.g., "C:\\Users\\user\\projects\\repo" or "/Users/user/projects/repo")
+ * @param pageName - The name of the current page (e.g., "History", "Changes", "Stashes", "Settings")
+ */
+export function useWorkspaceTitle(repoPath: string | null, pageName: string) {
+    const repository = useRepository(repoPath);
+
+    useEffect(() => {
+        const repoName = repoPath
+            ? repository
+                ? getRepositoryDisplayName(repository)
+                : getRepoFolderName(repoPath)
+            : 'Workspace';
+        document.title = `${repoName} | ${pageName}`;
+    }, [repoPath, repository, pageName]);
+}

package/src/lib/api-utils.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+
+/**
+ * Handles errors in Git API routes.
+ *
+ * @param error The error object caught in the try-catch block.
+ * @returns A NextResponse with the appropriate error message and status code.
+ */
+export function handleGitError(error: unknown) {
+  console.error('Git API Error:', error);
+
+  if (error instanceof z.ZodError) {
+    return NextResponse.json({ error: error.issues }, { status: 400 });
+  }
+
+  const message = error instanceof Error ? error.message : String(error);
+
+  if (message.includes('not a git repository')) {
+    return NextResponse.json({ error: 'Not a git repository' }, { status: 400 });
+  }
+
+  return NextResponse.json({ error: message }, { status: 500 });
+}

package/src/lib/branch-colors.ts

@@ -0,0 +1,98 @@
+export interface BranchTagColors {
+  backgroundColor: string;
+  textColor: string;
+}
+
+function hashString(input: string): number {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+export function getBranchColorSeed(branchName: string): number {
+  return hashString(branchName);
+}
+
+function hslToRgb(h: number, s: number, l: number): { r: number; g: number; b: number } {
+  const sat = s / 100;
+  const light = l / 100;
+  const c = (1 - Math.abs(2 * light - 1)) * sat;
+  const hh = h / 60;
+  const x = c * (1 - Math.abs((hh % 2) - 1));
+
+  let r1 = 0;
+  let g1 = 0;
+  let b1 = 0;
+
+  if (hh >= 0 && hh < 1) {
+    r1 = c;
+    g1 = x;
+  } else if (hh >= 1 && hh < 2) {
+    r1 = x;
+    g1 = c;
+  } else if (hh >= 2 && hh < 3) {
+    g1 = c;
+    b1 = x;
+  } else if (hh >= 3 && hh < 4) {
+    g1 = x;
+    b1 = c;
+  } else if (hh >= 4 && hh < 5) {
+    r1 = x;
+    b1 = c;
+  } else {
+    r1 = c;
+    b1 = x;
+  }
+
+  const m = light - c / 2;
+  return {
+    r: Math.round((r1 + m) * 255),
+    g: Math.round((g1 + m) * 255),
+    b: Math.round((b1 + m) * 255),
+  };
+}
+
+function relativeLuminance({ r, g, b }: { r: number; g: number; b: number }): number {
+  const toLinear = (channel: number) => {
+    const value = channel / 255;
+    return value <= 0.03928 ? value / 12.92 : Math.pow((value + 0.055) / 1.055, 2.4);
+  };
+
+  const rLin = toLinear(r);
+  const gLin = toLinear(g);
+  const bLin = toLinear(b);
+  return 0.2126 * rLin + 0.7152 * gLin + 0.0722 * bLin;
+}
+
+function getReadableTextColor(rgb: { r: number; g: number; b: number }): string {
+  const backgroundLum = relativeLuminance(rgb);
+  const whiteContrast = (1.05) / (backgroundLum + 0.05);
+  const blackContrast = (backgroundLum + 0.05) / 0.05;
+  return whiteContrast >= blackContrast ? '#ffffff' : '#111827';
+}
+
+export function getBranchTagColors(branchName: string): BranchTagColors {
+  const hash = getBranchColorSeed(branchName);
+
+  const hue = hash % 360;
+  const saturation = 72 + ((hash >>> 9) % 20); // 72-91
+  const lightness = 84 + ((hash >>> 17) % 8); // 84-91
+
+  const rgb = hslToRgb(hue, saturation, lightness);
+  const textColor = getReadableTextColor(rgb);
+  const backgroundColor = `hsl(${hue} ${saturation}% ${lightness}%)`;
+
+  return {
+    backgroundColor,
+    textColor,
+  };
+}
+
+export function getBranchGraphColor(branchName: string): string {
+  const hash = getBranchColorSeed(branchName);
+  const hue = hash % 360;
+  return `hsl(${hue} 82% 52%)`;
+}