hale-commenting-system 1.0.2 → 1.0.4

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -43,124 +53,2217 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/components/CommentOverlay.tsx
-var import_jsx_runtime = require("react/jsx-runtime");
-var CommentOverlay = ({ selectedThreadId, onThreadSelect }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: "Comment Overlay Placeholder" }) });
-};
+var React3 = __toESM(require("react"));
+var import_react_router_dom = require("react-router-dom");
 
-// src/components/CommentDrawer.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var CommentDrawer = ({ selectedThreadId, onThreadSelect, children }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { children });
-};
+// src/contexts/CommentContext.tsx
+var React = __toESM(require("react"));
 
-// src/components/CommentPin.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var CommentPin = () => {
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { children: "CommentPin Placeholder" });
+// src/services/githubAdapter.ts
+var import_axios = __toESM(require("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 import_axios.default.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
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var AIAssistant = () => {
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("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
-var import_jsx_runtime5 = require("react/jsx-runtime");
-var AIChatPanel = () => {
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { children: "AIChatPanel Placeholder" });
+// src/services/gitlabAdapter.ts
+var import_axios2 = __toESM(require("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 import_axios2.default.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
-var import_react = require("react");
-var import_jsx_runtime6 = require("react/jsx-runtime");
-var CommentContext = (0, import_react.createContext)(null);
+var import_jsx_runtime = require("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__ */ (0, import_jsx_runtime6.jsx)(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__ */ (0, import_jsx_runtime.jsx)(CommentContext.Provider, { value, children });
 };
 var useComments = () => {
-  const context = (0, import_react.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
-var import_react2 = require("react");
-var import_jsx_runtime7 = require("react/jsx-runtime");
-var VersionContext = (0, import_react2.createContext)(null);
+var React2 = __toESM(require("react"));
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var VersionContext = React2.createContext(void 0);
+var VERSION_STORAGE_KEY = "apollo-current-version";
 var VersionProvider = ({ children }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(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__ */ (0, import_jsx_runtime2.jsx)(VersionContext.Provider, { value, children });
 };
 var useVersion = () => {
-  const context = (0, import_react2.useContext)(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
-var import_react3 = require("react");
-var import_jsx_runtime8 = require("react/jsx-runtime");
-var GitHubAuthContext = (0, import_react3.createContext)(null);
-var GitHubAuthProvider = ({ children, config }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(GitHubAuthContext.Provider, { value: {}, children });
+// src/components/CommentPin.tsx
+var import_react_core = require("@patternfly/react-core");
+var import_react_icons = require("@patternfly/react-icons");
+var import_jsx_runtime3 = require("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__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("style", { children: `
+          @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+          }
+        ` }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_react_core.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__ */ (0, import_jsx_runtime3.jsx)(import_react_icons.ExclamationTriangleIcon, { style: { fontSize: "1rem" } }) : commentCount === 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { fontWeight: "bold", fontSize: "0.75rem" }, children: "0" }) : commentCount === 1 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_icons.CommentIcon, {}) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { fontWeight: "bold" }, children: commentCount })
+      }
+    )
+  ] });
 };
-var useGitHubAuth = () => {
-  const context = (0, import_react3.useContext)(GitHubAuthContext);
-  if (!context) {
-    throw new Error("useGitHubAuth must be used within GitHubAuthProvider");
+
+// src/components/CommentOverlay.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var CommentOverlay = ({
+  selectedThreadId,
+  onThreadSelect
+}) => {
+  const location = (0, import_react_router_dom.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__ */ (0, import_jsx_runtime4.jsx)(
+    "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__ */ (0, import_jsx_runtime4.jsx)(
+        "div",
+        {
+          style: { pointerEvents: "auto" },
+          onClick: (e) => e.stopPropagation(),
+          children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            CommentPin,
+            {
+              thread,
+              onPinClick: () => onThreadSelect(thread.id),
+              isSelected: thread.id === selectedThreadId
+            }
+          )
+        },
+        thread.id
+      ))
+    }
+  );
 };
 
+// src/components/CommentDrawer.tsx
+var React6 = __toESM(require("react"));
+var import_react_core2 = require("@patternfly/react-core");
+var import_react_icons2 = require("@patternfly/react-icons");
+var import_react_router_dom2 = require("react-router-dom");
+
 // src/contexts/GitLabAuthContext.tsx
-var import_react4 = require("react");
-var import_jsx_runtime9 = require("react/jsx-runtime");
-var GitLabAuthContext = (0, import_react4.createContext)(null);
+var React4 = __toESM(require("react"));
+var import_jsx_runtime5 = require("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__ */ (0, import_jsx_runtime9.jsx)(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__ */ (0, import_jsx_runtime5.jsx)(
+    GitLabAuthContext.Provider,
+    {
+      value: {
+        user,
+        isAuthenticated: !!getToken(),
+        login,
+        logout,
+        getToken
+      },
+      children
+    }
+  );
 };
 var useGitLabAuth = () => {
-  const context = (0, import_react4.useContext)(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
-var import_react5 = require("react");
-var import_jsx_runtime10 = require("react/jsx-runtime");
-var AIContext = (0, import_react5.createContext)(null);
+var React5 = __toESM(require("react"));
+var import_jsx_runtime6 = require("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__ */ (0, import_jsx_runtime10.jsx)(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__ */ (0, import_jsx_runtime6.jsx)(AIContext.Provider, { value, children });
 };
 var useAIContext = () => {
-  const context = (0, import_react5.useContext)(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
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var CommentDrawer = ({
+  children,
+  selectedThreadId,
+  onThreadSelect
+}) => {
+  const location = (0, import_react_router_dom2.useLocation)();
+  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__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Label, { color: "green", icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.GithubIcon, {}), children: "Synced" });
+      case "local":
+        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Label, { color: "grey", children: "Local Only" });
+      case "pending":
+        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Label, { color: "blue", icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Spinner, { size: "sm" }), children: "Pending..." });
+      case "syncing":
+        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Label, { color: "blue", icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Spinner, { size: "sm" }), children: "Syncing..." });
+      case "error":
+        return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.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__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.DrawerPanelContent, { isResizable: true, defaultSize: "400px", minSize: "300px", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.DrawerHead, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: "0.5rem", flex: 1 }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.Title, { headingLevel: "h2", size: "xl", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.CommentIcon, { style: { marginRight: "0.5rem", color: "#C9190B" } }),
+          "Thread"
+        ] }),
+        (isGitHubConfigured() || isGitLabConfigured()) && /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+            import_react_core2.Button,
+            {
+              id: "sync-github-button",
+              variant: "plain",
+              size: "sm",
+              icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.SyncAltIcon, {}),
+              onClick: handleSync,
+              isDisabled: isSyncing,
+              "aria-label": "Sync with remote",
+              title: "Sync with remote",
+              children: isSyncing ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Spinner, { size: "sm" }) : null
+            }
+          ),
+          hasPendingSync && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+            import_react_core2.Button,
+            {
+              id: "retry-sync-button",
+              variant: "plain",
+              size: "sm",
+              icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.RedoIcon, {}),
+              onClick: handleRetrySync,
+              isDisabled: isSyncing,
+              "aria-label": "Retry sync for pending threads",
+              title: "Retry sync for pending threads"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.DrawerActions, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.DrawerCloseButton, { onClick: () => onThreadSelect(null) }) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.DrawerContentBody, { style: { padding: "1rem" }, children: !selectedThread ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.EmptyState, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.CommentIcon, { style: { fontSize: "3rem", color: "var(--pf-v6-global--Color--200)", marginBottom: "1rem" } }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Title, { headingLevel: "h3", size: "lg", children: "No thread selected" }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.EmptyStateBody, { children: "Click a pin to view its comments." })
+    ] }) : /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { display: "flex", flexDirection: "column", gap: "1rem" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Card, { isCompact: true, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.CardBody, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("strong", { children: "Location:" }),
+          " (",
+          Math.round(selectedThread.x),
+          ", ",
+          Math.round(selectedThread.y),
+          ")"
+        ] }),
+        selectedThread.version && /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("strong", { children: "Version:" }),
+          " ",
+          selectedThread.version
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("strong", { children: "Comments:" }),
+          " ",
+          selectedThread.comments.length
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: "0.5rem", marginBottom: "0.5rem" }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("strong", { style: { fontSize: "0.875rem" }, children: "Status:" }),
+          getSyncStatusLabel(selectedThread.syncStatus)
+        ] }),
+        selectedThread.issueNumber && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { style: { fontSize: "0.875rem", marginBottom: "0.5rem" }, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+          "a",
+          {
+            href: getIssueLink(selectedThread.provider, selectedThread.issueNumber) || "#",
+            target: "_blank",
+            rel: "noopener noreferrer",
+            style: { display: "inline-flex", alignItems: "center", gap: "0.25rem" },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.GithubIcon, {}),
+              "Issue #",
+              selectedThread.issueNumber,
+              /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.ExternalLinkAltIcon, { style: { fontSize: "0.75rem" } })
+            ]
+          }
+        ) }),
+        selectedThread.comments.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          import_react_core2.Button,
+          {
+            id: `ai-summarize-thread-${selectedThread.id}`,
+            variant: "secondary",
+            size: "sm",
+            icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.MagicIcon, {}),
+            onClick: handleSummarizeThread,
+            isLoading: loadingSummary,
+            isDisabled: loadingSummary,
+            style: { marginTop: "0.5rem" },
+            children: loadingSummary ? "Generating..." : "AI Summarize Thread"
+          }
+        ),
+        enableCommenting && isUserAuthenticated && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          import_react_core2.Button,
+          {
+            id: `delete-thread-${selectedThread.id}`,
+            variant: "danger",
+            size: "sm",
+            icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.TimesIcon, {}),
+            onClick: handleDeleteThread,
+            style: { marginTop: "0.5rem", marginLeft: selectedThread.comments.length > 0 ? "0.5rem" : "0" },
+            children: "Delete Thread"
+          }
+        )
+      ] }) }),
+      threadSummaries[selectedThread.id] && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+        import_react_core2.Alert,
+        {
+          variant: "info",
+          isInline: true,
+          title: "AI Summary",
+          actionClose: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+            import_react_core2.Button,
+            {
+              variant: "plain",
+              onClick: () => {
+                const newSummaries = { ...threadSummaries };
+                delete newSummaries[selectedThread.id];
+                setThreadSummaries(newSummaries);
+              },
+              "aria-label": "Clear summary",
+              children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.TimesIcon, {})
+            }
+          ),
+          children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+            import_react_core2.ExpandableSection,
+            {
+              toggleText: summaryExpanded ? "Hide summary" : "Show summary",
+              onToggle: (_event, isExpanded) => setSummaryExpanded(isExpanded),
+              isExpanded: summaryExpanded,
+              isIndented: true,
+              children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { style: { fontSize: "0.875rem", lineHeight: "1.5" }, children: threadSummaries[selectedThread.id] })
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Divider, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { style: { display: "flex", flexDirection: "column", gap: "1rem" }, children: selectedThread.comments.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.EmptyState, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Title, { headingLevel: "h4", size: "md", children: "No comments yet" }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.EmptyStateBody, { children: enableCommenting ? "Add a reply below to start the conversation." : "Enable commenting to add replies." })
+      ] }) : selectedThread.comments.map((comment, index) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.Card, { isCompact: true, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.CardTitle, { children: [
+          "Comment #",
+          index + 1,
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { fontSize: "0.75rem", color: "var(--pf-v6-global--Color--200)", fontWeight: "normal" }, children: [
+            comment.author && /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("span", { style: { marginRight: "0.5rem" }, children: [
+              "@",
+              comment.author
+            ] }),
+            formatDate(comment.createdAt)
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.CardBody, { children: editingCommentId === comment.id ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+            import_react_core2.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__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { display: "flex", gap: "0.5rem" }, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+              import_react_core2.Button,
+              {
+                id: `save-comment-${comment.id}`,
+                variant: "primary",
+                size: "sm",
+                onClick: () => handleSave(selectedThread.id, comment.id),
+                children: "Save"
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+              import_react_core2.Button,
+              {
+                id: `cancel-edit-${comment.id}`,
+                variant: "link",
+                size: "sm",
+                onClick: () => setEditingCommentId(null),
+                children: "Cancel"
+              }
+            )
+          ] })
+        ] }) : /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { style: { marginBottom: "0.75rem", whiteSpace: "pre-wrap" }, children: comment.text || /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("em", { style: { color: "var(--pf-v6-global--Color--200)" }, children: "No text" }) }),
+          enableCommenting && isUserAuthenticated && /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { style: { display: "flex", gap: "0.5rem" }, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+              import_react_core2.Button,
+              {
+                id: `edit-comment-btn-${comment.id}`,
+                variant: "secondary",
+                size: "sm",
+                onClick: () => handleEdit(comment.id, comment.text),
+                children: "Edit"
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+              import_react_core2.Button,
+              {
+                id: `delete-comment-btn-${comment.id}`,
+                variant: "danger",
+                size: "sm",
+                icon: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.TimesIcon, {}),
+                onClick: () => handleDeleteComment(selectedThread.id, comment.id),
+                children: "Delete"
+              }
+            )
+          ] })
+        ] }) })
+      ] }, comment.id)) }),
+      enableCommenting && isUserAuthenticated && /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Divider, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.Card, { isCompact: true, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.CardTitle, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_icons2.PlusCircleIcon, { style: { marginRight: "0.5rem" } }),
+            "Add Reply"
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_react_core2.CardBody, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+              import_react_core2.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__ */ (0, import_jsx_runtime7.jsx)(
+              import_react_core2.Button,
+              {
+                id: `add-reply-${selectedThread.id}`,
+                variant: "primary",
+                size: "sm",
+                onClick: handleAddReply,
+                isDisabled: !replyText.trim(),
+                children: "Add Reply"
+              }
+            )
+          ] })
+        ] })
+      ] })
+    ] }) })
+  ] });
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.Drawer, { isExpanded: isDrawerOpen, isInline: true, position: "right", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.DrawerContent, { panelContent, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_core2.DrawerContentBody, { children }) }) });
 };
-var isGitHubConfigured = () => {
-  return false;
+
+// src/components/AIAssistant.tsx
+var import_chatbot2 = require("@patternfly/chatbot");
+
+// src/components/AIChatPanel.tsx
+var React7 = __toESM(require("react"));
+var import_chatbot = require("@patternfly/chatbot");
+var import_react_core3 = require("@patternfly/react-core");
+var import_react_icons3 = require("@patternfly/react-icons");
+var import_react_router_dom3 = require("react-router-dom");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var AIChatPanel = () => {
+  const { messages, isLoading, sendMessage, toggleChatbot, clearHistory } = useAIContext();
+  const { currentVersion } = useVersion();
+  const { threads } = useComments();
+  const location = (0, import_react_router_dom3.useLocation)();
+  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__ */ (0, import_jsx_runtime8.jsx)(
+    "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__ */ (0, import_jsx_runtime8.jsxs)(import_chatbot.Chatbot, { displayMode: import_chatbot.ChatbotDisplayMode.default, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_chatbot.ChatbotHeader, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_chatbot.ChatbotHeaderMain, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_chatbot.ChatbotHeaderTitle, { children: "\u{1F916} AI Feedback Assistant" }),
+            currentVersion && commentCount > 0 && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { style: { marginLeft: "0.5rem" }, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_react_core3.Label, { color: "blue", isCompact: true, children: [
+                "Version ",
+                currentVersion
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_react_core3.Label, { color: "grey", isCompact: true, style: { marginLeft: "0.25rem" }, children: [
+                commentCount,
+                " comments"
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_chatbot.ChatbotHeaderActions, { children: [
+            messages.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+              import_react_core3.Button,
+              {
+                variant: "plain",
+                onClick: clearHistory,
+                "aria-label": "Clear chat history",
+                icon: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_icons3.TrashIcon, {})
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+              import_react_core3.Button,
+              {
+                variant: "plain",
+                onClick: toggleChatbot,
+                "aria-label": "Close chatbot",
+                icon: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_icons3.TimesIcon, {})
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_chatbot.ChatbotContent, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_chatbot.MessageBox, { children: messages.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          import_chatbot.ChatbotWelcomePrompt,
+          {
+            title: "Welcome to AI Feedback Assistant",
+            description: "Ask me about comments across your prototype. I can help you:",
+            children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_react_core3.ActionList, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core3.ActionListItem, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                import_react_core3.Button,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("What feedback was left in the last week?"),
+                  children: "Summarize recent feedback"
+                }
+              ) }),
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core3.ActionListItem, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                import_react_core3.Button,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("Show me all accessibility issues"),
+                  children: "Find accessibility issues"
+                }
+              ) }),
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core3.ActionListItem, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                import_react_core3.Button,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("What are the main navigation problems?"),
+                  children: "Identify navigation problems"
+                }
+              ) }),
+              /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_core3.ActionListItem, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+                import_react_core3.Button,
+                {
+                  variant: "link",
+                  isInline: true,
+                  onClick: () => handleQuickAction("Which page has the most comments?"),
+                  children: "Analyze comment distribution"
+                }
+              ) })
+            ] })
+          }
+        ) : /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+          messages.map((msg) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            import_chatbot.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__ */ (0, import_jsx_runtime8.jsx)(
+            import_chatbot.Message,
+            {
+              name: "AI Assistant",
+              role: "bot",
+              avatar: "/images/halefavicon.png",
+              content: "\u23F3 Analyzing comments..."
+            }
+          )
+        ] }) }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_chatbot.ChatbotFooter, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { style: { display: "flex", gap: "0.5rem", alignItems: "flex-end", width: "100%" }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            import_react_core3.TextArea,
+            {
+              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__ */ (0, import_jsx_runtime8.jsx)(
+            import_react_core3.Button,
+            {
+              variant: "primary",
+              onClick: handleSendMessage,
+              isDisabled: !inputValue.trim() || isLoading,
+              icon: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_icons3.PaperPlaneIcon, {}),
+              "aria-label": "Send message"
+            }
+          )
+        ] }) })
+      ] })
+    }
+  );
 };
 
-// src/services/gitlabAdapter.ts
-var gitlabAdapter = {
-  // TODO: Implement GitLab adapter methods
+// src/components/AIAssistant.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var AIAssistant = () => {
+  const { isChatbotVisible, toggleChatbot } = useAIContext();
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          bottom: "20px",
+          right: "20px",
+          zIndex: 2e3
+        },
+        children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+          import_chatbot2.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__ */ (0, import_jsx_runtime9.jsx)(AIChatPanel, {})
+  ] });
 };
-var isGitLabConfigured = () => {
-  return false;
+
+// src/contexts/GitHubAuthContext.tsx
+var React8 = __toESM(require("react"));
+var import_jsx_runtime10 = require("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__ */ (0, import_jsx_runtime10.jsx)(
+    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;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {