@tyroneross/navgator 0.2.0 → 0.2.2

package/web/.next/standalone/web/lib/hooks/use-projects.ts

@@ -0,0 +1,116 @@
+/**
+ * Hook for fetching and managing the project registry
+ */
+
+import { useState, useEffect, useCallback } from "react";
+
+export interface RegisteredProject {
+  path: string;
+  name: string;
+  addedAt: number;
+  lastScan: number | null;
+  hasArchitecture: boolean;
+  componentCount: number;
+  connectionCount: number;
+  lastScanFormatted: string | null;
+}
+
+interface UseProjectsResult {
+  projects: RegisteredProject[];
+  activeProject: string | null;
+  isLoading: boolean;
+  error: string | null;
+  setActiveProject: (path: string) => void;
+  addProject: (path: string) => Promise<void>;
+  removeProject: (path: string) => Promise<void>;
+  refresh: () => Promise<void>;
+}
+
+const ACTIVE_PROJECT_KEY = "navgator-active-project";
+
+export function useProjects(): UseProjectsResult {
+  const [projects, setProjects] = useState<RegisteredProject[]>([]);
+  const [activeProject, setActiveProjectState] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchProjects = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await fetch("/api/projects");
+      const result = await response.json();
+      if (result.success) {
+        setProjects(result.data.projects);
+      } else {
+        setError(result.error || "Failed to fetch projects");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Network error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  const setActiveProject = useCallback((path: string) => {
+    setActiveProjectState(path);
+    localStorage.setItem(ACTIVE_PROJECT_KEY, path);
+    // Dispatch custom event so other hooks/components react
+    window.dispatchEvent(new CustomEvent("navgator-project-changed", { detail: { path } }));
+  }, []);
+
+  const addProject = useCallback(async (path: string) => {
+    try {
+      await fetch("/api/projects", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "add", path }),
+      });
+      await fetchProjects();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to add project");
+    }
+  }, [fetchProjects]);
+
+  const removeProject = useCallback(async (path: string) => {
+    try {
+      await fetch("/api/projects", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "remove", path }),
+      });
+      // If we removed the active project, clear it
+      if (path === activeProject) {
+        setActiveProjectState(null);
+        localStorage.removeItem(ACTIVE_PROJECT_KEY);
+      }
+      await fetchProjects();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to remove project");
+    }
+  }, [fetchProjects, activeProject]);
+
+  // Load active project from localStorage on mount
+  useEffect(() => {
+    const stored = localStorage.getItem(ACTIVE_PROJECT_KEY);
+    if (stored) {
+      setActiveProjectState(stored);
+    }
+  }, []);
+
+  // Fetch projects on mount
+  useEffect(() => {
+    fetchProjects();
+  }, [fetchProjects]);
+
+  return {
+    projects,
+    activeProject,
+    isLoading,
+    error,
+    setActiveProject,
+    addProject,
+    removeProject,
+    refresh: fetchProjects,
+  };
+}

package/web/.next/standalone/web/lib/hooks/use-prompts.ts

@@ -0,0 +1,122 @@
+/**
+ * Hook for fetching and managing prompt/LLM call data
+ */
+
+import { useState, useEffect, useCallback } from "react";
+import type { LLMCall, Prompt, LLMTrackingSummary, PromptsApiResponse } from "../types";
+import { useActiveProject } from "../project-context";
+
+interface UsePromptsResult {
+  calls: LLMCall[];
+  prompts: Prompt[];
+  summary: LLMTrackingSummary | null;
+  isLoading: boolean;
+  error: string | null;
+  source: "scan" | "cache" | "mock" | null;
+  refresh: () => Promise<void>;
+  scan: (projectPath?: string) => Promise<void>;
+}
+
+interface UsePromptsOptions {
+  /** Start in demo mode (use mock data) */
+  demoMode?: boolean;
+  /** Auto-fetch on mount */
+  autoFetch?: boolean;
+  /** Project path for scans */
+  projectPath?: string;
+}
+
+export function usePrompts(options: UsePromptsOptions = {}): UsePromptsResult {
+  const { demoMode = false, autoFetch = true, projectPath: explicitPath } = options;
+  const { activeProjectPath } = useActiveProject();
+  const projectPath = explicitPath || activeProjectPath || undefined;
+
+  const [calls, setCalls] = useState<LLMCall[]>([]);
+  const [prompts, setPrompts] = useState<Prompt[]>([]);
+  const [summary, setSummary] = useState<LLMTrackingSummary | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [source, setSource] = useState<"scan" | "cache" | "mock" | null>(null);
+
+  const fetchData = useCallback(
+    async (forceRefresh = false) => {
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const params = new URLSearchParams();
+        if (demoMode) params.set("demo", "true");
+        if (forceRefresh) params.set("refresh", "true");
+        if (projectPath) params.set("path", projectPath);
+
+        const response = await fetch(`/api/prompts?${params.toString()}`);
+        const result: PromptsApiResponse = await response.json();
+
+        if (result.success && result.data) {
+          setCalls(result.data.calls);
+          setPrompts(result.data.prompts);
+          setSummary(result.data.summary);
+          setSource(result.source);
+        } else {
+          setError(result.error || "Failed to fetch data");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Network error");
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [demoMode, projectPath]
+  );
+
+  const refresh = useCallback(async () => {
+    await fetchData(true);
+  }, [fetchData]);
+
+  const scan = useCallback(
+    async (path?: string) => {
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const response = await fetch("/api/prompts", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ path: path || projectPath }),
+        });
+        const result: PromptsApiResponse = await response.json();
+
+        if (result.success && result.data) {
+          setCalls(result.data.calls);
+          setPrompts(result.data.prompts);
+          setSummary(result.data.summary);
+          setSource(result.source);
+        } else {
+          setError(result.error || "Scan failed");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Network error");
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [projectPath]
+  );
+
+  useEffect(() => {
+    if (autoFetch) {
+      fetchData();
+    }
+  }, [autoFetch, fetchData]);
+
+  return {
+    calls,
+    prompts,
+    summary,
+    isLoading,
+    error,
+    source,
+    refresh,
+    scan,
+  };
+}

package/web/.next/standalone/web/lib/hooks/use-settings.ts

@@ -0,0 +1,135 @@
+/**
+ * Hook for fetching and saving NavGator settings
+ */
+
+import { useState, useEffect, useCallback } from "react";
+
+export interface ScanConfig {
+  rootPath: string;
+  excludePaths: string[];
+  includePatterns: string[];
+  scanDepth: number;
+  watchMode: boolean;
+  autoScanOnChange: boolean;
+}
+
+export interface DetectionConfig {
+  npm: boolean;
+  database: boolean;
+  service: boolean;
+  queue: boolean;
+  cache: boolean;
+  storage: boolean;
+  auth: boolean;
+  llm: boolean;
+  staticAnalysis: boolean;
+  environmentVariables: boolean;
+  configFiles: boolean;
+}
+
+export interface NotificationConfig {
+  enabled: boolean;
+  onNewConnection: boolean;
+  onBreakingChange: boolean;
+  onSecurityIssue: boolean;
+  slackWebhook: string;
+}
+
+export interface DisplayConfig {
+  theme: "dark" | "light" | "system";
+  compactMode: boolean;
+  showLineNumbers: boolean;
+  diagramDirection: "TB" | "LR";
+  maxVisibleConnections: number;
+}
+
+export interface AllSettings {
+  scan: ScanConfig;
+  detection: DetectionConfig;
+  notifications: NotificationConfig;
+  display: DisplayConfig;
+  lastSaved?: number;
+}
+
+interface UseSettingsResult {
+  settings: AllSettings | null;
+  isLoading: boolean;
+  isSaving: boolean;
+  error: string | null;
+  source: "local" | "cache" | "default" | null;
+  save: (data: Partial<AllSettings>) => Promise<boolean>;
+  refresh: () => Promise<void>;
+}
+
+export function useSettings(options: { autoFetch?: boolean } = {}): UseSettingsResult {
+  const { autoFetch = true } = options;
+
+  const [settings, setSettings] = useState<AllSettings | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [source, setSource] = useState<"local" | "cache" | "default" | null>(null);
+
+  const fetchData = useCallback(async (forceRefresh = false) => {
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const params = new URLSearchParams();
+      if (forceRefresh) params.set("refresh", "true");
+
+      const response = await fetch(`/api/settings?${params.toString()}`);
+      const result = await response.json();
+
+      if (result.success && result.data) {
+        setSettings(result.data);
+        setSource(result.source);
+      } else {
+        setError(result.error || "Failed to fetch settings");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Network error");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  const save = useCallback(async (data: Partial<AllSettings>): Promise<boolean> => {
+    setIsSaving(true);
+    setError(null);
+
+    try {
+      const response = await fetch("/api/settings", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data),
+      });
+      const result = await response.json();
+
+      if (result.success && result.data) {
+        setSettings(result.data);
+        return true;
+      } else {
+        setError(result.error || "Failed to save settings");
+        return false;
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Network error");
+      return false;
+    } finally {
+      setIsSaving(false);
+    }
+  }, []);
+
+  const refresh = useCallback(async () => {
+    await fetchData(true);
+  }, [fetchData]);
+
+  useEffect(() => {
+    if (autoFetch) {
+      fetchData();
+    }
+  }, [autoFetch, fetchData]);
+
+  return { settings, isLoading, isSaving, error, source, save, refresh };
+}

package/web/.next/standalone/web/lib/hooks/use-status.ts

@@ -0,0 +1,80 @@
+/**
+ * Hook for fetching and managing project status data
+ */
+
+import { useState, useEffect, useCallback } from "react";
+import type { ProjectStatus, StatusApiResponse } from "../types";
+import { useActiveProject } from "../project-context";
+
+interface UseStatusResult {
+  status: ProjectStatus | null;
+  isLoading: boolean;
+  error: string | null;
+  source: "scan" | "cache" | "mock" | null;
+  refresh: () => Promise<void>;
+}
+
+interface UseStatusOptions {
+  autoFetch?: boolean;
+  projectPath?: string;
+}
+
+export function useStatus(options: UseStatusOptions = {}): UseStatusResult {
+  const { autoFetch = true, projectPath: explicitPath } = options;
+  const { activeProjectPath } = useActiveProject();
+  const projectPath = explicitPath || activeProjectPath || undefined;
+
+  const [status, setStatus] = useState<ProjectStatus | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [source, setSource] = useState<"scan" | "cache" | "mock" | null>(null);
+
+  const fetchData = useCallback(
+    async (forceRefresh = false) => {
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const params = new URLSearchParams();
+        if (forceRefresh) params.set("refresh", "true");
+        if (projectPath) params.set("path", projectPath);
+
+        const response = await fetch(`/api/status?${params.toString()}`);
+        const result: StatusApiResponse = await response.json();
+
+        if (result.success && result.data) {
+          setStatus(result.data);
+          setSource(result.source);
+          if (result.error) {
+            setError(result.error);
+          }
+        } else {
+          setError(result.error || "Failed to fetch status");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Network error");
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [projectPath]
+  );
+
+  const refresh = useCallback(async () => {
+    await fetchData(true);
+  }, [fetchData]);
+
+  useEffect(() => {
+    if (autoFetch) {
+      fetchData();
+    }
+  }, [autoFetch, fetchData]);
+
+  return {
+    status,
+    isLoading,
+    error,
+    source,
+    refresh,
+  };
+}

package/web/.next/standalone/web/lib/project-context.tsx

@@ -0,0 +1,46 @@
+"use client"
+
+import { createContext, useContext, useState, useEffect, type ReactNode } from "react"
+
+interface ProjectContextValue {
+  activeProjectPath: string | null
+  setActiveProjectPath: (path: string | null) => void
+}
+
+const ProjectContext = createContext<ProjectContextValue>({
+  activeProjectPath: null,
+  setActiveProjectPath: () => {},
+})
+
+const ACTIVE_PROJECT_KEY = "navgator-active-project"
+
+export function ProjectProvider({ children }: { children: ReactNode }) {
+  const [activeProjectPath, setActiveProjectPathState] = useState<string | null>(null)
+
+  // Load from localStorage on mount
+  useEffect(() => {
+    const stored = localStorage.getItem(ACTIVE_PROJECT_KEY)
+    if (stored) {
+      setActiveProjectPathState(stored)
+    }
+  }, [])
+
+  const setActiveProjectPath = (path: string | null) => {
+    setActiveProjectPathState(path)
+    if (path) {
+      localStorage.setItem(ACTIVE_PROJECT_KEY, path)
+    } else {
+      localStorage.removeItem(ACTIVE_PROJECT_KEY)
+    }
+  }
+
+  return (
+    <ProjectContext.Provider value={{ activeProjectPath, setActiveProjectPath }}>
+      {children}
+    </ProjectContext.Provider>
+  )
+}
+
+export function useActiveProject() {
+  return useContext(ProjectContext)
+}