trident-git 0.2.0

package/src/components/theme-toggle.tsx

@@ -0,0 +1,37 @@
+"use client"
+
+import * as React from "react"
+import { useTheme } from "next-themes"
+
+export function ThemeToggle() {
+    const { theme, setTheme } = useTheme()
+    const [mounted, setMounted] = React.useState(false)
+
+    React.useEffect(() => {
+        setMounted(true)
+    }, [])
+
+    if (!mounted) {
+        return (
+            <button className="btn btn-ghost btn-sm btn-square">
+                <i className="iconoir-sun-light text-[20px]" aria-hidden="true" />
+                <span className="sr-only">Toggle theme</span>
+            </button>
+        )
+    }
+
+    const toggleTheme = () => {
+        if (theme === 'system') setTheme('light')
+        else if (theme === 'light') setTheme('dark')
+        else setTheme('system')
+    }
+
+    return (
+        <button className="btn btn-ghost btn-sm btn-square" onClick={toggleTheme} title={`Current theme: ${theme}`}>
+            {theme === 'system' && <i className="iconoir-computer text-[20px]" aria-hidden="true" />}
+            {theme === 'light' && <i className="iconoir-sun-light text-[20px]" aria-hidden="true" />}
+            {theme === 'dark' && <i className="iconoir-moon-sat text-[20px]" aria-hidden="true" />}
+            <span className="sr-only">Toggle theme</span>
+        </button>
+    )
+}

package/src/components/toaster.tsx

@@ -0,0 +1,36 @@
+'use client';
+
+import { useToast } from '@/hooks/use-toast';
+import { useEffect, useState } from 'react';
+
+export function Toaster() {
+  const { toasts } = useToast();
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  if (!mounted) return null;
+
+  return (
+    <div className="toast toast-bottom toast-end z-50 p-4 gap-2">
+      {toasts.map((toast) => {
+        let alertClass = 'alert-info';
+        if (toast.type === 'success') alertClass = 'alert-success';
+        else if (toast.type === 'warning' || toast.variant === 'warning') alertClass = 'alert-warning';
+        else if (toast.type === 'error' || toast.variant === 'destructive') alertClass = 'alert-error';
+
+        return (
+          <div key={toast.id} className={`alert ${alertClass} shadow-lg max-w-md w-auto flex-col items-start gap-1 p-3 text-sm animate-in fade-in slide-in-from-bottom-2 duration-300`}>
+             <div className="w-full">
+                {toast.title && <h3 className="font-bold">{toast.title}</h3>}
+                {toast.description && <div className="opacity-90 break-words">{toast.description}</div>}
+             </div>
+             {toast.action && <div className="mt-2 w-full">{toast.action}</div>}
+          </div>
+        )
+      })}
+    </div>
+  );
+}

package/src/components/workspace-repo-open-tracker.tsx

@@ -0,0 +1,39 @@
+'use client';
+
+import { useEffect, useRef } from 'react';
+import { usePathname, useSearchParams } from 'next/navigation';
+import { useRepositories, useUpdateRepository } from '@/hooks/use-git';
+
+export function WorkspaceRepoOpenTracker() {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const repoPath = searchParams.get('path');
+  const { data: repositories } = useRepositories();
+  const updateRepository = useUpdateRepository();
+  const lastTrackedPathRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (!pathname.startsWith('/workspace')) {
+      lastTrackedPathRef.current = null;
+      return;
+    }
+
+    if (!repoPath || !repositories?.some((repo) => repo.path === repoPath)) {
+      return;
+    }
+
+    if (lastTrackedPathRef.current === repoPath) {
+      return;
+    }
+
+    lastTrackedPathRef.current = repoPath;
+    updateRepository.mutate({
+      path: repoPath,
+      updates: {
+        lastOpenedAt: new Date().toISOString(),
+      },
+    });
+  }, [pathname, repoPath, repositories, updateRepository]);
+
+  return null;
+}

package/src/hooks/use-credentials.ts

@@ -0,0 +1,123 @@
+'use client';
+
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import type { Credential, CredentialType } from '@/lib/credentials';
+
+// Re-export types for client-side use
+export type { Credential, CredentialType };
+export type { GitHubCredential, GitLabCredential } from '@/lib/credentials';
+
+async function fetchCredentials(): Promise<Credential[]> {
+  const res = await fetch('/api/credentials');
+  if (!res.ok) {
+    throw new Error('Failed to fetch credentials');
+  }
+  return res.json();
+}
+
+export function useCredentials() {
+  return useQuery({
+    queryKey: ['credentials'],
+    queryFn: fetchCredentials,
+  });
+}
+
+// Create GitHub credential
+interface CreateGitHubParams {
+  type: 'github';
+  token: string;
+}
+
+interface CreateGitLabParams {
+  type: 'gitlab';
+  serverUrl: string;
+  token: string;
+}
+
+type CreateCredentialParams = CreateGitHubParams | CreateGitLabParams;
+
+async function createCredential(params: CreateCredentialParams): Promise<Credential> {
+  const res = await fetch('/api/credentials', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(params),
+  });
+  
+  const data = await res.json();
+  
+  if (!res.ok) {
+    throw new Error(data.error || 'Failed to create credential');
+  }
+  
+  return data;
+}
+
+export function useCreateCredential() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: createCredential,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] });
+    },
+  });
+}
+
+// Update credential
+interface UpdateCredentialParams {
+  id: string;
+  token: string;
+}
+
+async function updateCredential(params: UpdateCredentialParams): Promise<Credential> {
+  const res = await fetch('/api/credentials', {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(params),
+  });
+  
+  const data = await res.json();
+  
+  if (!res.ok) {
+    throw new Error(data.error || 'Failed to update credential');
+  }
+  
+  return data;
+}
+
+export function useUpdateCredential() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: updateCredential,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] });
+    },
+  });
+}
+
+// Delete credential
+async function deleteCredentialApi(id: string): Promise<void> {
+  const res = await fetch('/api/credentials', {
+    method: 'DELETE',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id }),
+  });
+  
+  const data = await res.json();
+  
+  if (!res.ok) {
+    throw new Error(data.error || 'Failed to delete credential');
+  }
+}
+
+export function useDeleteCredential() {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: deleteCredentialApi,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['credentials'] });
+    },
+  });
+}

package/src/hooks/use-escape-dismiss.ts

@@ -0,0 +1,72 @@
+import { useEffect, useRef } from 'react';
+
+type EscapeHandler = {
+  id: number;
+  onEscape: () => void;
+};
+
+const escapeHandlers: EscapeHandler[] = [];
+let nextEscapeHandlerId = 0;
+let hasGlobalKeyListener = false;
+
+function handleEscapeKey(event: KeyboardEvent) {
+  if (event.key !== 'Escape') {
+    return;
+  }
+
+  const topHandler = escapeHandlers[escapeHandlers.length - 1];
+  if (!topHandler) {
+    return;
+  }
+
+  event.preventDefault();
+  topHandler.onEscape();
+}
+
+function attachGlobalListener() {
+  if (hasGlobalKeyListener || typeof document === 'undefined') {
+    return;
+  }
+
+  document.addEventListener('keydown', handleEscapeKey);
+  hasGlobalKeyListener = true;
+}
+
+function detachGlobalListenerIfUnused() {
+  if (!hasGlobalKeyListener || typeof document === 'undefined' || escapeHandlers.length > 0) {
+    return;
+  }
+
+  document.removeEventListener('keydown', handleEscapeKey);
+  hasGlobalKeyListener = false;
+}
+
+export function useEscapeDismiss(enabled: boolean, onEscape: () => void) {
+  const onEscapeRef = useRef(onEscape);
+
+  useEffect(() => {
+    onEscapeRef.current = onEscape;
+  }, [onEscape]);
+
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+
+    const id = ++nextEscapeHandlerId;
+    escapeHandlers.push({
+      id,
+      onEscape: () => onEscapeRef.current(),
+    });
+
+    attachGlobalListener();
+
+    return () => {
+      const index = escapeHandlers.findIndex((handler) => handler.id === id);
+      if (index >= 0) {
+        escapeHandlers.splice(index, 1);
+      }
+      detachGlobalListenerIfUnused();
+    };
+  }, [enabled]);
+}