@mndrk/agx 2.3.3 → 2.4.1

package/cloud-runtime/standalone/apps/local/hooks/{useLinearConnection.ts → useTrackerConnection.ts}

@@ -1,8 +1,4 @@
-// TODO(multi-tracker): This hook manages the Linear OAuth/API-key connection.
-// Abstraction path: rename to `useTrackerConnection(trackerType: 'linear' | 'jira' | ...)`.
-// Each tracker type maps to its own `/api/<tracker>/status`, `/api/<tracker>/auth`, and
-// `/api/<tracker>/token` routes. The returned interface (connected, user, connect, disconnect,
-// configureMcp) stays the same — only the endpoints change.
+"use client";
 
 import { useState, useEffect, useCallback, useRef } from "react";
 
@@ -14,7 +10,7 @@ interface CliStatus {
 
 type McpStatus = Record<string, boolean>;
 
-interface LinearConnectionState {
+interface TrackerConnectionState {
   connected: boolean;
   loading: boolean;
   user: { name: string; email: string } | null;
@@ -27,7 +23,44 @@ interface LinearConnectionState {
   refresh: () => Promise<boolean>;
 }
 
-export function useLinearConnection(projectId: string): LinearConnectionState {
+// Module-level cache shared across all hook instances — 5-minute TTL.
+const STATUS_TTL = 5 * 60 * 1000;
+type CacheEntry = {
+  connected: boolean;
+  user: { name: string; email: string } | null;
+  clis: CliStatus;
+  mcpConfigured: McpStatus;
+  ts: number;
+};
+const statusCache = new Map<string, CacheEntry>();
+
+function getCached(key: string): CacheEntry | null {
+  const entry = statusCache.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.ts > STATUS_TTL) {
+    statusCache.delete(key);
+    return null;
+  }
+  return entry;
+}
+
+function setCached(key: string, entry: Omit<CacheEntry, "ts">) {
+  statusCache.set(key, { ...entry, ts: Date.now() });
+}
+
+function bustCache(key: string) {
+  statusCache.delete(key);
+}
+
+/**
+ * Tracker-agnostic connection hook.
+ * Replaces useLinearConnection by hitting /api/trackers/[tracker]/status instead of /api/linear/status.
+ * Connection status is cached for 5 minutes to avoid re-fetching on every navigation.
+ */
+export function useTrackerConnection(
+  trackerType: string,
+  projectId: string
+): TrackerConnectionState {
   const [connected, setConnected] = useState(false);
   const [loading, setLoading] = useState(true);
   const [user, setUser] = useState<{ name: string; email: string } | null>(null);
@@ -35,34 +68,62 @@ export function useLinearConnection(projectId: string): LinearConnectionState {
   const [mcpConfigured, setMcpConfigured] = useState<McpStatus>({});
   const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
 
+  const basePath = `/api/trackers/${encodeURIComponent(trackerType)}`;
+  const cacheKey = `${trackerType}:${projectId}`;
+
   const refreshMcp = useCallback(async () => {
     try {
-      const res = await fetch("/api/linear/mcp-setup");
+      const res = await fetch(`${basePath}/mcp-setup`);
       const data = await res.json();
       setMcpConfigured(data.configured ?? {});
     } catch {
       // ignore
     }
-  }, []);
+  }, [basePath]);
 
   const refresh = useCallback(async () => {
     if (!projectId) {
+      // projectId not yet resolved (useProjects still loading) — hold the
+      // skeleton until the real ID arrives. Don't set loading: false here.
       setConnected(false);
-      setLoading(false);
       return false;
     }
+
+    // Serve from cache if fresh — resolves immediately without a network round-trip.
+    const cached = getCached(cacheKey);
+    if (cached) {
+      setConnected(cached.connected);
+      setUser(cached.user);
+      setClis(cached.clis);
+      setMcpConfigured(cached.mcpConfigured);
+      setLoading(false);
+      return cached.connected;
+    }
+
     try {
       const query = `?projectId=${encodeURIComponent(projectId)}`;
       const [statusRes, mcpRes] = await Promise.all([
-        fetch(`/api/linear/status${query}`),
-        fetch("/api/linear/mcp-setup"),
+        fetch(`${basePath}/status${query}`),
+        fetch(`${basePath}/mcp-setup`),
       ]);
       const statusData = await statusRes.json();
       const mcpData = await mcpRes.json();
+      const resolvedClis: CliStatus = statusData.clis ?? { claude: false, codex: false, gemini: false };
+      const resolvedMcp: McpStatus = mcpData.configured ?? {};
+      const resolvedUser = statusData.user ?? null;
+
       setConnected(statusData.connected);
-      setUser(statusData.user ?? null);
-      setClis(statusData.clis ?? { claude: false, codex: false, gemini: false });
-      setMcpConfigured(mcpData.configured ?? {});
+      setUser(resolvedUser);
+      setClis(resolvedClis);
+      setMcpConfigured(resolvedMcp);
+
+      setCached(cacheKey, {
+        connected: statusData.connected,
+        user: resolvedUser,
+        clis: resolvedClis,
+        mcpConfigured: resolvedMcp,
+      });
+
       return statusData.connected as boolean;
     } catch {
       setConnected(false);
@@ -70,7 +131,25 @@ export function useLinearConnection(projectId: string): LinearConnectionState {
     } finally {
       setLoading(false);
     }
-  }, [projectId]);
+  }, [projectId, basePath, cacheKey]);
+
+  // Reset stale state immediately when tracker type or project changes,
+  // before the new fetch (or cache hit) completes.
+  useEffect(() => {
+    const cached = getCached(cacheKey);
+    if (cached) {
+      // Apply cached values synchronously so there's no loading flash at all.
+      setConnected(cached.connected);
+      setUser(cached.user);
+      setClis(cached.clis);
+      setMcpConfigured(cached.mcpConfigured);
+      setLoading(false);
+    } else {
+      setLoading(true);
+      setConnected(false);
+      setUser(null);
+    }
+  }, [trackerType, projectId, cacheKey]);
 
   useEffect(() => {
     refresh();
@@ -81,23 +160,23 @@ export function useLinearConnection(projectId: string): LinearConnectionState {
 
   const connect = useCallback(() => {
     if (!projectId) return;
-    // Open OAuth in a new tab
+    bustCache(cacheKey);
     window.open(
-      `/api/linear/auth?projectId=${encodeURIComponent(projectId)}`,
+      `${basePath}/auth?projectId=${encodeURIComponent(projectId)}`,
       "_blank",
       "noopener"
     );
 
-    // Poll for connection until successful
     if (pollRef.current) clearInterval(pollRef.current);
     pollRef.current = setInterval(async () => {
+      bustCache(cacheKey);
       const isConnected = await refresh();
       if (isConnected && pollRef.current) {
         clearInterval(pollRef.current);
         pollRef.current = null;
       }
     }, 2000);
-  }, [projectId, refresh]);
+  }, [projectId, basePath, cacheKey, refresh]);
 
   const connectWithKey = useCallback(
     async (apiKey: string): Promise<{ ok: boolean; error?: string }> => {
@@ -105,7 +184,7 @@ export function useLinearConnection(projectId: string): LinearConnectionState {
         return { ok: false, error: "Missing projectId" };
       }
       try {
-        const res = await fetch("/api/linear/token", {
+        const res = await fetch(`${basePath}/token`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ projectId, accessToken: apiKey }),
@@ -114,27 +193,29 @@ export function useLinearConnection(projectId: string): LinearConnectionState {
           const data = await res.json().catch(() => ({}));
           return { ok: false, error: data.error || "Failed to save token" };
         }
+        bustCache(cacheKey);
         await refresh();
         return { ok: true };
       } catch {
         return { ok: false, error: "Failed to connect" };
       }
     },
-    [projectId, refresh]
+    [projectId, basePath, cacheKey, refresh]
   );
 
   const disconnect = useCallback(async () => {
     if (!projectId) return;
-    await fetch(`/api/linear/status?projectId=${encodeURIComponent(projectId)}`, {
+    bustCache(cacheKey);
+    await fetch(`${basePath}/status?projectId=${encodeURIComponent(projectId)}`, {
       method: "DELETE",
     });
     setConnected(false);
     setUser(null);
-  }, [projectId]);
+  }, [projectId, basePath, cacheKey]);
 
   const configureMcp = useCallback(async (cli: string): Promise<{ ok: boolean; error?: string }> => {
     try {
-      const res = await fetch("/api/linear/mcp-setup", {
+      const res = await fetch(`${basePath}/mcp-setup`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ cli }),
@@ -148,7 +229,7 @@ export function useLinearConnection(projectId: string): LinearConnectionState {
     } catch {
       return { ok: false, error: "Failed to configure MCP" };
     }
-  }, [refreshMcp]);
+  }, [basePath, refreshMcp]);
 
   return { connected, loading, user, clis, mcpConfigured, connect, connectWithKey, disconnect, configureMcp, refresh };
 }

package/cloud-runtime/standalone/apps/local/hooks/useTrackerConnections.ts

@@ -0,0 +1,99 @@
+"use client";
+
+import { useState, useEffect, useCallback } from "react";
+import type { TrackerConnection } from "@/lib/tracker/types";
+
+interface TrackerConnectionInfo {
+  type: string;
+  connectedAt: string;
+  connected: boolean;
+  user?: { name: string; email: string } | null;
+  metadata?: Record<string, string>;
+}
+
+interface UseTrackerConnectionsReturn {
+  connections: TrackerConnectionInfo[];
+  loading: boolean;
+  refresh: () => Promise<void>;
+  addConnection: (type: string, metadata?: Record<string, string>) => Promise<{ ok: boolean; error?: string }>;
+  removeConnection: (type: string) => Promise<{ ok: boolean; error?: string }>;
+}
+
+/**
+ * Hook to list all tracker connections for a project.
+ * Reads from /api/trackers/connections.
+ * Used to power sidebar navigation and the connect page.
+ */
+export function useTrackerConnections(projectId: string | null): UseTrackerConnectionsReturn {
+  const [connections, setConnections] = useState<TrackerConnectionInfo[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  const refresh = useCallback(async () => {
+    if (!projectId) {
+      setConnections([]);
+      setLoading(false);
+      return;
+    }
+    try {
+      const res = await fetch(`/api/trackers/connections?projectId=${encodeURIComponent(projectId)}`);
+      const data = await res.json();
+      setConnections(Array.isArray(data.connections) ? data.connections : []);
+    } catch {
+      setConnections([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [projectId]);
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  const addConnection = useCallback(
+    async (type: string, metadata?: Record<string, string>) => {
+      if (!projectId) return { ok: false, error: "Missing projectId" };
+      try {
+        const res = await fetch("/api/trackers/connections", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ type, projectId, metadata }),
+        });
+        if (!res.ok) {
+          const data = await res.json().catch(() => ({}));
+          return { ok: false, error: data.error || "Failed to add connection" };
+        }
+        await refresh();
+        return { ok: true };
+      } catch {
+        return { ok: false, error: "Failed to add connection" };
+      }
+    },
+    [projectId, refresh]
+  );
+
+  const removeConnection = useCallback(
+    async (type: string) => {
+      if (!projectId) return { ok: false, error: "Missing projectId" };
+      try {
+        // Use the tracker-specific status DELETE which clears the token and removes
+        // from the manifest. The connections DELETE alone is insufficient because the
+        // GET endpoint auto-re-registers adapters that still have valid tokens.
+        const res = await fetch(
+          `/api/trackers/${type}/status?projectId=${encodeURIComponent(projectId)}`,
+          { method: "DELETE" }
+        );
+        if (!res.ok) {
+          const data = await res.json().catch(() => ({}));
+          return { ok: false, error: data.error || "Failed to remove connection" };
+        }
+        await refresh();
+        return { ok: true };
+      } catch {
+        return { ok: false, error: "Failed to remove connection" };
+      }
+    },
+    [projectId, refresh]
+  );
+
+  return { connections, loading, refresh, addConnection, removeConnection };
+}

package/cloud-runtime/standalone/apps/local/hooks/{useLinearIssueMentions.ts → useTrackerItemMentions.ts}

@@ -1,27 +1,34 @@
 "use client";
 
 import { useEffect, useState } from "react";
-import type { LinearIssue } from "@/hooks/useLinearIssues";
 
-interface UseLinearIssueMentionsOptions {
+export interface TrackerItemMention {
+  id: string;
+  identifier: string;
+  title: string;
+  status: string;
+  url?: string;
+}
+
+interface UseTrackerItemMentionsOptions {
   projectId: string;
   projectSlug?: string;
   enabled?: boolean;
   limit?: number;
 }
 
-interface UseLinearIssueMentionsReturn {
-  issues: LinearIssue[];
+interface UseTrackerItemMentionsReturn {
+  issues: TrackerItemMention[];
   loading: boolean;
 }
 
-export function useLinearIssueMentions({
+export function useTrackerItemMentions({
   projectId,
   projectSlug,
   enabled = true,
   limit = 500,
-}: UseLinearIssueMentionsOptions): UseLinearIssueMentionsReturn {
-  const [issues, setIssues] = useState<LinearIssue[]>([]);
+}: UseTrackerItemMentionsOptions): UseTrackerItemMentionsReturn {
+  const [issues, setIssues] = useState<TrackerItemMention[]>([]);
   const [loading, setLoading] = useState(false);
 
   useEffect(() => {
@@ -40,7 +47,7 @@ export function useLinearIssueMentions({
     }
 
     setLoading(true);
-    fetch(`/api/linear/issues?${params.toString()}`)
+    fetch(`/api/trackers/linear/items?${params.toString()}`)
       .then(async (response) => {
         const data = await response.json().catch(() => ({}));
         if (!cancelled) {

package/cloud-runtime/standalone/apps/local/hooks/useTrackerItems.ts

@@ -0,0 +1,120 @@
+"use client";
+
+import { useState, useEffect, useCallback, useRef } from "react";
+import type { TrackerItem, TrackerStatusCategory, TrackerFilters } from "@/lib/tracker/types";
+
+interface UseTrackerItemsFilters {
+  statuses?: string[];
+  statusCategories?: TrackerStatusCategory[];
+  assigneeIds?: string[];
+  groupIds?: string[];
+  search?: string;
+  sortBy?: string;
+  sortDir?: "asc" | "desc";
+  hasActivity?: boolean;
+}
+
+interface UseTrackerItemsOptions {
+  projectId: string;
+  limit?: number;
+}
+
+interface UseTrackerItemsReturn {
+  items: TrackerItem[];
+  loading: boolean;
+  hasMore: boolean;
+  loadMore: () => Promise<void>;
+  refresh: () => Promise<void>;
+  updateItem: (item: TrackerItem) => void;
+}
+
+/**
+ * Tracker-agnostic items hook.
+ * Replaces useLinearIssues by fetching from /api/trackers/[tracker]/items.
+ */
+export function useTrackerItems(
+  trackerType: string,
+  filters: UseTrackerItemsFilters,
+  enabled: boolean,
+  options: UseTrackerItemsOptions
+): UseTrackerItemsReturn {
+  const [items, setItems] = useState<TrackerItem[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [cursor, setCursor] = useState<string | null>(null);
+  const [hasMore, setHasMore] = useState(false);
+  const cursorRef = useRef(cursor);
+  const hydratedRef = useRef(false);
+  cursorRef.current = cursor;
+
+  const basePath = `/api/trackers/${encodeURIComponent(trackerType)}/items`;
+
+  const fetchPage = useCallback(
+    async (append: boolean) => {
+      if (!enabled || !options.projectId) return;
+      setLoading(true);
+      try {
+        const params = new URLSearchParams();
+        params.set("projectId", options.projectId);
+        if (filters.statuses?.length) {
+          for (const s of filters.statuses) {
+            params.append("status", s);
+          }
+        }
+        if (filters.statusCategories?.length) {
+          for (const cat of filters.statusCategories) {
+            params.append("statusCategory", cat);
+          }
+        }
+        if (filters.search) params.set("search", filters.search);
+        if (filters.assigneeIds?.length) {
+          for (const assigneeId of filters.assigneeIds) {
+            params.append("assigneeId", assigneeId);
+          }
+        }
+        if (filters.groupIds?.length) {
+          for (const groupId of filters.groupIds) {
+            params.append("groupId", groupId);
+          }
+        }
+        if (filters.sortBy) params.set("sortBy", filters.sortBy);
+        if (filters.sortDir) params.set("sortDir", filters.sortDir);
+        if (filters.hasActivity) params.set("hasActivity", "true");
+        if (append && cursorRef.current) params.set("cursor", cursorRef.current);
+        if (options.limit) params.set("limit", String(options.limit));
+
+        const res = await fetch(`${basePath}?${params.toString()}`);
+        const data = await res.json();
+        const newItems: TrackerItem[] = data.items ?? [];
+
+        setItems((prev) => (append ? [...prev, ...newItems] : newItems));
+        setCursor(data.pageInfo?.endCursor ?? null);
+        setHasMore(data.pageInfo?.hasNextPage ?? false);
+        hydratedRef.current = true;
+      } catch {
+        if (!append) setItems([]);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [basePath, filters.statuses, filters.statusCategories, filters.search, filters.assigneeIds, filters.groupIds, filters.sortBy, filters.sortDir, filters.hasActivity, enabled, options.projectId, options.limit]
+  );
+
+  useEffect(() => {
+    setCursor(null);
+    void fetchPage(false);
+  }, [fetchPage]);
+
+  const loadMore = useCallback(() => fetchPage(true), [fetchPage]);
+  const refresh = useCallback(() => {
+    setCursor(null);
+    return fetchPage(false);
+  }, [fetchPage]);
+
+  const updateItem = useCallback((item: TrackerItem) => {
+    setItems((previous) =>
+      previous.map((entry) => (entry.id === item.id ? item : entry))
+    );
+  }, []);
+
+  return { items, loading, hasMore, loadMore, refresh, updateItem };
+}

package/cloud-runtime/standalone/apps/local/hooks/{useLinearParticipants.ts → useTrackerParticipants.ts}

@@ -3,7 +3,7 @@
 import { useEffect, useState } from "react";
 import type { Participant } from "@/lib/types";
 
-export function useLinearParticipants(projectId?: string): {
+export function useTrackerParticipants(trackerType: string, projectId?: string): {
   participants: Participant[];
   participantsLoaded: boolean;
 } {
@@ -28,10 +28,10 @@ export function useLinearParticipants(projectId?: string): {
           return;
         }
 
-        // Check if the linear worker has a team configured
+        // Check if the tracker worker has a team configured
         const workerParams = new URLSearchParams();
         workerParams.set("projectId", projectId);
-        const workerResponse = await fetch(`/api/linear/worker?${workerParams}`).catch(() => null);
+        const workerResponse = await fetch(`/api/trackers/${encodeURIComponent(trackerType)}/worker?${workerParams}`).catch(() => null);
         const workerData = workerResponse?.ok ? await workerResponse.json().catch(() => null) : null;
         const workerTeamId: string | undefined = workerData?.job?.teamId || undefined;
 
@@ -112,7 +112,7 @@ export function useLinearParticipants(projectId?: string): {
     return () => {
       cancelled = true;
     };
-  }, [projectId]);
+  }, [trackerType, projectId]);
 
   return { participants, participantsLoaded };
 }

package/cloud-runtime/standalone/apps/local/hooks/{useLinearRunScripts.ts → useTrackerRunScripts.ts}

@@ -2,12 +2,12 @@
 
 import { useCallback, useEffect, useMemo, useState } from "react";
 import {
-  loadLinearRunScripts,
-  persistLinearRunScripts,
-  type LinearRunScript,
-} from "@/state/linearRunScripts";
+  loadTrackerRunScripts,
+  persistTrackerRunScripts,
+  type TrackerRunScript,
+} from "@/state/trackerRunScripts";
 
-interface SaveLinearRunScriptInput {
+interface SaveTrackerRunScriptInput {
   id?: string;
   name: string;
   prompt: string;
@@ -17,30 +17,30 @@ function buildTimestamp(): string {
   return new Date().toISOString();
 }
 
-function sortScripts(scripts: LinearRunScript[]): LinearRunScript[] {
+function sortScripts(scripts: TrackerRunScript[]): TrackerRunScript[] {
   return [...scripts].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
 
-export function useLinearRunScripts(projectSlug?: string | null) {
-  const [scripts, setScripts] = useState<LinearRunScript[]>([]);
+export function useTrackerRunScripts(trackerType: string, projectSlug?: string | null) {
+  const [scripts, setScripts] = useState<TrackerRunScript[]>([]);
   const [activeScriptId, setActiveScriptIdState] = useState<string | null>(null);
 
   useEffect(() => {
-    const state = loadLinearRunScripts(projectSlug);
+    const state = loadTrackerRunScripts(trackerType, projectSlug);
     setScripts(state.scripts);
     setActiveScriptIdState(state.activeScriptId);
-  }, [projectSlug]);
+  }, [trackerType, projectSlug]);
 
   const persistState = useCallback(
-    (nextScripts: LinearRunScript[], nextActiveScriptId: string | null) => {
+    (nextScripts: TrackerRunScript[], nextActiveScriptId: string | null) => {
       setScripts(nextScripts);
       setActiveScriptIdState(nextActiveScriptId);
-      persistLinearRunScripts(projectSlug, {
+      persistTrackerRunScripts(trackerType, projectSlug, {
         scripts: nextScripts,
         activeScriptId: nextActiveScriptId,
       });
     },
-    [projectSlug]
+    [trackerType, projectSlug]
   );
 
   const setActiveScriptId = useCallback(
@@ -55,7 +55,7 @@ export function useLinearRunScripts(projectSlug?: string | null) {
   );
 
   const saveScript = useCallback(
-    (input: SaveLinearRunScriptInput): LinearRunScript => {
+    (input: SaveTrackerRunScriptInput): TrackerRunScript => {
       const now = buildTimestamp();
       const name = input.name.trim();
       const prompt = input.prompt.trim();
@@ -64,7 +64,7 @@ export function useLinearRunScripts(projectSlug?: string | null) {
       }
 
       const existing = input.id ? scripts.find((script) => script.id === input.id) : null;
-      const nextScript: LinearRunScript = existing
+      const nextScript: TrackerRunScript = existing
         ? {
             ...existing,
             name,