hale-commenting-system 1.0.2 → 1.0.4

package/dist/index.mjs

@@ -1,122 +1,2254 @@
 // src/components/CommentOverlay.tsx
-import { jsx } from "react/jsx-runtime";
-var CommentOverlay = ({ selectedThreadId, onThreadSelect }) => {
-  return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx("div", { children: "Comment Overlay Placeholder" }) });
-};
+import * as React3 from "react";
+import { useLocation } from "react-router-dom";
 
-// src/components/CommentDrawer.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-var CommentDrawer = ({ selectedThreadId, onThreadSelect, children }) => {
-  return /* @__PURE__ */ jsx2("div", { children });
-};
+// src/contexts/CommentContext.tsx
+import * as React from "react";
 
-// src/components/CommentPin.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
-var CommentPin = () => {
-  return /* @__PURE__ */ jsx3("div", { children: "CommentPin Placeholder" });
+// src/services/githubAdapter.ts
+import axios from "axios";
+var getApiBase = () => {
+  if (typeof window === "undefined") return "/api/github-api";
+  const isNetlify = window.location.hostname.includes("netlify.app");
+  const apiBase = isNetlify ? "/.netlify/functions/github-api" : "/api/github-api";
+  console.log("\u{1F50D} API detection:", { hostname: window.location.hostname, isNetlify, apiBase });
+  return apiBase;
+};
+var getStoredToken = () => {
+  if (typeof window === "undefined") return null;
+  const token = localStorage.getItem("github_access_token");
+  console.log("\u{1F511} getStoredToken:", token ? "Token found" : "No token found");
+  return token;
+};
+var getStoredUser = () => {
+  if (typeof window === "undefined") return null;
+  const userStr = localStorage.getItem("github_user");
+  return userStr ? JSON.parse(userStr) : null;
+};
+var storeGitHubAuth = (token, login, avatar) => {
+  localStorage.setItem("github_access_token", token);
+  localStorage.setItem("github_user", JSON.stringify({ login, avatar }));
 };
+var clearGitHubAuth = () => {
+  localStorage.removeItem("github_access_token");
+  localStorage.removeItem("github_user");
+};
+var getAuthenticatedUser = () => {
+  return getStoredUser();
+};
+var isGitHubConfigured = () => {
+  const token = getStoredToken();
+  const owner = process.env.VITE_GITHUB_OWNER;
+  const repo = process.env.VITE_GITHUB_REPO;
+  console.log("\u{1F50D} isGitHubConfigured check:", { hasToken: !!token, owner, repo });
+  return !!(token && owner && repo);
+};
+async function makeGitHubRequest(method, endpoint, data) {
+  const token = getStoredToken();
+  if (!token) {
+    throw new Error("Not authenticated with GitHub");
+  }
+  const response = await axios.post(getApiBase(), {
+    token,
+    method,
+    endpoint,
+    data
+  });
+  return response.data;
+}
+var githubAdapter = {
+  /**
+   * Create a new GitHub Issue for a comment thread
+   */
+  async createIssue(title, body, route, x, y, version) {
+    console.log("\u{1F535} createIssue called", { title, route, x, y, version });
+    if (!isGitHubConfigured()) {
+      console.warn("\u26A0\uFE0F GitHub not configured. Skipping issue creation.");
+      return { success: false, error: "Please sign in with GitHub" };
+    }
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    console.log("\u{1F535} GitHub config:", { owner, repo, hasToken: !!getStoredToken() });
+    try {
+      const metadata = [
+        `- Route: \`${route}\``,
+        version ? `- Version: \`${version}\`` : null,
+        `- Coordinates: \`(${Math.round(x)}, ${Math.round(y)})\``
+      ].filter(Boolean).join("\n");
+      const issueBody = {
+        title,
+        body: `${body}
 
-// src/components/AIAssistant.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
-var AIAssistant = () => {
-  return /* @__PURE__ */ jsx4("div", { children: "AIAssistant Placeholder" });
+---
+**Metadata:**
+${metadata}`
+      };
+      console.log("\u{1F535} Calling makeGitHubRequest...");
+      const issueData = await makeGitHubRequest("POST", `/repos/${owner}/${repo}/issues`, issueBody);
+      console.log("\u2705 Created GitHub Issue #", issueData.number);
+      try {
+        const labels = [
+          "apollo-comment",
+          `route:${route}`,
+          `coords:${Math.round(x)},${Math.round(y)}`
+        ];
+        if (version) labels.push(`version:${version}`);
+        await makeGitHubRequest(
+          "POST",
+          `/repos/${owner}/${repo}/issues/${issueData.number}/labels`,
+          { labels }
+        );
+        console.log("\u2705 Added labels to Issue #", issueData.number);
+      } catch (labelError) {
+        console.warn("\u26A0\uFE0F Could not add labels (labels may not exist in repo)");
+      }
+      return { success: true, data: issueData };
+    } catch (error) {
+      const errorMessage = error?.response?.data?.message || error?.message || "Failed to create issue";
+      console.error("\u274C Failed to create GitHub Issue:", {
+        message: errorMessage,
+        error: error?.response?.data || error,
+        status: error?.response?.status
+      });
+      return { success: false, error: errorMessage };
+    }
+  },
+  /**
+   * Add a comment to an existing GitHub Issue
+   */
+  async createComment(issueNumber, body) {
+    if (!isGitHubConfigured()) {
+      return { success: false, error: "Please sign in with GitHub" };
+    }
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    try {
+      const commentData = await makeGitHubRequest(
+        "POST",
+        `/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
+        { body }
+      );
+      console.log(`\u2705 Added comment to Issue #${issueNumber}`);
+      return { success: true, data: commentData };
+    } catch (error) {
+      const errorMessage = error?.response?.data?.message || error?.message || "Failed to create comment";
+      console.error(`\u274C Failed to add comment to Issue #${issueNumber}:`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  },
+  /**
+   * Fetch all issues for a specific route
+   */
+  async fetchIssues(route) {
+    if (!isGitHubConfigured()) {
+      console.warn("GitHub not configured. Skipping issue fetch.");
+      return [];
+    }
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    try {
+      const issues = await makeGitHubRequest(
+        "GET",
+        `/repos/${owner}/${repo}/issues?state=open`
+      );
+      const filteredIssues = issues.filter((issue) => {
+        if (issue.body && issue.body.includes(`Route: \`${route}\``)) {
+          return true;
+        }
+        if (issue.labels && issue.labels.some((l) => {
+          const labelName = typeof l === "string" ? l : l.name;
+          return labelName === `route:${route}`;
+        })) {
+          return true;
+        }
+        return false;
+      });
+      console.log(`\u2705 Fetched ${filteredIssues.length} issues for route: ${route}`);
+      return filteredIssues;
+    } catch (error) {
+      console.error(`\u274C Failed to fetch issues for route ${route}:`, error);
+      return [];
+    }
+  },
+  /**
+   * Fetch all comments for a specific issue
+   */
+  async fetchComments(issueNumber) {
+    if (!isGitHubConfigured()) {
+      return [];
+    }
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    try {
+      const comments = await makeGitHubRequest(
+        "GET",
+        `/repos/${owner}/${repo}/issues/${issueNumber}/comments`
+      );
+      console.log(`\u2705 Fetched ${comments.length} comments for Issue #${issueNumber}`);
+      return comments;
+    } catch (error) {
+      console.error(`\u274C Failed to fetch comments for Issue #${issueNumber}:`, error);
+      return [];
+    }
+  },
+  /**
+   * Close a GitHub Issue (when deleting a thread)
+   */
+  async closeIssue(issueNumber) {
+    if (!isGitHubConfigured()) {
+      return { success: false, error: "Please sign in with GitHub" };
+    }
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    try {
+      const issueData = await makeGitHubRequest(
+        "PATCH",
+        `/repos/${owner}/${repo}/issues/${issueNumber}`,
+        { state: "closed" }
+      );
+      console.log(`\u2705 Closed Issue #${issueNumber}`);
+      return { success: true, data: issueData };
+    } catch (error) {
+      const errorMessage = error?.response?.data?.message || error?.message || "Failed to close issue";
+      console.error(`\u274C Failed to close Issue #${issueNumber}:`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  },
+  /**
+   * Update an existing comment on a GitHub Issue
+   */
+  async updateComment(commentId, body) {
+    if (!isGitHubConfigured()) {
+      return { success: false, error: "Please sign in with GitHub" };
+    }
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    try {
+      const commentData = await makeGitHubRequest(
+        "PATCH",
+        `/repos/${owner}/${repo}/issues/comments/${commentId}`,
+        { body }
+      );
+      console.log(`\u2705 Updated comment #${commentId}`);
+      return { success: true, data: commentData };
+    } catch (error) {
+      const errorMessage = error?.response?.data?.message || error?.message || "Failed to update comment";
+      console.error(`\u274C Failed to update comment #${commentId}:`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  },
+  /**
+   * Delete a comment on a GitHub Issue
+   */
+  async deleteComment(commentId) {
+    if (!isGitHubConfigured()) {
+      return { success: false, error: "Please sign in with GitHub" };
+    }
+    const owner = process.env.VITE_GITHUB_OWNER;
+    const repo = process.env.VITE_GITHUB_REPO;
+    try {
+      await makeGitHubRequest(
+        "DELETE",
+        `/repos/${owner}/${repo}/issues/comments/${commentId}`
+      );
+      console.log(`\u2705 Deleted comment #${commentId}`);
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error?.response?.data?.message || error?.message || "Failed to delete comment";
+      console.error(`\u274C Failed to delete comment #${commentId}:`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  }
 };
 
-// src/components/AIChatPanel.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
-var AIChatPanel = () => {
-  return /* @__PURE__ */ jsx5("div", { children: "AIChatPanel Placeholder" });
+// src/services/gitlabAdapter.ts
+import axios2 from "axios";
+var getApiBase2 = () => {
+  if (typeof window === "undefined") return "/api/gitlab-api";
+  const isNetlify = window.location.hostname.includes("netlify.app");
+  return isNetlify ? "/.netlify/functions/gitlab-api" : "/api/gitlab-api";
+};
+var getStoredToken2 = () => {
+  if (typeof window === "undefined") return null;
+  return localStorage.getItem("gitlab_access_token");
+};
+var isGitLabConfigured = () => {
+  const token = getStoredToken2();
+  const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+  const baseUrl = process.env.VITE_GITLAB_BASE_URL || "https://gitlab.com";
+  return !!(token && projectPath && baseUrl);
+};
+async function makeGitLabRequest(method, endpoint, data) {
+  const token = getStoredToken2();
+  if (!token) {
+    throw new Error("Not authenticated with GitLab");
+  }
+  const baseUrl = process.env.VITE_GITLAB_BASE_URL || "https://gitlab.com";
+  const response = await axios2.post(getApiBase2(), {
+    token,
+    method,
+    endpoint,
+    data,
+    baseUrl
+  });
+  return response.data;
+}
+var encodeProject = (p) => encodeURIComponent(p);
+var gitlabAdapter = {
+  async createIssue(title, body, route, x, y, version) {
+    if (!isGitLabConfigured()) {
+      return { success: false, error: "Please sign in with GitLab" };
+    }
+    try {
+      const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+      const labels = ["apollo-comment", `route:${route}`, `coords:${Math.round(x)},${Math.round(y)}`];
+      if (version) labels.push(`version:${version}`);
+      const issue = await makeGitLabRequest(
+        "POST",
+        `/projects/${encodeProject(projectPath)}/issues`,
+        { title, description: body, labels: labels.join(",") }
+      );
+      return { success: true, data: { ...issue, number: issue.iid } };
+    } catch (error) {
+      const message = error?.response?.data?.message || error?.message || "Failed to create GitLab issue";
+      return { success: false, error: message };
+    }
+  },
+  async createComment(issueNumber, body) {
+    if (!isGitLabConfigured()) {
+      return { success: false, error: "Please sign in with GitLab" };
+    }
+    try {
+      const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+      const note = await makeGitLabRequest(
+        "POST",
+        `/projects/${encodeProject(projectPath)}/issues/${issueNumber}/notes`,
+        { body }
+      );
+      return { success: true, data: note };
+    } catch (error) {
+      const message = error?.response?.data?.message || error?.message || "Failed to create GitLab comment";
+      return { success: false, error: message };
+    }
+  },
+  async updateComment(commentId, body) {
+    if (!isGitLabConfigured()) {
+      return { success: false, error: "Please sign in with GitLab" };
+    }
+    try {
+      const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+      const note = await makeGitLabRequest(
+        "PUT",
+        `/projects/${encodeProject(projectPath)}/notes/${commentId}`,
+        { body }
+      );
+      return { success: true, data: note };
+    } catch (error) {
+      const message = error?.response?.data?.message || error?.message || "Failed to update GitLab comment";
+      return { success: false, error: message };
+    }
+  },
+  async deleteComment(commentId) {
+    if (!isGitLabConfigured()) {
+      return { success: false, error: "Please sign in with GitLab" };
+    }
+    try {
+      const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+      await makeGitLabRequest(
+        "DELETE",
+        `/projects/${encodeProject(projectPath)}/notes/${commentId}`
+      );
+      return { success: true };
+    } catch (error) {
+      const message = error?.response?.data?.message || error?.message || "Failed to delete GitLab comment";
+      return { success: false, error: message };
+    }
+  },
+  async closeIssue(issueNumber) {
+    if (!isGitLabConfigured()) {
+      return { success: false, error: "Please sign in with GitLab" };
+    }
+    try {
+      const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+      const issue = await makeGitLabRequest(
+        "PUT",
+        `/projects/${encodeProject(projectPath)}/issues/${issueNumber}`,
+        { state_event: "close" }
+      );
+      return { success: true, data: issue };
+    } catch (error) {
+      const message = error?.response?.data?.message || error?.message || "Failed to close GitLab issue";
+      return { success: false, error: message };
+    }
+  },
+  async fetchIssues(route) {
+    if (!isGitLabConfigured()) {
+      return [];
+    }
+    try {
+      const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+      const issues = await makeGitLabRequest(
+        "GET",
+        `/projects/${encodeProject(projectPath)}/issues?state=opened&per_page=100`
+      );
+      return (issues || []).filter((issue) => {
+        const labels = issue.labels || [];
+        const routeLabel = labels.some((l) => l === `route:${route}`);
+        const inBody = (issue.description || "").includes(`Route: \`${route}\``);
+        return routeLabel || inBody;
+      });
+    } catch {
+      return [];
+    }
+  },
+  async fetchComments(issueNumber) {
+    if (!isGitLabConfigured()) {
+      return [];
+    }
+    try {
+      const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+      const notes = await makeGitLabRequest(
+        "GET",
+        `/projects/${encodeProject(projectPath)}/issues/${issueNumber}/notes?per_page=100`
+      );
+      return notes || [];
+    } catch {
+      return [];
+    }
+  }
 };
 
 // src/contexts/CommentContext.tsx
-import { createContext, useContext } from "react";
-import { jsx as jsx6 } from "react/jsx-runtime";
-var CommentContext = createContext(null);
+import { jsx } from "react/jsx-runtime";
+var CommentContext = React.createContext(void 0);
+var STORAGE_KEY = "apollo-threads";
+var SHOW_PINS_KEY = "apollo-show-pins";
+var ENABLE_COMMENTING_KEY = "apollo-enable-commenting";
+var migrateOldComments = () => {
+  try {
+    const oldComments = localStorage.getItem("apollo-comments");
+    if (oldComments) {
+      const parsed = JSON.parse(oldComments);
+      const threads = parsed.map((oldComment) => ({
+        id: oldComment.id,
+        x: oldComment.x,
+        y: oldComment.y,
+        route: oldComment.route,
+        comments: [
+          {
+            id: `${oldComment.id}-comment-0`,
+            text: oldComment.text || "",
+            createdAt: oldComment.createdAt
+          }
+        ]
+      }));
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(threads));
+      localStorage.removeItem("apollo-comments");
+      return threads;
+    }
+  } catch (error) {
+    console.error("Failed to migrate old comments:", error);
+  }
+  return [];
+};
 var CommentProvider = ({ children }) => {
-  return /* @__PURE__ */ jsx6(CommentContext.Provider, { value: {}, children });
+  const [threads, setThreads] = React.useState(() => {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        return JSON.parse(stored);
+      }
+      return migrateOldComments();
+    } catch (error) {
+      console.error("Failed to load threads from localStorage:", error);
+      return [];
+    }
+  });
+  const [showPins, setShowPins] = React.useState(() => {
+    try {
+      const stored = localStorage.getItem(SHOW_PINS_KEY);
+      return stored === "true";
+    } catch (error) {
+      return false;
+    }
+  });
+  const [enableCommenting, setEnableCommenting] = React.useState(() => {
+    try {
+      const stored = localStorage.getItem(ENABLE_COMMENTING_KEY);
+      return stored === "true";
+    } catch (error) {
+      return false;
+    }
+  });
+  const [isSyncing, setIsSyncing] = React.useState(false);
+  React.useEffect(() => {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(threads));
+    } catch (error) {
+      console.error("Failed to save threads to localStorage:", error);
+    }
+  }, [threads]);
+  React.useEffect(() => {
+    try {
+      localStorage.setItem(SHOW_PINS_KEY, String(showPins));
+    } catch (error) {
+      console.error("Failed to save showPins to localStorage:", error);
+    }
+  }, [showPins]);
+  React.useEffect(() => {
+    try {
+      localStorage.setItem(ENABLE_COMMENTING_KEY, String(enableCommenting));
+    } catch (error) {
+      console.error("Failed to save enableCommenting to localStorage:", error);
+    }
+  }, [enableCommenting]);
+  const toggleShowPins = React.useCallback(() => {
+    setShowPins((prev) => !prev);
+  }, []);
+  const toggleEnableCommenting = React.useCallback(() => {
+    setEnableCommenting((prev) => !prev);
+  }, []);
+  const addThread = React.useCallback((x, y, route, version) => {
+    const threadId = `thread-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const newThread = {
+      id: threadId,
+      x,
+      y,
+      route,
+      comments: [],
+      // Start with no comments
+      syncStatus: "local",
+      version
+    };
+    setThreads((prev) => [...prev, newThread]);
+    if (isGitHubConfigured() || isGitLabConfigured()) {
+      (async () => {
+        setThreads((prev) => prev.map(
+          (t) => t.id === threadId ? { ...t, syncStatus: "syncing" } : t
+        ));
+        const pageName = route === "/" ? "Home page" : route.split("/").filter(Boolean).join(" > ") || "Page";
+        const versionStr = version ? ` [v${version}]` : "";
+        let createdProvider;
+        let createdNumber;
+        let createError;
+        if (isGitHubConfigured()) {
+          const issue = await githubAdapter.createIssue(
+            `\u{1F4AC} ${pageName} comment${versionStr}`,
+            `Thread created on route: ${route}
+
+Coordinates: (${Math.round(x)}, ${Math.round(y)})
+
+**Version:** ${version || "N/A"}
+
+(Initial comment will be added as a reply)`,
+            route,
+            x,
+            y,
+            version
+          );
+          if (issue.success && issue.data) {
+            createdProvider = "github";
+            createdNumber = issue.data.number;
+          } else {
+            createError = issue.error;
+          }
+        } else if (isGitLabConfigured()) {
+          const issue = await gitlabAdapter.createIssue(
+            `\u{1F4AC} ${pageName} comment${versionStr}`,
+            `Thread created on route: ${route}
+
+Coordinates: (${Math.round(x)}, ${Math.round(y)})
+
+**Version:** ${version || "N/A"}
+
+(Initial comment will be added as a reply)`,
+            route,
+            x,
+            y,
+            version
+          );
+          if (issue.success && issue.data) {
+            createdProvider = "gitlab";
+            createdNumber = issue.data.number;
+          } else {
+            createError = issue.error;
+          }
+        }
+        if (createdNumber && createdProvider) {
+          setThreads((prev) => prev.map(
+            (t) => t.id === threadId ? { ...t, issueNumber: createdNumber, provider: createdProvider, syncStatus: "synced" } : t
+          ));
+        } else if (createError) {
+          setThreads((prev) => prev.map(
+            (t) => t.id === threadId ? { ...t, syncStatus: "error", syncError: createError } : t
+          ));
+        }
+      })();
+    }
+    return threadId;
+  }, []);
+  const addReply = React.useCallback(async (threadId, text) => {
+    const commentId = `${threadId}-comment-${Date.now()}`;
+    const newComment = {
+      id: commentId,
+      text,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const thread = threads.find((t) => t.id === threadId);
+    setThreads(
+      (prev) => prev.map((t) => {
+        if (t.id === threadId) {
+          return {
+            ...t,
+            comments: [...t.comments, newComment],
+            syncStatus: "pending"
+            // Mark as pending sync
+          };
+        }
+        return t;
+      })
+    );
+    if (thread) {
+      if (!thread.issueNumber) {
+        console.log("\u{1F535} Thread has no issue number, creating remote issue first...");
+        setThreads((prev) => prev.map(
+          (t) => t.id === threadId ? { ...t, syncStatus: "syncing" } : t
+        ));
+        const pageName = thread.route === "/" ? "Home page" : thread.route.split("/").filter(Boolean).join(" > ") || "Page";
+        const versionStr = thread.version ? ` [v${thread.version}]` : "";
+        let createdProvider;
+        let createdNumber;
+        const providerPref = thread.provider || (isGitHubConfigured() ? "github" : isGitLabConfigured() ? "gitlab" : void 0);
+        if (providerPref === "github" && isGitHubConfigured()) {
+          const issue = await githubAdapter.createIssue(
+            `\u{1F4AC} ${pageName} comment${versionStr}`,
+            `Thread created on route: ${thread.route}
+
+Coordinates: (${Math.round(thread.x)}, ${Math.round(thread.y)})
+
+**Version:** ${thread.version || "N/A"}`,
+            thread.route,
+            thread.x,
+            thread.y,
+            thread.version
+          );
+          if (issue.success && issue.data) {
+            createdProvider = "github";
+            createdNumber = issue.data.number;
+          } else {
+            console.error("\u274C Failed to create GitHub issue:", issue.error);
+          }
+        } else if (providerPref === "gitlab" && isGitLabConfigured()) {
+          const issue = await gitlabAdapter.createIssue(
+            `\u{1F4AC} ${pageName} comment${versionStr}`,
+            `Thread created on route: ${thread.route}
+
+Coordinates: (${Math.round(thread.x)}, ${Math.round(thread.y)})
+
+**Version:** ${thread.version || "N/A"}`,
+            thread.route,
+            thread.x,
+            thread.y,
+            thread.version
+          );
+          if (issue.success && issue.data) {
+            createdProvider = "gitlab";
+            createdNumber = issue.data.number;
+          } else {
+            console.error("\u274C Failed to create GitLab issue:", issue.error);
+          }
+        }
+        if (createdNumber && createdProvider) {
+          console.log("\u2705 Created remote issue #", createdNumber);
+          setThreads((prev) => prev.map(
+            (t) => t.id === threadId ? { ...t, issueNumber: createdNumber, provider: createdProvider, syncStatus: "pending" } : t
+          ));
+          const updatedThread = threads.find((t) => t.id === threadId);
+          if (updatedThread) {
+            for (const comment of updatedThread.comments) {
+              if (!comment.githubCommentId) {
+                const commentResult = createdProvider === "github" ? await githubAdapter.createComment(createdNumber, comment.text) : await gitlabAdapter.createComment(createdNumber, comment.text);
+                if (commentResult.success && commentResult.data) {
+                  setThreads((prev) => prev.map((t) => {
+                    if (t.id === threadId) {
+                      return {
+                        ...t,
+                        comments: t.comments.map(
+                          (c) => c.id === comment.id ? { ...c, githubCommentId: commentResult.data.id } : c
+                        )
+                      };
+                    }
+                    return t;
+                  }));
+                }
+              }
+            }
+          }
+          const result = createdProvider === "github" ? await githubAdapter.createComment(createdNumber, text) : await gitlabAdapter.createComment(createdNumber, text);
+          if (result.success && result.data) {
+            setThreads(
+              (prev) => prev.map((t) => {
+                if (t.id === threadId) {
+                  return {
+                    ...t,
+                    syncStatus: "synced",
+                    comments: t.comments.map(
+                      (c) => c.id === commentId ? { ...c, githubCommentId: result.data.id } : c
+                    )
+                  };
+                }
+                return t;
+              })
+            );
+          } else {
+            setThreads(
+              (prev) => prev.map(
+                (t) => t.id === threadId ? { ...t, syncStatus: "error", syncError: result.error } : t
+              )
+            );
+          }
+        } else {
+          setThreads((prev) => prev.map(
+            (t) => t.id === threadId ? { ...t, syncStatus: "error", syncError: "Failed to create remote issue" } : t
+          ));
+        }
+      } else {
+        const isGitHub = thread.provider === "github";
+        const isGitLab = thread.provider === "gitlab";
+        let result;
+        if (isGitHub && isGitHubConfigured()) {
+          result = await githubAdapter.createComment(thread.issueNumber, text);
+        } else if (isGitLab && isGitLabConfigured()) {
+          result = await gitlabAdapter.createComment(thread.issueNumber, text);
+        } else {
+          return;
+        }
+        if (result.success && result.data) {
+          setThreads(
+            (prev) => prev.map((t) => {
+              if (t.id === threadId) {
+                return {
+                  ...t,
+                  syncStatus: "synced",
+                  comments: t.comments.map(
+                    (c) => c.id === commentId ? { ...c, githubCommentId: result.data.id } : c
+                  )
+                };
+              }
+              return t;
+            })
+          );
+        } else {
+          setThreads(
+            (prev) => prev.map(
+              (t) => t.id === threadId ? { ...t, syncStatus: "error", syncError: result.error } : t
+            )
+          );
+        }
+      }
+    }
+  }, [threads]);
+  const updateComment = React.useCallback(async (threadId, commentId, text) => {
+    const thread = threads.find((t) => t.id === threadId);
+    const comment = thread?.comments.find((c) => c.id === commentId);
+    setThreads(
+      (prev) => prev.map((t) => {
+        if (t.id === threadId) {
+          return {
+            ...t,
+            syncStatus: "pending",
+            comments: t.comments.map(
+              (c) => c.id === commentId ? { ...c, text } : c
+            )
+          };
+        }
+        return t;
+      })
+    );
+    if (comment?.githubCommentId) {
+      let ok = false;
+      if (thread?.provider === "github" && isGitHubConfigured()) {
+        const result = await githubAdapter.updateComment(comment.githubCommentId, text);
+        ok = !!result.success;
+      } else if (thread?.provider === "gitlab" && isGitLabConfigured()) {
+        const result = await gitlabAdapter.updateComment(comment.githubCommentId, text);
+        ok = !!result.success;
+      }
+      if (ok) {
+        setThreads(
+          (prev) => prev.map((t) => t.id === threadId ? { ...t, syncStatus: "synced" } : t)
+        );
+      } else {
+        setThreads(
+          (prev) => prev.map(
+            (t) => t.id === threadId ? { ...t, syncStatus: "error", syncError: "Update failed" } : t
+          )
+        );
+      }
+    }
+  }, [threads]);
+  const deleteComment = React.useCallback(async (threadId, commentId) => {
+    const thread = threads.find((t) => t.id === threadId);
+    const comment = thread?.comments.find((c) => c.id === commentId);
+    setThreads(
+      (prev) => prev.map((t) => {
+        if (t.id === threadId) {
+          return {
+            ...t,
+            syncStatus: "pending",
+            comments: t.comments.filter((c) => c.id !== commentId)
+          };
+        }
+        return t;
+      })
+    );
+    if (comment?.githubCommentId) {
+      let ok = false;
+      if (thread?.provider === "github" && isGitHubConfigured()) {
+        const result = await githubAdapter.deleteComment(comment.githubCommentId);
+        ok = !!result.success;
+      } else if (thread?.provider === "gitlab" && isGitLabConfigured()) {
+        const result = await gitlabAdapter.deleteComment(comment.githubCommentId);
+        ok = !!result.success;
+      }
+      if (ok) {
+        setThreads(
+          (prev) => prev.map((t) => t.id === threadId ? { ...t, syncStatus: "synced" } : t)
+        );
+      } else {
+        setThreads(
+          (prev) => prev.map(
+            (t) => t.id === threadId ? { ...t, syncStatus: "error", syncError: "Delete failed" } : t
+          )
+        );
+      }
+    }
+  }, [threads]);
+  const deleteThread = React.useCallback(async (threadId) => {
+    const thread = threads.find((t) => t.id === threadId);
+    setThreads((prev) => prev.filter((t) => t.id !== threadId));
+    if (thread?.issueNumber) {
+      if (thread.provider === "github" && isGitHubConfigured()) {
+        const result = await githubAdapter.closeIssue(thread.issueNumber);
+        if (!result.success) {
+          console.error("Failed to close GitHub issue:", result.error);
+        }
+      } else if (thread.provider === "gitlab" && isGitLabConfigured()) {
+        const result = await gitlabAdapter.closeIssue(thread.issueNumber);
+        if (!result.success) {
+          console.error("Failed to close GitLab issue:", result.error);
+        }
+      }
+    }
+  }, [threads]);
+  const clearAllThreads = React.useCallback(() => {
+    setThreads([]);
+  }, []);
+  const getThreadsForRoute = React.useCallback((route, version) => {
+    return threads.filter((thread) => {
+      const routeMatch = thread.route === route;
+      const threadVersion = thread.version || "3";
+      const versionMatch = !version || threadVersion === version;
+      return routeMatch && versionMatch;
+    });
+  }, [threads]);
+  const syncFromGitHub = React.useCallback(async (route) => {
+    setIsSyncing(true);
+    console.log(`\u{1F504} Syncing threads from remote providers for route: ${route}`);
+    try {
+      const newThreads = [];
+      if (isGitHubConfigured()) {
+        const issues = await githubAdapter.fetchIssues(route);
+        for (const issue of issues) {
+          let coords = null;
+          if (issue.body) {
+            const coordMatch = issue.body.match(/Coordinates: `\((\d+),\s*(\d+)\)`/);
+            if (coordMatch) {
+              coords = [parseInt(coordMatch[1]), parseInt(coordMatch[2])];
+            }
+          }
+          if (!coords) {
+            const coordLabel = issue.labels.find(
+              (l) => typeof l === "string" ? l.startsWith("coords:") : l.name?.startsWith("coords:")
+            );
+            const coordString = typeof coordLabel === "string" ? coordLabel : coordLabel?.name;
+            if (coordString) {
+              const coordParts = coordString.replace("coords:", "").split(",").map(Number);
+              if (coordParts.length === 2) {
+                coords = coordParts;
+              }
+            }
+          }
+          if (!coords || coords.length !== 2 || isNaN(coords[0]) || isNaN(coords[1])) {
+            console.warn(`Skipping issue #${issue.number}: invalid or missing coords`);
+            continue;
+          }
+          const ghComments = await githubAdapter.fetchComments(issue.number);
+          const comments = [];
+          if (issue.body) {
+            comments.push({
+              id: `issue-${issue.number}-body`,
+              text: issue.body,
+              createdAt: issue.created_at,
+              author: issue.user?.login,
+              githubCommentId: void 0
+              // Body is not a comment
+            });
+          }
+          ghComments.forEach((ghComment) => {
+            comments.push({
+              id: `comment-${ghComment.id}`,
+              text: ghComment.body,
+              createdAt: ghComment.created_at,
+              author: ghComment.user?.login,
+              githubCommentId: ghComment.id
+            });
+          });
+          newThreads.push({
+            id: `github-${issue.number}`,
+            x: coords[0],
+            y: coords[1],
+            route,
+            comments,
+            issueNumber: issue.number,
+            provider: "github",
+            syncStatus: "synced"
+          });
+        }
+      }
+      if (isGitLabConfigured()) {
+        const issues = await gitlabAdapter.fetchIssues(route);
+        for (const issue of issues) {
+          let coords = null;
+          const labels = issue.labels || [];
+          const coordLabel = labels.find((l) => l.startsWith("coords:"));
+          if (coordLabel) {
+            const parts = coordLabel.replace("coords:", "").split(",").map((n) => parseInt(n, 10));
+            if (parts.length === 2 && !Number.isNaN(parts[0]) && !Number.isNaN(parts[1])) {
+              coords = parts;
+            }
+          }
+          if (!coords && issue.description) {
+            const m = issue.description.match(/Coordinates:\s*`?\((\d+),\s*(\d+)\)`?/);
+            if (m) coords = [parseInt(m[1], 10), parseInt(m[2], 10)];
+          }
+          if (!coords) {
+            console.warn(`Skipping GitLab issue #${issue.iid}: invalid or missing coords`);
+            continue;
+          }
+          const glComments = await gitlabAdapter.fetchComments(issue.iid);
+          const comments = [];
+          if (issue.description) {
+            comments.push({
+              id: `issue-${issue.iid}-body`,
+              text: issue.description,
+              createdAt: issue.created_at,
+              author: issue.author?.username,
+              githubCommentId: void 0
+            });
+          }
+          glComments.forEach((note) => {
+            comments.push({
+              id: `comment-${note.id}`,
+              text: note.body,
+              createdAt: note.created_at,
+              author: note.author?.username,
+              githubCommentId: note.id
+            });
+          });
+          newThreads.push({
+            id: `gitlab-${issue.iid}`,
+            x: coords[0],
+            y: coords[1],
+            route,
+            comments,
+            issueNumber: issue.iid,
+            provider: "gitlab",
+            syncStatus: "synced"
+          });
+        }
+      }
+      setThreads((prev) => {
+        const localOnlyThreads = prev.filter((t) => t.route === route && !t.issueNumber);
+        const mergedThreads = [
+          ...prev.filter((t) => t.route !== route),
+          // Keep threads from other routes
+          ...newThreads,
+          // Add synced threads
+          ...localOnlyThreads
+          // Keep local-only threads
+        ];
+        return mergedThreads;
+      });
+      console.log(`\u2705 Synced ${newThreads.length} threads from providers`);
+    } catch (error) {
+      console.error("Failed to sync from providers:", error);
+    } finally {
+      setIsSyncing(false);
+    }
+  }, []);
+  const retrySync = React.useCallback(async () => {
+    console.log("\u{1F504} Retrying sync for pending/error threads...");
+    const threadsToSync = threads.filter(
+      (t) => (t.syncStatus === "pending" || t.syncStatus === "error") && !t.issueNumber
+    );
+    if (threadsToSync.length === 0) {
+      console.log("No threads to sync");
+      return;
+    }
+    if (!isGitHubConfigured()) {
+      console.warn("GitHub not configured. Cannot retry sync.");
+      return;
+    }
+    for (const thread of threadsToSync) {
+      console.log(`\u{1F535} Syncing thread ${thread.id}...`);
+      setThreads((prev) => prev.map(
+        (t) => t.id === thread.id ? { ...t, syncStatus: "syncing" } : t
+      ));
+      const pageName = thread.route === "/" ? "Home page" : thread.route.split("/").filter(Boolean).join(" > ") || "Page";
+      const versionStr = thread.version ? ` [v${thread.version}]` : "";
+      const issue = await githubAdapter.createIssue(
+        `\u{1F4AC} ${pageName} comment${versionStr}`,
+        `Thread created on route: ${thread.route}
+
+Coordinates: (${Math.round(thread.x)}, ${Math.round(thread.y)})
+
+**Version:** ${thread.version || "N/A"}`,
+        thread.route,
+        thread.x,
+        thread.y,
+        thread.version
+      );
+      if (issue.success && issue.data) {
+        console.log("\u2705 Created GitHub issue #", issue.data.number);
+        setThreads((prev) => prev.map(
+          (t) => t.id === thread.id ? { ...t, issueNumber: issue.data.number } : t
+        ));
+        for (const comment of thread.comments) {
+          if (!comment.githubCommentId) {
+            const commentResult = await githubAdapter.createComment(issue.data.number, comment.text);
+            if (commentResult.success && commentResult.data) {
+              setThreads((prev) => prev.map((t) => {
+                if (t.id === thread.id) {
+                  return {
+                    ...t,
+                    comments: t.comments.map(
+                      (c) => c.id === comment.id ? { ...c, githubCommentId: commentResult.data.id } : c
+                    )
+                  };
+                }
+                return t;
+              }));
+            }
+          }
+        }
+        setThreads((prev) => prev.map(
+          (t) => t.id === thread.id ? { ...t, syncStatus: "synced" } : t
+        ));
+      } else {
+        console.error("\u274C Failed to create GitHub issue:", issue.error);
+        setThreads((prev) => prev.map(
+          (t) => t.id === thread.id ? { ...t, syncStatus: "error", syncError: issue.error } : t
+        ));
+      }
+    }
+    console.log("\u2705 Retry sync complete");
+  }, [threads]);
+  const hasPendingSync = React.useMemo(() => {
+    return threads.some((t) => t.syncStatus === "pending" || t.syncStatus === "error");
+  }, [threads]);
+  const value = React.useMemo(
+    () => ({
+      threads,
+      showPins,
+      enableCommenting,
+      toggleShowPins,
+      toggleEnableCommenting,
+      addThread,
+      addReply,
+      updateComment,
+      deleteComment,
+      deleteThread,
+      clearAllThreads,
+      getThreadsForRoute,
+      syncFromGitHub,
+      retrySync,
+      isSyncing,
+      hasPendingSync
+    }),
+    [threads, showPins, enableCommenting, toggleShowPins, toggleEnableCommenting, addThread, addReply, updateComment, deleteComment, deleteThread, clearAllThreads, getThreadsForRoute, syncFromGitHub, retrySync, isSyncing, hasPendingSync]
+  );
+  return /* @__PURE__ */ jsx(CommentContext.Provider, { value, children });
 };
 var useComments = () => {
-  const context = useContext(CommentContext);
+  const context = React.useContext(CommentContext);
   if (!context) {
-    throw new Error("useComments must be used within CommentProvider");
+    throw new Error("useComments must be used within a CommentProvider");
   }
   return context;
 };
 
 // src/contexts/VersionContext.tsx
-import { createContext as createContext2, useContext as useContext2 } from "react";
-import { jsx as jsx7 } from "react/jsx-runtime";
-var VersionContext = createContext2(null);
+import * as React2 from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var VersionContext = React2.createContext(void 0);
+var VERSION_STORAGE_KEY = "apollo-current-version";
 var VersionProvider = ({ children }) => {
-  return /* @__PURE__ */ jsx7(VersionContext.Provider, { value: {}, children });
+  const [currentVersion, setCurrentVersionState] = React2.useState(() => {
+    try {
+      const stored = localStorage.getItem(VERSION_STORAGE_KEY);
+      return stored || "3";
+    } catch (error) {
+      console.error("Failed to load version from localStorage:", error);
+      return "3";
+    }
+  });
+  React2.useEffect(() => {
+    try {
+      localStorage.setItem(VERSION_STORAGE_KEY, currentVersion);
+    } catch (error) {
+      console.error("Failed to save version to localStorage:", error);
+    }
+  }, [currentVersion]);
+  const setCurrentVersion = React2.useCallback((version) => {
+    setCurrentVersionState(version);
+  }, []);
+  const value = React2.useMemo(
+    () => ({
+      currentVersion,
+      setCurrentVersion
+    }),
+    [currentVersion, setCurrentVersion]
+  );
+  return /* @__PURE__ */ jsx2(VersionContext.Provider, { value, children });
 };
 var useVersion = () => {
-  const context = useContext2(VersionContext);
+  const context = React2.useContext(VersionContext);
   if (!context) {
-    throw new Error("useVersion must be used within VersionProvider");
+    throw new Error("useVersion must be used within a VersionProvider");
   }
   return context;
 };
 
-// src/contexts/GitHubAuthContext.tsx
-import { createContext as createContext3, useContext as useContext3 } from "react";
-import { jsx as jsx8 } from "react/jsx-runtime";
-var GitHubAuthContext = createContext3(null);
-var GitHubAuthProvider = ({ children, config }) => {
-  return /* @__PURE__ */ jsx8(GitHubAuthContext.Provider, { value: {}, children });
+// src/components/CommentPin.tsx
+import { Button } from "@patternfly/react-core";
+import { CommentIcon, ExclamationTriangleIcon } from "@patternfly/react-icons";
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var CommentPin = ({
+  thread,
+  onPinClick,
+  isSelected = false
+}) => {
+  const commentCount = thread.comments.length;
+  const isPending = thread.syncStatus === "pending" || thread.syncStatus === "syncing";
+  const isError = thread.syncStatus === "error";
+  const pulseAnimation = isPending ? {
+    animation: "pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite"
+  } : {};
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3("style", { children: `
+          @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+          }
+        ` }),
+    /* @__PURE__ */ jsx3(
+      Button,
+      {
+        id: `comment-pin-${thread.id}`,
+        variant: "plain",
+        "aria-label": `Comment thread with ${commentCount} ${commentCount === 1 ? "comment" : "comments"}${isError ? " - sync error" : ""}${isPending ? " - syncing" : ""}`,
+        onClick: (e) => {
+          e.stopPropagation();
+          onPinClick();
+        },
+        style: {
+          position: "absolute",
+          left: `${thread.x}px`,
+          top: `${thread.y}px`,
+          transform: "translate(-50%, -50%)",
+          width: "32px",
+          height: "32px",
+          borderRadius: "50%",
+          backgroundColor: isError ? "#A30000" : isPending ? "#F0AB00" : "#C9190B",
+          color: "white",
+          border: isSelected ? "3px solid #0066CC" : "2px solid white",
+          boxShadow: isSelected ? "0 0 0 2px #0066CC, 0 4px 12px rgba(0, 0, 0, 0.4)" : "0 2px 8px rgba(0, 0, 0, 0.3)",
+          padding: 0,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          cursor: "pointer",
+          zIndex: isSelected ? 1001 : 1e3,
+          transition: "all 0.2s ease",
+          fontSize: commentCount > 1 ? "0.7rem" : void 0,
+          ...pulseAnimation
+        },
+        children: isError ? /* @__PURE__ */ jsx3(ExclamationTriangleIcon, { style: { fontSize: "1rem" } }) : commentCount === 0 ? /* @__PURE__ */ jsx3("span", { style: { fontWeight: "bold", fontSize: "0.75rem" }, children: "0" }) : commentCount === 1 ? /* @__PURE__ */ jsx3(CommentIcon, {}) : /* @__PURE__ */ jsx3("span", { style: { fontWeight: "bold" }, children: commentCount })
+      }
+    )
+  ] });
 };
-var useGitHubAuth = () => {
-  const context = useContext3(GitHubAuthContext);
-  if (!context) {
-    throw new Error("useGitHubAuth must be used within GitHubAuthProvider");
+
+// src/components/CommentOverlay.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var CommentOverlay = ({
+  selectedThreadId,
+  onThreadSelect
+}) => {
+  const location = useLocation();
+  const { showPins, enableCommenting, addThread, getThreadsForRoute } = useComments();
+  const { currentVersion } = useVersion();
+  const overlayRef = React3.useRef(null);
+  const currentRouteThreads = React3.useMemo(
+    () => getThreadsForRoute(location.pathname, currentVersion),
+    [getThreadsForRoute, location.pathname, currentVersion]
+  );
+  const handleOverlayClick = React3.useCallback(
+    (event) => {
+      if (!enableCommenting) return;
+      if (event.target === overlayRef.current) {
+        const rect = overlayRef.current.getBoundingClientRect();
+        const x = event.clientX - rect.left;
+        const y = event.clientY - rect.top;
+        const newThreadId = addThread(x, y, location.pathname, currentVersion);
+        onThreadSelect(newThreadId);
+      }
+    },
+    [enableCommenting, addThread, location.pathname, currentVersion, onThreadSelect]
+  );
+  if (!showPins && !enableCommenting) {
+    return null;
   }
-  return context;
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref: overlayRef,
+      id: "comment-overlay",
+      onClick: handleOverlayClick,
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        pointerEvents: enableCommenting ? "auto" : "none",
+        cursor: enableCommenting ? "crosshair" : "default",
+        zIndex: 999
+      },
+      children: showPins && currentRouteThreads.map((thread) => /* @__PURE__ */ jsx4(
+        "div",
+        {
+          style: { pointerEvents: "auto" },
+          onClick: (e) => e.stopPropagation(),
+          children: /* @__PURE__ */ jsx4(
+            CommentPin,
+            {
+              thread,
+              onPinClick: () => onThreadSelect(thread.id),
+              isSelected: thread.id === selectedThreadId
+            }
+          )
+        },
+        thread.id
+      ))
+    }
+  );
 };
 
+// src/components/CommentDrawer.tsx
+import * as React6 from "react";
+import {
+  Drawer,
+  DrawerContent,
+  DrawerContentBody,
+  DrawerPanelContent,
+  DrawerHead,
+  DrawerActions,
+  DrawerCloseButton,
+  Title,
+  Button as Button2,
+  TextArea,
+  Card,
+  CardBody,
+  CardTitle,
+  EmptyState,
+  EmptyStateBody,
+  Divider,
+  Label,
+  Spinner,
+  ExpandableSection,
+  Alert
+} from "@patternfly/react-core";
+import { CommentIcon as CommentIcon2, TimesIcon, PlusCircleIcon, SyncAltIcon, GithubIcon, ExternalLinkAltIcon, RedoIcon, MagicIcon } from "@patternfly/react-icons";
+import { useLocation as useLocation2 } from "react-router-dom";
+
 // src/contexts/GitLabAuthContext.tsx
-import { createContext as createContext4, useContext as useContext4 } from "react";
-import { jsx as jsx9 } from "react/jsx-runtime";
-var GitLabAuthContext = createContext4(null);
+import * as React4 from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var GitLabAuthContext = React4.createContext(void 0);
+var GITLAB_TOKEN_KEY = "gitlab_access_token";
+var GITLAB_USER_KEY = "gitlab_user";
 var GitLabAuthProvider = ({ children }) => {
-  return /* @__PURE__ */ jsx9(GitLabAuthContext.Provider, { value: {}, children });
+  const [user, setUser] = React4.useState(null);
+  React4.useEffect(() => {
+    try {
+      const token = localStorage.getItem(GITLAB_TOKEN_KEY);
+      const userStr = localStorage.getItem(GITLAB_USER_KEY);
+      if (token && userStr) {
+        setUser(JSON.parse(userStr));
+      }
+    } catch {
+    }
+  }, []);
+  React4.useEffect(() => {
+    const handleCallback = () => {
+      const hash = window.location.hash;
+      if (hash.includes("#/auth-callback")) {
+        const params = new URLSearchParams(hash.split("?")[1]);
+        const token = params.get("gitlab_token");
+        const username = params.get("gitlab_username") || void 0;
+        const avatar = params.get("gitlab_avatar") || void 0;
+        if (token) {
+          localStorage.setItem(GITLAB_TOKEN_KEY, token);
+          const u = { username, avatar };
+          localStorage.setItem(GITLAB_USER_KEY, JSON.stringify(u));
+          setUser(u);
+          window.location.hash = "/";
+        }
+      }
+    };
+    handleCallback();
+  }, []);
+  const getToken = React4.useCallback(() => {
+    try {
+      return localStorage.getItem(GITLAB_TOKEN_KEY);
+    } catch {
+      return null;
+    }
+  }, []);
+  const login = () => {
+    const clientId = process.env.VITE_GITLAB_CLIENT_ID;
+    const baseUrl = process.env.VITE_GITLAB_BASE_URL || "https://gitlab.com";
+    if (!clientId) {
+      alert("GitLab login is not configured (missing VITE_GITLAB_CLIENT_ID).");
+      return;
+    }
+    const redirectUri = `${window.location.origin}/api/auth/callback`;
+    const scope = encodeURIComponent("read_user api");
+    const url = `${baseUrl}/oauth/authorize?client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&response_type=code&scope=${scope}`;
+    window.location.href = url;
+  };
+  const logout = () => {
+    try {
+      localStorage.removeItem(GITLAB_TOKEN_KEY);
+      localStorage.removeItem(GITLAB_USER_KEY);
+    } finally {
+      setUser(null);
+    }
+  };
+  return /* @__PURE__ */ jsx5(
+    GitLabAuthContext.Provider,
+    {
+      value: {
+        user,
+        isAuthenticated: !!getToken(),
+        login,
+        logout,
+        getToken
+      },
+      children
+    }
+  );
 };
 var useGitLabAuth = () => {
-  const context = useContext4(GitLabAuthContext);
-  if (!context) {
-    throw new Error("useGitLabAuth must be used within GitLabAuthProvider");
+  const ctx = React4.useContext(GitLabAuthContext);
+  if (!ctx) {
+    throw new Error("useGitLabAuth must be used within a GitLabAuthProvider");
   }
-  return context;
+  return ctx;
 };
 
 // src/contexts/AIContext.tsx
-import { createContext as createContext5, useContext as useContext5 } from "react";
-import { jsx as jsx10 } from "react/jsx-runtime";
-var AIContext = createContext5(null);
+import * as React5 from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var AIContext = React5.createContext(void 0);
+var STORAGE_KEY2 = "apollo-ai-chat-history";
+var VISIBILITY_KEY = "apollo-ai-chatbot-visible";
 var AIProvider = ({ children }) => {
-  return /* @__PURE__ */ jsx10(AIContext.Provider, { value: {}, children });
+  const [isChatbotVisible, setIsChatbotVisible] = React5.useState(() => {
+    try {
+      const stored = localStorage.getItem(VISIBILITY_KEY);
+      return stored === "true";
+    } catch (error) {
+      return false;
+    }
+  });
+  const [messages, setMessages] = React5.useState(() => {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY2);
+      if (stored) {
+        return JSON.parse(stored);
+      }
+      return [];
+    } catch (error) {
+      console.error("Failed to load AI chat history from localStorage:", error);
+      return [];
+    }
+  });
+  const [isLoading, setIsLoading] = React5.useState(false);
+  React5.useEffect(() => {
+    try {
+      localStorage.setItem(VISIBILITY_KEY, String(isChatbotVisible));
+    } catch (error) {
+      console.error("Failed to save chatbot visibility to localStorage:", error);
+    }
+  }, [isChatbotVisible]);
+  React5.useEffect(() => {
+    try {
+      localStorage.setItem(STORAGE_KEY2, JSON.stringify(messages));
+    } catch (error) {
+      console.error("Failed to save AI chat history to localStorage:", error);
+    }
+  }, [messages]);
+  const toggleChatbot = React5.useCallback(() => {
+    setIsChatbotVisible((prev) => !prev);
+  }, []);
+  const sendMessage = React5.useCallback(async (content, commentContext) => {
+    if (!content.trim()) return;
+    const userMessage = {
+      id: `user-${Date.now()}`,
+      role: "user",
+      content: content.trim(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    setMessages((prev) => [...prev, userMessage]);
+    setIsLoading(true);
+    try {
+      if (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") {
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        const mockResponse = `**Mock AI Response** (local dev mode)
+
+I analyzed your query: "${content.trim()}"
+
+**Summary:**
+- Found ${commentContext?.threads?.length || 0} comment threads
+- Version: ${commentContext?.version || "unknown"}
+- Page: ${commentContext?.route || "unknown"}
+
+*Note: This is a mock response. Deploy to production to test the real AI.*`;
+        const botMessage2 = {
+          id: `bot-${Date.now()}`,
+          role: "bot",
+          content: mockResponse,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        setMessages((prev) => [...prev, botMessage2]);
+        return;
+      }
+      const response = await fetch("/api/ai-assistant", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query: content.trim(),
+          threads: commentContext?.threads || [],
+          version: commentContext?.version || "unknown",
+          route: commentContext?.route
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.message || `API error: ${response.status}`);
+      }
+      const data = await response.json();
+      const botMessage = {
+        id: `bot-${Date.now()}`,
+        role: "bot",
+        content: data.message || "No response received.",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, botMessage]);
+    } catch (error) {
+      console.error("Failed to send message:", error);
+      const errorMessage = {
+        id: `bot-error-${Date.now()}`,
+        role: "bot",
+        content: error instanceof Error ? `Sorry, I encountered an error: ${error.message}` : "Sorry, something went wrong. Please try again.",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, errorMessage]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const clearHistory = React5.useCallback(() => {
+    setMessages([]);
+    try {
+      localStorage.removeItem(STORAGE_KEY2);
+    } catch (error) {
+      console.error("Failed to clear chat history from localStorage:", error);
+    }
+  }, []);
+  const value = React5.useMemo(
+    () => ({
+      isChatbotVisible,
+      messages,
+      isLoading,
+      toggleChatbot,
+      sendMessage,
+      clearHistory
+    }),
+    [isChatbotVisible, messages, isLoading, toggleChatbot, sendMessage, clearHistory]
+  );
+  return /* @__PURE__ */ jsx6(AIContext.Provider, { value, children });
 };
 var useAIContext = () => {
-  const context = useContext5(AIContext);
+  const context = React5.useContext(AIContext);
   if (!context) {
-    throw new Error("useAIContext must be used within AIProvider");
+    throw new Error("useAIContext must be used within an AIProvider");
   }
   return context;
 };
 
-// src/services/githubAdapter.ts
-var githubAdapter = {
-  // TODO: Implement GitHub adapter methods
+// src/components/CommentDrawer.tsx
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs2 } from "react/jsx-runtime";
+var CommentDrawer = ({
+  children,
+  selectedThreadId,
+  onThreadSelect
+}) => {
+  const location = useLocation2();
+  const {
+    getThreadsForRoute,
+    addReply,
+    updateComment,
+    deleteComment,
+    deleteThread,
+    enableCommenting,
+    syncFromGitHub,
+    isSyncing,
+    retrySync,
+    hasPendingSync
+  } = useComments();
+  const { currentVersion } = useVersion();
+  const { isAuthenticated: isGitLabAuthenticated } = useGitLabAuth();
+  const { sendMessage, toggleChatbot, isChatbotVisible } = useAIContext();
+  const [editingCommentId, setEditingCommentId] = React6.useState(null);
+  const [editText, setEditText] = React6.useState("");
+  const [replyText, setReplyText] = React6.useState("");
+  const replyTextAreaRef = React6.useRef(null);
+  const [threadSummaries, setThreadSummaries] = React6.useState({});
+  const [loadingSummary, setLoadingSummary] = React6.useState(false);
+  const [summaryExpanded, setSummaryExpanded] = React6.useState(true);
+  const currentRouteThreads = getThreadsForRoute(location.pathname, currentVersion);
+  const selectedThread = currentRouteThreads.find((t) => t.id === selectedThreadId);
+  const isDrawerOpen = selectedThreadId !== null && selectedThread !== void 0;
+  const isUserAuthenticated = isGitHubConfigured() || isGitLabAuthenticated;
+  React6.useEffect(() => {
+    if (!isDrawerOpen || !enableCommenting) return;
+    const timer = setTimeout(() => {
+      replyTextAreaRef.current?.focus();
+    }, 100);
+    return () => clearTimeout(timer);
+  }, [isDrawerOpen, enableCommenting, selectedThreadId]);
+  React6.useEffect(() => {
+    if (isGitHubConfigured() || isGitLabConfigured()) {
+      syncFromGitHub(location.pathname).catch((err) => {
+        console.error("Failed to sync from providers:", err);
+      });
+    }
+  }, [location.pathname]);
+  const handleEdit = (commentId, text) => {
+    setEditingCommentId(commentId);
+    setEditText(text);
+  };
+  const handleSave = async (threadId, commentId) => {
+    await updateComment(threadId, commentId, editText);
+    setEditingCommentId(null);
+  };
+  const handleAddReply = async () => {
+    if (selectedThreadId && replyText.trim()) {
+      await addReply(selectedThreadId, replyText);
+      setReplyText("");
+    }
+  };
+  const handleDeleteThread = async () => {
+    if (selectedThreadId && window.confirm("Delete this entire thread and all its comments?")) {
+      await deleteThread(selectedThreadId);
+      onThreadSelect(null);
+    }
+  };
+  const handleSummarizeThread = async () => {
+    if (!selectedThread) return;
+    setLoadingSummary(true);
+    setSummaryExpanded(true);
+    try {
+      const response = await fetch("/api/ai-assistant", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query: `Summarize the feedback in this thread (${selectedThread.comments.length} comments)`,
+          threads: [selectedThread],
+          version: currentVersion || "unknown",
+          route: location.pathname
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`API error: ${response.status}`);
+      }
+      const data = await response.json();
+      const summary = data.message || "No summary available.";
+      setThreadSummaries((prev) => ({
+        ...prev,
+        [selectedThread.id]: summary
+      }));
+    } catch (error) {
+      console.error("Failed to generate summary:", error);
+      setThreadSummaries((prev) => ({
+        ...prev,
+        [selectedThread.id]: "Failed to generate summary. Please try again."
+      }));
+    } finally {
+      setLoadingSummary(false);
+    }
+  };
+  const handleDeleteComment = async (threadId, commentId) => {
+    if (window.confirm("Delete this comment?")) {
+      await deleteComment(threadId, commentId);
+    }
+  };
+  const handleSync = async () => {
+    await syncFromGitHub(location.pathname);
+  };
+  const handleRetrySync = async () => {
+    await retrySync();
+  };
+  const getSyncStatusLabel = (status) => {
+    switch (status) {
+      case "synced":
+        return /* @__PURE__ */ jsx7(Label, { color: "green", icon: /* @__PURE__ */ jsx7(GithubIcon, {}), children: "Synced" });
+      case "local":
+        return /* @__PURE__ */ jsx7(Label, { color: "grey", children: "Local Only" });
+      case "pending":
+        return /* @__PURE__ */ jsx7(Label, { color: "blue", icon: /* @__PURE__ */ jsx7(Spinner, { size: "sm" }), children: "Pending..." });
+      case "syncing":
+        return /* @__PURE__ */ jsx7(Label, { color: "blue", icon: /* @__PURE__ */ jsx7(Spinner, { size: "sm" }), children: "Syncing..." });
+      case "error":
+        return /* @__PURE__ */ jsx7(Label, { color: "red", children: "Sync Error" });
+      default:
+        return null;
+    }
+  };
+  const getIssueLink = (provider, issueNumber) => {
+    if (!issueNumber || !provider) return null;
+    try {
+      if (provider === "gitlab") {
+        const baseUrl = process.env.VITE_GITLAB_BASE_URL || "https://gitlab.com";
+        const projectPath = process.env.VITE_GITLAB_PROJECT_PATH;
+        if (!projectPath) return null;
+        return `${baseUrl}/${projectPath}/-/issues/${issueNumber}`;
+      } else {
+        const owner = process.env.VITE_GITHUB_OWNER;
+        const repo = process.env.VITE_GITHUB_REPO;
+        if (!owner || !repo) return null;
+        return `https://github.com/${owner}/${repo}/issues/${issueNumber}`;
+      }
+    } catch (error) {
+      return null;
+    }
+  };
+  const formatDate = (isoDate) => {
+    const date = new Date(isoDate);
+    return date.toLocaleString(void 0, {
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+  };
+  const panelContent = /* @__PURE__ */ jsxs2(DrawerPanelContent, { isResizable: true, defaultSize: "400px", minSize: "300px", children: [
+    /* @__PURE__ */ jsxs2(DrawerHead, { children: [
+      /* @__PURE__ */ jsxs2("div", { style: { display: "flex", alignItems: "center", gap: "0.5rem", flex: 1 }, children: [
+        /* @__PURE__ */ jsxs2(Title, { headingLevel: "h2", size: "xl", children: [
+          /* @__PURE__ */ jsx7(CommentIcon2, { style: { marginRight: "0.5rem", color: "#C9190B" } }),
+          "Thread"
+        ] }),
+        (isGitHubConfigured() || isGitLabConfigured()) && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx7(
+            Button2,
+            {
+              id: "sync-github-button",
+              variant: "plain",
+              size: "sm",
+              icon: /* @__PURE__ */ jsx7(SyncAltIcon, {}),
+              onClick: handleSync,
+              isDisabled: isSyncing,
+              "aria-label": "Sync with remote",
+              title: "Sync with remote",
+              children: isSyncing ? /* @__PURE__ */ jsx7(Spinner, { size: "sm" }) : null
+            }
+          ),
+          hasPendingSync && /* @__PURE__ */ jsx7(
+            Button2,
+            {
+              id: "retry-sync-button",
+              variant: "plain",
+              size: "sm",
+              icon: /* @__PURE__ */ jsx7(RedoIcon, {}),
+              onClick: handleRetrySync,
+              isDisabled: isSyncing,
+              "aria-label": "Retry sync for pending threads",
+              title: "Retry sync for pending threads"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx7(DrawerActions, { children: /* @__PURE__ */ jsx7(DrawerCloseButton, { onClick: () => onThreadSelect(null) }) })
+    ] }),
+    /* @__PURE__ */ jsx7(DrawerContentBody, { style: { padding: "1rem" }, children: !selectedThread ? /* @__PURE__ */ jsxs2(EmptyState, { children: [
+      /* @__PURE__ */ jsx7(CommentIcon2, { style: { fontSize: "3rem", color: "var(--pf-v6-global--Color--200)", marginBottom: "1rem" } }),
+      /* @__PURE__ */ jsx7(Title, { headingLevel: "h3", size: "lg", children: "No thread selected" }),
+      /* @__PURE__ */ jsx7(EmptyStateBody, { children: "Click a pin to view its comments." })
+    ] }) : /* @__PURE__ */ jsxs2("div", { style: { display: "flex", flexDirection: "column", gap: "1rem" }, children: [
+      /* @__PURE__ */ jsx7(Card, { isCompact: true, children: /* @__PURE__ */ jsxs2(CardBody, { children: [
+        /* @__PURE__ */ jsxs2("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ jsx7("strong", { children: "Location:" }),
+          " (",
+          Math.round(selectedThread.x),
+          ", ",
+          Math.round(selectedThread.y),
+          ")"
+        ] }),
+        selectedThread.version && /* @__PURE__ */ jsxs2("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ jsx7("strong", { children: "Version:" }),
+          " ",
+          selectedThread.version
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ jsx7("strong", { children: "Comments:" }),
+          " ",
+          selectedThread.comments.length
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { style: { display: "flex", alignItems: "center", gap: "0.5rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ jsx7("strong", { style: { fontSize: "0.875rem" }, children: "Status:" }),
+          getSyncStatusLabel(selectedThread.syncStatus)
+        ] }),
+        selectedThread.issueNumber && /* @__PURE__ */ jsx7("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: /* @__PURE__ */ jsxs2(
+          "a",
+          {
+            href: getIssueLink(selectedThread.provider, selectedThread.issueNumber) || "#",
+            target: "_blank",
+            rel: "noopener noreferrer",
+            style: { display: "inline-flex", alignItems: "center", gap: "0.25rem" },
+            children: [
+              /* @__PURE__ */ jsx7(GithubIcon, {}),
+              "Issue #",
+              selectedThread.issueNumber,
+              /* @__PURE__ */ jsx7(ExternalLinkAltIcon, { style: { fontSize: "0.75rem" } })
+            ]
+          }
+        ) }),
+        selectedThread.comments.length > 0 && /* @__PURE__ */ jsx7(
+          Button2,
+          {
+            id: `ai-summarize-thread-${selectedThread.id}`,
+            variant: "secondary",
+            size: "sm",
+            icon: /* @__PURE__ */ jsx7(MagicIcon, {}),
+            onClick: handleSummarizeThread,
+            isLoading: loadingSummary,
+            isDisabled: loadingSummary,
+            style: { marginTop: "0.5rem" },
+            children: loadingSummary ? "Generating..." : "AI Summarize Thread"
+          }
+        ),
+        enableCommenting && isUserAuthenticated && /* @__PURE__ */ jsx7(
+          Button2,
+          {
+            id: `delete-thread-${selectedThread.id}`,
+            variant: "danger",
+            size: "sm",
+            icon: /* @__PURE__ */ jsx7(TimesIcon, {}),
+            onClick: handleDeleteThread,
+            style: { marginTop: "0.5rem", marginLeft: selectedThread.comments.length > 0 ? "0.5rem" : "0" },
+            children: "Delete Thread"
+          }
+        )
+      ] }) }),
+      threadSummaries[selectedThread.id] && /* @__PURE__ */ jsx7(
+        Alert,
+        {
+          variant: "info",
+          isInline: true,
+          title: "AI Summary",
+          actionClose: /* @__PURE__ */ jsx7(
+            Button2,
+            {
+              variant: "plain",
+              onClick: () => {
+                const newSummaries = { ...threadSummaries };
+                delete newSummaries[selectedThread.id];
+                setThreadSummaries(newSummaries);
+              },
+              "aria-label": "Clear summary",
+              children: /* @__PURE__ */ jsx7(TimesIcon, {})
+            }
+          ),
+          children: /* @__PURE__ */ jsx7(
+            ExpandableSection,
+            {
+              toggleText: summaryExpanded ? "Hide summary" : "Show summary",
+              onToggle: (_event, isExpanded) => setSummaryExpanded(isExpanded),
+              isExpanded: summaryExpanded,
+              isIndented: true,
+              children: /* @__PURE__ */ jsx7("div", { style: { fontSize: "0.875rem", lineHeight: "1.5" }, children: threadSummaries[selectedThread.id] })
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx7(Divider, {}),
+      /* @__PURE__ */ jsx7("div", { style: { display: "flex", flexDirection: "column", gap: "1rem" }, children: selectedThread.comments.length === 0 ? /* @__PURE__ */ jsxs2(EmptyState, { children: [
+        /* @__PURE__ */ jsx7(Title, { headingLevel: "h4", size: "md", children: "No comments yet" }),
+        /* @__PURE__ */ jsx7(EmptyStateBody, { children: enableCommenting ? "Add a reply below to start the conversation." : "Enable commenting to add replies." })
+      ] }) : selectedThread.comments.map((comment, index) => /* @__PURE__ */ jsxs2(Card, { isCompact: true, children: [
+        /* @__PURE__ */ jsxs2(CardTitle, { children: [
+          "Comment #",
+          index + 1,
+          /* @__PURE__ */ jsxs2("div", { style: { fontSize: "0.75rem", color: "var(--pf-v6-global--Color--200)", fontWeight: "normal" }, children: [
+            comment.author && /* @__PURE__ */ jsxs2("span", { style: { marginRight: "0.5rem" }, children: [
+              "@",
+              comment.author
+            ] }),
+            formatDate(comment.createdAt)
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx7(CardBody, { children: editingCommentId === comment.id ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx7(
+            TextArea,
+            {
+              id: `edit-comment-${comment.id}`,
+              value: editText,
+              onChange: (_event, value) => setEditText(value),
+              rows: 3,
+              style: { marginBottom: "0.5rem" },
+              onKeyDown: (e) => {
+                if (e.key === "Enter" && !e.shiftKey) {
+                  e.preventDefault();
+                  handleSave(selectedThread.id, comment.id);
+                }
+                if (e.key === "Escape") {
+                  setEditingCommentId(null);
+                }
+              }
+            }
+          ),
+          /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: "0.5rem" }, children: [
+            /* @__PURE__ */ jsx7(
+              Button2,
+              {
+                id: `save-comment-${comment.id}`,
+                variant: "primary",
+                size: "sm",
+                onClick: () => handleSave(selectedThread.id, comment.id),
+                children: "Save"
+              }
+            ),
+            /* @__PURE__ */ jsx7(
+              Button2,
+              {
+                id: `cancel-edit-${comment.id}`,
+                variant: "link",
+                size: "sm",
+                onClick: () => setEditingCommentId(null),
+                children: "Cancel"
+              }
+            )
+          ] })
+        ] }) : /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx7("div", { style: { marginBottom: "0.75rem", whiteSpace: "pre-wrap" }, children: comment.text || /* @__PURE__ */ jsx7("em", { style: { color: "var(--pf-v6-global--Color--200)" }, children: "No text" }) }),
+          enableCommenting && isUserAuthenticated && /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: "0.5rem" }, children: [
+            /* @__PURE__ */ jsx7(
+              Button2,
+              {
+                id: `edit-comment-btn-${comment.id}`,
+                variant: "secondary",
+                size: "sm",
+                onClick: () => handleEdit(comment.id, comment.text),
+                children: "Edit"
+              }
+            ),
+            /* @__PURE__ */ jsx7(
+              Button2,
+              {
+                id: `delete-comment-btn-${comment.id}`,
+                variant: "danger",
+                size: "sm",
+                icon: /* @__PURE__ */ jsx7(TimesIcon, {}),
+                onClick: () => handleDeleteComment(selectedThread.id, comment.id),
+                children: "Delete"
+              }
+            )
+          ] })
+        ] }) })
+      ] }, comment.id)) }),
+      enableCommenting && isUserAuthenticated && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        /* @__PURE__ */ jsx7(Divider, {}),
+        /* @__PURE__ */ jsxs2(Card, { isCompact: true, children: [
+          /* @__PURE__ */ jsxs2(CardTitle, { children: [
+            /* @__PURE__ */ jsx7(PlusCircleIcon, { style: { marginRight: "0.5rem" } }),
+            "Add Reply"
+          ] }),
+          /* @__PURE__ */ jsxs2(CardBody, { children: [
+            /* @__PURE__ */ jsx7(
+              TextArea,
+              {
+                ref: replyTextAreaRef,
+                id: `reply-textarea-${selectedThread.id}`,
+                value: replyText,
+                onChange: (_event, value) => setReplyText(value),
+                placeholder: "Enter your reply...",
+                rows: 3,
+                style: { marginBottom: "0.5rem" },
+                onKeyDown: (e) => {
+                  if (e.key === "Enter" && !e.shiftKey) {
+                    e.preventDefault();
+                    handleAddReply();
+                  }
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx7(
+              Button2,
+              {
+                id: `add-reply-${selectedThread.id}`,
+                variant: "primary",
+                size: "sm",
+                onClick: handleAddReply,
+                isDisabled: !replyText.trim(),
+                children: "Add Reply"
+              }
+            )
+          ] })
+        ] })
+      ] })
+    ] }) })
+  ] });
+  return /* @__PURE__ */ jsx7(Drawer, { isExpanded: isDrawerOpen, isInline: true, position: "right", children: /* @__PURE__ */ jsx7(DrawerContent, { panelContent, children: /* @__PURE__ */ jsx7(DrawerContentBody, { children }) }) });
 };
-var isGitHubConfigured = () => {
-  return false;
+
+// src/components/AIAssistant.tsx
+import { ChatbotToggle } from "@patternfly/chatbot";
+
+// src/components/AIChatPanel.tsx
+import * as React7 from "react";
+import {
+  Chatbot,
+  ChatbotDisplayMode,
+  ChatbotHeader,
+  ChatbotHeaderActions,
+  ChatbotHeaderMain,
+  ChatbotHeaderTitle,
+  ChatbotContent,
+  ChatbotFooter,
+  ChatbotWelcomePrompt,
+  MessageBox,
+  Message
+} from "@patternfly/chatbot";
+import {
+  Button as Button3,
+  Label as Label2,
+  TextArea as TextArea2,
+  ActionList,
+  ActionListItem
+} from "@patternfly/react-core";
+import { TimesIcon as TimesIcon2, PaperPlaneIcon, TrashIcon } from "@patternfly/react-icons";
+import { useLocation as useLocation3 } from "react-router-dom";
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
+var AIChatPanel = () => {
+  const { messages, isLoading, sendMessage, toggleChatbot, clearHistory } = useAIContext();
+  const { currentVersion } = useVersion();
+  const { threads } = useComments();
+  const location = useLocation3();
+  const [inputValue, setInputValue] = React7.useState("");
+  const commentCount = React7.useMemo(() => {
+    return threads.filter((t) => t.version === currentVersion).reduce((acc, t) => acc + t.comments.length, 0);
+  }, [threads, currentVersion]);
+  const handleSendMessage = async () => {
+    if (inputValue.trim() && !isLoading) {
+      await sendMessage(inputValue, {
+        threads,
+        version: currentVersion || "unknown",
+        route: location.pathname
+      });
+      setInputValue("");
+    }
+  };
+  const handleKeyDown = (event) => {
+    if (event.key === "Enter" && !event.shiftKey) {
+      event.preventDefault();
+      handleSendMessage();
+    }
+  };
+  const handleQuickAction = (action) => {
+    setInputValue(action);
+  };
+  return /* @__PURE__ */ jsx8(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        bottom: "80px",
+        right: "20px",
+        width: "400px",
+        maxHeight: "600px",
+        zIndex: 2e3,
+        boxShadow: "0 4px 12px rgba(0, 0, 0, 0.15)"
+      },
+      children: /* @__PURE__ */ jsxs3(Chatbot, { displayMode: ChatbotDisplayMode.default, children: [
+        /* @__PURE__ */ jsxs3(ChatbotHeader, { children: [
+          /* @__PURE__ */ jsxs3(ChatbotHeaderMain, { children: [
+            /* @__PURE__ */ jsx8(ChatbotHeaderTitle, { children: "\u{1F916} AI Feedback Assistant" }),
+            currentVersion && commentCount > 0 && /* @__PURE__ */ jsxs3("span", { style: { marginLeft: "0.5rem" }, children: [
+              /* @__PURE__ */ jsxs3(Label2, { color: "blue", isCompact: true, children: [
+                "Version ",
+                currentVersion
+              ] }),
+              /* @__PURE__ */ jsxs3(Label2, { color: "grey", isCompact: true, style: { marginLeft: "0.25rem" }, children: [
+                commentCount,
+                " comments"
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs3(ChatbotHeaderActions, { children: [
+            messages.length > 0 && /* @__PURE__ */ jsx8(
+              Button3,
+              {
+                variant: "plain",
+                onClick: clearHistory,
+                "aria-label": "Clear chat history",
+                icon: /* @__PURE__ */ jsx8(TrashIcon, {})
+              }
+            ),
+            /* @__PURE__ */ jsx8(
+              Button3,
+              {
+                variant: "plain",
+                onClick: toggleChatbot,
+                "aria-label": "Close chatbot",
+                icon: /* @__PURE__ */ jsx8(TimesIcon2, {})
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx8(ChatbotContent, { children: /* @__PURE__ */ jsx8(MessageBox, { children: messages.length === 0 ? /* @__PURE__ */ jsx8(
+          ChatbotWelcomePrompt,
+          {
+            title: "Welcome to AI Feedback Assistant",
+            description: "Ask me about comments across your prototype. I can help you:",
+            children: /* @__PURE__ */ jsxs3(ActionList, { children: [
+              /* @__PURE__ */ jsx8(ActionListItem, { children: /* @__PURE__ */ jsx8(
+                Button3,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("What feedback was left in the last week?"),
+                  children: "Summarize recent feedback"
+                }
+              ) }),
+              /* @__PURE__ */ jsx8(ActionListItem, { children: /* @__PURE__ */ jsx8(
+                Button3,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("Show me all accessibility issues"),
+                  children: "Find accessibility issues"
+                }
+              ) }),
+              /* @__PURE__ */ jsx8(ActionListItem, { children: /* @__PURE__ */ jsx8(
+                Button3,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("What are the main navigation problems?"),
+                  children: "Identify navigation problems"
+                }
+              ) }),
+              /* @__PURE__ */ jsx8(ActionListItem, { children: /* @__PURE__ */ jsx8(
+                Button3,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("Which page has the most comments?"),
+                  children: "Analyze comment distribution"
+                }
+              ) })
+            ] })
+          }
+        ) : /* @__PURE__ */ jsxs3(Fragment3, { children: [
+          messages.map((msg) => /* @__PURE__ */ jsx8(
+            Message,
+            {
+              name: msg.role === "user" ? "You" : "AI Assistant",
+              role: msg.role === "user" ? "user" : "bot",
+              avatar: msg.role === "user" ? "/images/user_advatar.jpg" : "/images/halefavicon.png",
+              content: msg.content,
+              timestamp: new Date(msg.timestamp).toLocaleString(void 0, {
+                month: "short",
+                day: "numeric",
+                hour: "2-digit",
+                minute: "2-digit"
+              })
+            },
+            msg.id
+          )),
+          isLoading && /* @__PURE__ */ jsx8(
+            Message,
+            {
+              name: "AI Assistant",
+              role: "bot",
+              avatar: "/images/halefavicon.png",
+              content: "\u23F3 Analyzing comments..."
+            }
+          )
+        ] }) }) }),
+        /* @__PURE__ */ jsx8(ChatbotFooter, { children: /* @__PURE__ */ jsxs3("div", { style: { display: "flex", gap: "0.5rem", alignItems: "flex-end", width: "100%" }, children: [
+          /* @__PURE__ */ jsx8(
+            TextArea2,
+            {
+              id: "ai-chat-input",
+              value: inputValue,
+              onChange: (_event, value) => setInputValue(value),
+              onKeyDown: handleKeyDown,
+              placeholder: "Ask about feedback...",
+              "aria-label": "Message input",
+              rows: 2,
+              style: { flex: 1 },
+              isDisabled: isLoading
+            }
+          ),
+          /* @__PURE__ */ jsx8(
+            Button3,
+            {
+              variant: "primary",
+              onClick: handleSendMessage,
+              isDisabled: !inputValue.trim() || isLoading,
+              icon: /* @__PURE__ */ jsx8(PaperPlaneIcon, {}),
+              "aria-label": "Send message"
+            }
+          )
+        ] }) })
+      ] })
+    }
+  );
 };
 
-// src/services/gitlabAdapter.ts
-var gitlabAdapter = {
-  // TODO: Implement GitLab adapter methods
+// src/components/AIAssistant.tsx
+import { Fragment as Fragment4, jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+var AIAssistant = () => {
+  const { isChatbotVisible, toggleChatbot } = useAIContext();
+  return /* @__PURE__ */ jsxs4(Fragment4, { children: [
+    /* @__PURE__ */ jsx9(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          bottom: "20px",
+          right: "20px",
+          zIndex: 2e3
+        },
+        children: /* @__PURE__ */ jsx9(
+          ChatbotToggle,
+          {
+            id: "ai-chatbot-toggle",
+            isChatbotVisible,
+            onToggleChatbot: toggleChatbot,
+            toggleButtonLabel: "AI Assistant",
+            tooltipLabel: "Get AI help analyzing feedback",
+            style: {
+              backgroundColor: "#C9190B",
+              borderRadius: "50%",
+              width: "56px",
+              height: "56px",
+              border: "2px solid white",
+              boxShadow: "0 2px 8px rgba(0, 0, 0, 0.3)",
+              color: "white"
+            }
+          }
+        )
+      }
+    ),
+    isChatbotVisible && /* @__PURE__ */ jsx9(AIChatPanel, {})
+  ] });
 };
-var isGitLabConfigured = () => {
-  return false;
+
+// src/contexts/GitHubAuthContext.tsx
+import * as React8 from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var GitHubAuthContext = React8.createContext(void 0);
+var GitHubAuthProvider = ({ children }) => {
+  const [user, setUser] = React8.useState(null);
+  React8.useEffect(() => {
+    const storedUser = getAuthenticatedUser();
+    if (storedUser) {
+      setUser(storedUser);
+    }
+  }, []);
+  React8.useEffect(() => {
+    const handleOAuthCallback = () => {
+      const hash = window.location.hash;
+      if (hash.includes("#/auth-callback")) {
+        const params = new URLSearchParams(hash.split("?")[1]);
+        const token = params.get("token");
+        const login2 = params.get("login");
+        const avatar = params.get("avatar");
+        if (token && login2 && avatar) {
+          storeGitHubAuth(token, login2, decodeURIComponent(avatar));
+          setUser({ login: login2, avatar: decodeURIComponent(avatar) });
+          window.location.hash = "/";
+        }
+      }
+    };
+    handleOAuthCallback();
+  }, []);
+  const login = () => {
+    const clientId = process.env.VITE_GITHUB_CLIENT_ID;
+    if (!clientId) {
+      alert("GitHub login is not configured (missing VITE_GITHUB_CLIENT_ID).");
+      return;
+    }
+    const redirectUri = `${window.location.origin}/api/github-oauth-callback`;
+    const scope = "public_repo";
+    const githubAuthUrl = `https://github.com/login/oauth/authorize?client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${encodeURIComponent(scope)}`;
+    console.log("\u{1F50D} GitHub OAuth redirect:", { clientId: "present", redirectUri });
+    window.location.href = githubAuthUrl;
+  };
+  const logout = () => {
+    clearGitHubAuth();
+    setUser(null);
+  };
+  return /* @__PURE__ */ jsx10(
+    GitHubAuthContext.Provider,
+    {
+      value: {
+        user,
+        isAuthenticated: !!user,
+        login,
+        logout
+      },
+      children
+    }
+  );
+};
+var useGitHubAuth = () => {
+  const context = React8.useContext(GitHubAuthContext);
+  if (context === void 0) {
+    throw new Error("useGitHubAuth must be used within a GitHubAuthProvider");
+  }
+  return context;
 };
 export {
   AIAssistant,