next-ai-editor 0.2.5 → 1.0.0

package/dist/index.js

@@ -1,36 +1,2111 @@
-import { A, C, a } from "./AIEditorProvider-DWId5Qmv.js";
-import "react/jsx-runtime";
-import "react";
-import "react-markdown";
-import "remark-gfm";
-import { j, t, g, l, o, m, x, h, d, f, a as a2, c, b, e, i, n, q, u, p, r, w, s, v, k } from "./comments-BYFEhf6K.js";
+"use client";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useRef, useMemo, useCallback, forwardRef, createElement, createContext } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { flushSync } from "react-dom";
+function cleanPath(filePath) {
+  if (!filePath) return "";
+  let cleaned = filePath;
+  cleaned = cleaned.replace(/^about:\/\/React\/Server\//, "");
+  if (cleaned.startsWith("file://")) {
+    cleaned = cleaned.replace(/^file:\/\//, "");
+  }
+  try {
+    if (cleaned.includes("%")) {
+      cleaned = decodeURIComponent(cleaned);
+    }
+  } catch (e) {
+  }
+  cleaned = cleaned.replace(/^webpack-internal:\/\/\/\([^)]+\)\/\.\//, "").replace(/^webpack-internal:\/\/\/\([^)]+\)\//, "").replace(/^webpack-internal:\/\//, "").replace(/^webpack:\/\/[^/]*\//, "").replace(/^\([^)]+\)\//, "").replace(/^\.\//, "").replace(/\?.*$/, "");
+  return cleaned;
+}
+function shouldSkipPath(filePath, additionalSkipPatterns = []) {
+  if (!filePath) return true;
+  const defaultSkipPatterns = ["node_modules", "next/dist", "react-dom"];
+  const allPatterns = [...defaultSkipPatterns, ...additionalSkipPatterns];
+  return allPatterns.some((pattern) => filePath.includes(pattern));
+}
+function getFiberFromElement(element) {
+  const key = Object.keys(element).find(
+    (k) => k.startsWith("__reactFiber$") || k.startsWith("__reactInternalInstance$")
+  );
+  return key ? element[key] : null;
+}
+function getComponentName(fiber) {
+  var _a, _b;
+  if (!fiber) return "Unknown";
+  const type = fiber.type;
+  if ((_a = fiber._debugSource) == null ? void 0 : _a.fileName) {
+    const fileName = fiber._debugSource.fileName;
+    const match = fileName.match(/\/([^/]+)\.(tsx?|jsx?)$/);
+    if (match) return match[1];
+  }
+  if (typeof type === "string") return type;
+  if (typeof type === "function")
+    return type.displayName || type.name || "Anonymous";
+  if (type == null ? void 0 : type.displayName) return type.displayName;
+  if ((_b = type == null ? void 0 : type.render) == null ? void 0 : _b.name) return type.render.name;
+  if (fiber._debugStack) {
+    const stack = String(fiber._debugStack.stack || fiber._debugStack);
+    const match = stack.match(/at\s+([A-Z][a-zA-Z0-9]*)\s*\(/);
+    if (match && match[1] !== "Object") {
+      return match[1];
+    }
+  }
+  return "Unknown";
+}
+function isUserComponent(fiber) {
+  if (fiber.tag === 5 || fiber.tag === 6 || fiber.tag === 3) return false;
+  const type = fiber.type;
+  if (!type || typeof type === "string") return false;
+  return true;
+}
+function countNthOfType(element, tagName) {
+  let boundary = element.parentElement;
+  while (boundary) {
+    const fiber = getFiberFromElement(boundary);
+    if (fiber && isUserComponent(fiber)) break;
+    boundary = boundary.parentElement;
+  }
+  if (!boundary) boundary = element.parentElement;
+  if (!boundary) return 1;
+  const sameTagElements = [];
+  if (boundary.tagName.toLowerCase() === tagName.toLowerCase()) {
+    sameTagElements.push(boundary);
+  }
+  sameTagElements.push(...Array.from(boundary.querySelectorAll(tagName)));
+  let count = 1;
+  for (const el of sameTagElements) {
+    if (el === element) break;
+    count++;
+  }
+  return count;
+}
+function extractProps(fiber) {
+  if (!fiber) return void 0;
+  const fiberProps = fiber.memoizedProps || fiber.pendingProps;
+  if (!fiberProps || typeof fiberProps !== "object") return void 0;
+  const props = {};
+  const identifyingKeys = [
+    "id",
+    "name",
+    "type",
+    "href",
+    "src",
+    "alt",
+    "role",
+    "aria-label",
+    "data-testid"
+  ];
+  for (const key of identifyingKeys) {
+    if (key in fiberProps && typeof fiberProps[key] === "string") {
+      props[key] = fiberProps[key];
+    }
+  }
+  if (fiberProps.style && typeof fiberProps.style === "object") {
+    props._styleKeys = Object.keys(fiberProps.style).slice(0, 5);
+  }
+  return Object.keys(props).length > 0 ? props : void 0;
+}
+function captureElementContext(element, fiber) {
+  const tagName = element.tagName.toLowerCase();
+  let textContent;
+  const directText = Array.from(element.childNodes).filter((n) => n.nodeType === Node.TEXT_NODE).map((n) => {
+    var _a;
+    return (_a = n.textContent) == null ? void 0 : _a.trim();
+  }).filter(Boolean).join(" ");
+  if (directText) {
+    textContent = directText.slice(0, 50);
+  } else if (element.textContent) {
+    textContent = element.textContent.trim().slice(0, 50);
+  }
+  const className = typeof element.className === "string" ? element.className.slice(0, 100) : void 0;
+  const nthOfType = countNthOfType(element, tagName);
+  const key = (fiber == null ? void 0 : fiber.key) ? String(fiber.key) : void 0;
+  const props = extractProps(fiber);
+  return { tagName, textContent, className, key, nthOfType, props };
+}
+function extractFromDebugStack(fiber) {
+  const stack = fiber._debugStack;
+  if (!stack) return null;
+  const stackStr = stack.stack || String(stack);
+  const frames = stackStr.split("\n");
+  const skipPatterns = [
+    "node_modules",
+    "SegmentViewNode",
+    "LayoutRouter",
+    "ErrorBoundary",
+    "fakeJSXCallSite"
+  ];
+  for (const frame of frames) {
+    if (skipPatterns.some((p) => frame.includes(p))) continue;
+    const match = frame.match(/at\s+(\w+)\s+\((.+?):(\d+):(\d+)\)?$/);
+    if (match) {
+      const fileName = cleanPath(match[2].replace(/\?[^:]*$/, ""));
+      if (!shouldSkipPath(fileName, ["ai-editor-provider"])) {
+        return {
+          fileName,
+          lineNumber: parseInt(match[3], 10),
+          columnNumber: parseInt(match[4], 10)
+        };
+      }
+    }
+  }
+  return null;
+}
+function extractFromDebugOwner(fiber) {
+  var _a, _b;
+  const owner = fiber._debugOwner;
+  if (!owner) return null;
+  if ((_a = owner._debugSource) == null ? void 0 : _a.fileName) {
+    return owner._debugSource;
+  }
+  const stack = owner.stack;
+  if (Array.isArray(stack) && ((_b = stack[0]) == null ? void 0 : _b.fileName)) {
+    return stack[0];
+  }
+  return null;
+}
+function findSourceFromFiber(fiber) {
+  if (!fiber) return null;
+  let actualComponentName = null;
+  if (fiber._debugOwner && typeof fiber._debugOwner === "object") {
+    const debugOwner = fiber._debugOwner;
+    if (debugOwner.name && typeof debugOwner.name === "string") {
+      actualComponentName = debugOwner.name;
+    }
+  }
+  let current = fiber;
+  const visited = /* @__PURE__ */ new Set();
+  let iterations = 0;
+  while (current && !visited.has(current) && iterations < 10) {
+    iterations++;
+    visited.add(current);
+    const sourceData = current._debugSource || extractFromDebugStack(current) || extractFromDebugOwner(current);
+    if (sourceData == null ? void 0 : sourceData.fileName) {
+      const filePath = cleanPath(sourceData.fileName);
+      if (!shouldSkipPath(filePath, ["ai-editor-provider"])) {
+        if (actualComponentName) {
+          const rawDebugStack = current._debugStack ? String(current._debugStack.stack || current._debugStack) : void 0;
+          return {
+            filePath,
+            lineNumber: sourceData.lineNumber || 1,
+            columnNumber: sourceData.columnNumber || 0,
+            componentName: actualComponentName,
+            debugStack: rawDebugStack
+          };
+        } else {
+          let componentFiber = current;
+          while (componentFiber) {
+            if (isUserComponent(componentFiber)) {
+              const componentName = getComponentName(componentFiber);
+              const isNextJSInternal = [
+                "Segment",
+                "Boundary",
+                "Router",
+                "Handler",
+                "Context",
+                "Layout",
+                "Template",
+                "Scroll",
+                "Focus",
+                "Loading",
+                "Error"
+              ].some((pattern) => componentName.includes(pattern));
+              if (!isNextJSInternal) {
+                const rawDebugStack = current._debugStack ? String(current._debugStack.stack || current._debugStack) : void 0;
+                return {
+                  filePath,
+                  lineNumber: sourceData.lineNumber || 1,
+                  columnNumber: sourceData.columnNumber || 0,
+                  componentName,
+                  debugStack: rawDebugStack
+                };
+              }
+            }
+            componentFiber = componentFiber.return || componentFiber._debugOwner || null;
+          }
+        }
+      }
+    }
+    current = current.return || current._debugOwner || null;
+  }
+  return null;
+}
+function findParentComponentFromFiber(childFiber, childComponentName) {
+  if (!childFiber) return null;
+  let childComponentFiber = null;
+  if (childFiber._debugOwner && typeof childFiber._debugOwner === "object") {
+    const debugOwner = childFiber._debugOwner;
+    if (debugOwner.type && typeof debugOwner.type === "function") {
+      const ownerComponentName = getComponentName(debugOwner);
+      if (ownerComponentName === childComponentName) {
+        childComponentFiber = debugOwner;
+      }
+    }
+  }
+  if (!childComponentFiber) {
+    let current2 = childFiber;
+    let iterations2 = 0;
+    while (current2 && iterations2 < 20) {
+      iterations2++;
+      const componentName = getComponentName(current2);
+      current2.index;
+      if (isUserComponent(current2)) {
+        if (componentName === childComponentName) {
+          childComponentFiber = current2;
+          break;
+        }
+      }
+      if (current2._debugOwner && typeof current2._debugOwner === "object") {
+        const debugOwner = current2._debugOwner;
+        if (debugOwner.name === childComponentName && !debugOwner.type) {
+          const parent = current2.return;
+          const parentDebugOwner = parent == null ? void 0 : parent._debugOwner;
+          const isRootElement = !parentDebugOwner || parentDebugOwner.name !== childComponentName;
+          if (isRootElement) {
+            childComponentFiber = current2;
+            break;
+          }
+        }
+      }
+      current2 = current2.return;
+    }
+  }
+  let childKey;
+  if (childComponentFiber == null ? void 0 : childComponentFiber.key) {
+    childKey = String(childComponentFiber.key);
+  } else if (childComponentFiber && typeof childComponentFiber.index === "number") {
+    childKey = String(childComponentFiber.index);
+  }
+  if (childFiber._debugOwner && typeof childFiber._debugOwner === "object") {
+    const debugOwner = childFiber._debugOwner;
+    if (debugOwner.owner && debugOwner.owner.name) {
+      const parentName = debugOwner.owner.name;
+      const parentDebugLocation = debugOwner.owner.debugLocation;
+      if (parentDebugLocation) {
+        const stack = String(parentDebugLocation.stack || parentDebugLocation);
+        return {
+          filePath: "",
+          // Will be resolved on server
+          lineNumber: 0,
+          columnNumber: 0,
+          componentName: parentName,
+          debugStack: stack,
+          childKey
+        };
+      }
+    }
+    if (debugOwner.type && typeof debugOwner.type === "function") {
+      const componentFiberOwner = debugOwner._debugOwner;
+      if (componentFiberOwner && typeof componentFiberOwner === "object") {
+        const parentName = componentFiberOwner.name;
+        const parentDebugLocation = componentFiberOwner.debugLocation;
+        if (parentName && typeof parentName === "string") {
+          if (parentDebugLocation) {
+            const stack = String(
+              parentDebugLocation.stack || parentDebugLocation
+            );
+            return {
+              filePath: "",
+              // Will be resolved on server
+              lineNumber: 0,
+              columnNumber: 0,
+              componentName: parentName,
+              debugStack: stack,
+              childKey
+            };
+          }
+        }
+      }
+    }
+  }
+  let current = childFiber.return;
+  const visited = /* @__PURE__ */ new Set();
+  let iterations = 0;
+  while (current && !visited.has(current) && iterations < 20) {
+    iterations++;
+    visited.add(current);
+    if (isUserComponent(current)) {
+      const componentName = getComponentName(current);
+      if (componentName === childComponentName) {
+        current = current._debugOwner || null;
+        continue;
+      }
+      const shouldSkipComponent = componentName.includes("AIEditorProvider") || // Skip the AI Editor wrapper itself
+      componentName.startsWith("__next") || // Skip all Next.js internal components like __next_root_layout_boundary__
+      componentName.startsWith("_") || // Skip internal components starting with underscore
+      [
+        "Segment",
+        "Boundary",
+        "Router",
+        "Handler",
+        "Context",
+        "Layout",
+        "Template",
+        "Scroll",
+        "Focus",
+        "Loading",
+        "Error",
+        "RootLayout",
+        // Skip root layout wrapper
+        "NotFound"
+      ].some((pattern) => componentName.includes(pattern));
+      if (shouldSkipComponent) {
+        current = current._debugOwner || null;
+        continue;
+      }
+      const sourceData = current._debugSource || extractFromDebugStack(current) || extractFromDebugOwner(current);
+      if (sourceData == null ? void 0 : sourceData.fileName) {
+        const filePath = cleanPath(sourceData.fileName);
+        if (!shouldSkipPath(filePath, ["ai-editor-provider"])) {
+          const rawDebugStack = current._debugStack ? String(current._debugStack.stack || current._debugStack) : void 0;
+          return {
+            filePath,
+            lineNumber: sourceData.lineNumber || 1,
+            columnNumber: sourceData.columnNumber || 0,
+            componentName,
+            debugStack: rawDebugStack,
+            childKey
+          };
+        }
+      }
+    }
+    const nextOwner = current._debugOwner;
+    current = nextOwner || null;
+  }
+  const childDebugStack = childFiber._debugStack ? String(childFiber._debugStack.stack || childFiber._debugStack) : null;
+  if (childDebugStack) {
+    return {
+      filePath: "",
+      // Will be resolved on server from debugStack
+      lineNumber: 0,
+      columnNumber: 0,
+      componentName: "",
+      // Will be determined on server
+      debugStack: childDebugStack,
+      // Use child's debugStack for server-side resolution
+      childKey
+    };
+  }
+  return null;
+}
+function getSourceFromElement(element) {
+  var _a;
+  let current = element;
+  let elementWithSource = null;
+  let fiberWithSource = null;
+  while (current && current !== document.body) {
+    const fiber = getFiberFromElement(current);
+    if (fiber) {
+      const hasSourceInfo = ((_a = fiber._debugSource) == null ? void 0 : _a.fileName) || fiber._debugStack || fiber._debugOwner && typeof fiber._debugOwner === "object";
+      if (hasSourceInfo && !fiberWithSource) {
+        elementWithSource = current;
+        fiberWithSource = fiber;
+      }
+    }
+    current = current.parentElement;
+  }
+  if (!fiberWithSource || !elementWithSource) return null;
+  const source = findSourceFromFiber(fiberWithSource);
+  if (!source) return null;
+  const elementContext = captureElementContext(elementWithSource, fiberWithSource);
+  const parentComponent = findParentComponentFromFiber(
+    fiberWithSource,
+    source.componentName
+  );
+  return {
+    ...source,
+    elementContext,
+    parentComponent: parentComponent || void 0
+  };
+}
+if (typeof window !== "undefined") {
+  window.__getSource = getSourceFromElement;
+}
+function TaskHistoryPanel({
+  isOpen,
+  onClose,
+  tasks,
+  onTaskClick
+}) {
+  if (!isOpen) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "task-history-panel ai-editor-ui", children: [
+    /* @__PURE__ */ jsx("div", { className: "task-history-overlay", onClick: onClose }),
+    /* @__PURE__ */ jsxs("div", { className: "task-history-content", children: [
+      /* @__PURE__ */ jsxs("div", { className: "task-history-header", children: [
+        /* @__PURE__ */ jsxs("div", { className: "header-title", children: [
+          /* @__PURE__ */ jsx("span", { className: "header-icon", children: "📝" }),
+          /* @__PURE__ */ jsx("h2", { children: "Task History" })
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "close-btn",
+            onClick: onClose,
+            "aria-label": "Close",
+            title: "Close (Esc)",
+            children: "✕"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "task-history-body", children: tasks.length === 0 ? /* @__PURE__ */ jsxs("div", { className: "empty-state", children: [
+        /* @__PURE__ */ jsx("div", { className: "empty-icon", children: "🎯" }),
+        /* @__PURE__ */ jsx("h3", { children: "No tasks yet" }),
+        /* @__PURE__ */ jsx("p", { children: "Create a comment and send a message to see AI actions here." })
+      ] }) : /* @__PURE__ */ jsx("div", { className: "task-list", children: tasks.map((task) => /* @__PURE__ */ jsx(
+        TaskItem,
+        {
+          task,
+          onClick: () => onTaskClick == null ? void 0 : onTaskClick(task.id)
+        },
+        task.id
+      )) }) })
+    ] })
+  ] });
+}
+function TaskItem({ task, onClick }) {
+  const getStatusIcon = () => {
+    switch (task.status) {
+      case "pending":
+        return "⏳";
+      case "done":
+        return "✅";
+      case "failed":
+        return "❌";
+      default:
+        return "⏳";
+    }
+  };
+  const getStatusLabel = () => {
+    switch (task.status) {
+      case "pending":
+        return "In Progress";
+      case "done":
+        return "Complete";
+      case "failed":
+        return "Failed";
+      default:
+        return "Unknown";
+    }
+  };
+  const formatTime = (timestamp) => {
+    const date = new Date(timestamp);
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 6e4);
+    if (diffMins < 1) return "Just now";
+    if (diffMins < 60) return `${diffMins}m ago`;
+    const diffHours = Math.floor(diffMins / 60);
+    if (diffHours < 24) return `${diffHours}h ago`;
+    const diffDays = Math.floor(diffHours / 24);
+    return `${diffDays}d ago`;
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `task-item status-${task.status}`,
+      onClick,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "task-header", children: [
+          /* @__PURE__ */ jsxs("div", { className: "task-status", children: [
+            /* @__PURE__ */ jsx("span", { className: "status-icon", children: getStatusIcon() }),
+            /* @__PURE__ */ jsx("span", { className: "status-label", children: getStatusLabel() })
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "task-time", children: formatTime(task.createdAt) })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "task-request", children: task.userRequest }),
+        task.actions.length > 0 && /* @__PURE__ */ jsx("div", { className: "task-actions", children: task.actions.map((action, idx) => /* @__PURE__ */ jsxs("div", { className: "action-item", children: [
+          action.type === "tool_use" && /* @__PURE__ */ jsxs("span", { className: "action-text", children: [
+            "🔧 ",
+            action.tool
+          ] }),
+          action.type === "result" && /* @__PURE__ */ jsxs("span", { className: "action-text", children: [
+            "✓ ",
+            action.result
+          ] }),
+          action.type === "error" && /* @__PURE__ */ jsxs("span", { className: "action-text error", children: [
+            "⚠️ ",
+            action.error
+          ] })
+        ] }, idx)) }),
+        task.affectedFiles.length > 0 && /* @__PURE__ */ jsxs("div", { className: "task-files", children: [
+          /* @__PURE__ */ jsx("span", { className: "files-label", children: "Files:" }),
+          task.affectedFiles.map((file, idx) => /* @__PURE__ */ jsx("span", { className: "file-badge", children: file.split("/").pop() }, idx))
+        ] })
+      ]
+    }
+  );
+}
+function MessageItem({ message }) {
+  var _a, _b, _c;
+  if ("role" in message) {
+    const commentMsg = message;
+    if (commentMsg.role === "user") {
+      return /* @__PURE__ */ jsx("div", { className: "message message-user", children: /* @__PURE__ */ jsx("div", { className: "message-content", children: /* @__PURE__ */ jsx(ReactMarkdown, { remarkPlugins: [remarkGfm], children: commentMsg.content }) }) });
+    }
+    if (commentMsg.role === "assistant") {
+      return /* @__PURE__ */ jsx("div", { className: "message message-assistant", children: /* @__PURE__ */ jsx("div", { className: "message-content", children: /* @__PURE__ */ jsx(ReactMarkdown, { remarkPlugins: [remarkGfm], children: commentMsg.content }) }) });
+    }
+  }
+  const chatMsg = message;
+  if (chatMsg.type === "connected" || chatMsg.type === "system") {
+    return null;
+  }
+  if (chatMsg.type === "user") {
+    return /* @__PURE__ */ jsx("div", { className: "message message-user", children: /* @__PURE__ */ jsx("div", { className: "message-content", children: /* @__PURE__ */ jsx(ReactMarkdown, { remarkPlugins: [remarkGfm], children: chatMsg.message }) }) });
+  }
+  if (chatMsg.type === "assistant") {
+    const content = typeof chatMsg.message === "string" ? chatMsg.message : ((_c = (_b = (_a = chatMsg.message) == null ? void 0 : _a.content) == null ? void 0 : _b[0]) == null ? void 0 : _c.text) || "";
+    if (!content.trim()) return null;
+    return /* @__PURE__ */ jsx("div", { className: "message message-assistant", children: /* @__PURE__ */ jsx("div", { className: "message-content", children: /* @__PURE__ */ jsx(ReactMarkdown, { remarkPlugins: [remarkGfm], children: content }) }) });
+  }
+  if (chatMsg.type === "error") {
+    return /* @__PURE__ */ jsx("div", { className: "message message-error", children: /* @__PURE__ */ jsxs("div", { className: "message-content", children: [
+      /* @__PURE__ */ jsx("strong", { children: "Error:" }),
+      " ",
+      chatMsg.error
+    ] }) });
+  }
+  return null;
+}
+function groupStepsIntoPhases(steps) {
+  const phases = [];
+  let currentPhase = null;
+  for (const step of steps) {
+    if (step.type === "status" || step.type === "completion") {
+      if (currentPhase) {
+        phases.push(currentPhase);
+      }
+      currentPhase = {
+        statusStep: step,
+        toolSteps: []
+      };
+    } else if (step.type === "tool") {
+      if (!currentPhase) {
+        currentPhase = {
+          toolSteps: []
+        };
+      }
+      currentPhase.toolSteps.push(step);
+    }
+  }
+  if (currentPhase) {
+    phases.push(currentPhase);
+  }
+  return phases;
+}
+function PhaseItem({
+  phase,
+  isStreaming
+}) {
+  var _a, _b;
+  const hasTools = phase.toolSteps.length > 0;
+  const allToolsComplete = phase.toolSteps.length === 0 || phase.toolSteps.every((t) => t.isComplete);
+  const phaseIsComplete = allToolsComplete && (!phase.statusStep || phase.statusStep.isComplete);
+  const isActive = !phaseIsComplete && isStreaming && (((_a = phase.statusStep) == null ? void 0 : _a.isLast) || hasTools);
+  const hasIncompleteTools = phase.toolSteps.some((step) => !step.isComplete);
+  const shouldAutoExpand = isActive || hasIncompleteTools && isStreaming;
+  const [isToolsExpanded, setIsToolsExpanded] = useState(false);
+  const [wasManuallyExpanded, setWasManuallyExpanded] = useState(false);
+  const [secondsElapsed, setSecondsElapsed] = useState(0);
+  useEffect(() => {
+    if (shouldAutoExpand) {
+      setIsToolsExpanded(true);
+    } else if (!wasManuallyExpanded) {
+      setIsToolsExpanded(false);
+    }
+  }, [shouldAutoExpand, wasManuallyExpanded]);
+  useEffect(() => {
+    var _a2;
+    if (!isActive) {
+      setSecondsElapsed(0);
+      return;
+    }
+    console.log("[PhaseItem] Starting timer for phase:", (_a2 = phase.statusStep) == null ? void 0 : _a2.text);
+    const startTime = Date.now();
+    const interval = setInterval(() => {
+      var _a3;
+      const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+      setSecondsElapsed(elapsed);
+      if (elapsed % 5 === 0) {
+        console.log("[PhaseItem] Timer update:", (_a3 = phase.statusStep) == null ? void 0 : _a3.text, elapsed + "s");
+      }
+    }, 1e3);
+    return () => {
+      var _a3;
+      console.log("[PhaseItem] Stopping timer for phase:", (_a3 = phase.statusStep) == null ? void 0 : _a3.text);
+      clearInterval(interval);
+    };
+  }, [isActive, (_b = phase.statusStep) == null ? void 0 : _b.text]);
+  const showElapsedTime = isActive && secondsElapsed >= 3;
+  return /* @__PURE__ */ jsxs("div", { className: "phase-item", children: [
+    phase.statusStep && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: `task-step ${phase.statusStep.type} ${phaseIsComplete ? "complete" : "pending"} ${isActive ? "current" : ""} ${hasTools ? "has-dropdown" : ""}`,
+        onClick: hasTools ? () => {
+          setIsToolsExpanded(!isToolsExpanded);
+          setWasManuallyExpanded(true);
+        } : void 0,
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "task-step-indicator", children: phaseIsComplete ? /* @__PURE__ */ jsx("span", { className: "task-checkmark", children: "✓" }) : /* @__PURE__ */ jsx("span", { className: "task-spinner" }) }),
+          /* @__PURE__ */ jsxs("span", { className: "task-step-text", children: [
+            phase.statusStep.isThinkingPlaceholder ? "Thinking..." : phase.statusStep.text || "",
+            phase.statusStep.target && /* @__PURE__ */ jsxs("span", { className: "task-step-target", children: [
+              " ",
+              phase.statusStep.target
+            ] }),
+            showElapsedTime && /* @__PURE__ */ jsxs("span", { className: "task-step-elapsed", children: [
+              " (",
+              secondsElapsed,
+              "s)"
+            ] })
+          ] }),
+          hasTools && /* @__PURE__ */ jsx("span", { className: "task-step-dropdown-icon", children: isToolsExpanded ? "▼" : "▶" })
+        ]
+      }
+    ),
+    isToolsExpanded && /* @__PURE__ */ jsxs("div", { className: "task-step-details", children: [
+      hasTools === false && isActive && phase.statusStep && !phase.statusStep.isThinkingPlaceholder && /* @__PURE__ */ jsxs("div", { className: "task-step-detail executing", children: [
+        /* @__PURE__ */ jsx("div", { className: "task-step-indicator", children: /* @__PURE__ */ jsx("span", { className: "task-spinner" }) }),
+        /* @__PURE__ */ jsx("span", { className: "task-step-text", children: "Thinking..." })
+      ] }),
+      phase.toolSteps.map((step, index) => /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: `task-step-detail ${step.isComplete ? "complete" : "executing"}`,
+          children: [
+            /* @__PURE__ */ jsx("div", { className: "task-step-indicator", children: step.isComplete ? /* @__PURE__ */ jsx("span", { className: "task-checkmark", children: "✓" }) : /* @__PURE__ */ jsx("span", { className: "task-spinner" }) }),
+            /* @__PURE__ */ jsxs("span", { className: "task-step-text", children: [
+              step.text || "",
+              step.target && /* @__PURE__ */ jsxs("span", { className: "task-step-target", children: [
+                " ",
+                step.target
+              ] })
+            ] })
+          ]
+        },
+        index
+      ))
+    ] })
+  ] });
+}
+function TaskBlock({ userMessage, steps, isStreaming }) {
+  let userContent = "";
+  if (userMessage) {
+    if ("role" in userMessage) {
+      userContent = userMessage.content;
+    } else {
+      const chatMsg = userMessage;
+      if (chatMsg.type === "user") {
+        userContent = chatMsg.message;
+      }
+    }
+  }
+  const phases = groupStepsIntoPhases(steps);
+  return /* @__PURE__ */ jsxs("div", { className: "task-block", children: [
+    userContent && /* @__PURE__ */ jsxs("div", { className: "task-block-header", children: [
+      /* @__PURE__ */ jsx("div", { className: "task-block-title", children: /* @__PURE__ */ jsx(ReactMarkdown, { remarkPlugins: [remarkGfm], children: userContent }) }),
+      /* @__PURE__ */ jsx("button", { className: "task-block-undo", title: "Undo this task", children: "↶" })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "task-block-steps", children: phases.map((phase, index) => /* @__PURE__ */ jsx(PhaseItem, { phase, isStreaming }, index)) })
+  ] });
+}
+function isCompletionMessage(content) {
+  if (!content) return false;
+  const trimmed = content.trim().toLowerCase();
+  return trimmed.startsWith("done.") || trimmed.startsWith("complete.") || trimmed.startsWith("finished.");
+}
+function isStatusMessage(content) {
+  if (!content) return false;
+  const trimmed = content.trim();
+  if (isCompletionMessage(trimmed)) {
+    return true;
+  }
+  if (trimmed.length < 100) {
+    const actionStarters = [
+      "searching",
+      "reading",
+      "writing",
+      "editing",
+      "looking",
+      "finding",
+      "checking",
+      "analyzing",
+      "processing",
+      "updating",
+      "creating",
+      "modifying",
+      "changing",
+      "applying",
+      "converting",
+      "transforming"
+    ];
+    const lowerContent = trimmed.toLowerCase();
+    if (actionStarters.some((starter) => lowerContent.startsWith(starter))) {
+      return true;
+    }
+  }
+  return false;
+}
+function groupMessages(messages, options) {
+  var _a, _b, _c, _d;
+  const groups = [];
+  let currentTaskBlock = { steps: [] };
+  const { isStreaming = false } = options || {};
+  const flushTaskBlock = () => {
+    if (currentTaskBlock.userMessage || currentTaskBlock.steps.length > 0) {
+      groups.push({
+        type: "task-block",
+        userMessage: currentTaskBlock.userMessage,
+        messages: currentTaskBlock.steps
+      });
+      currentTaskBlock = { steps: [] };
+    }
+  };
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const isLastMessage = i === messages.length - 1;
+    if ("role" in msg) {
+      if (msg.role === "user") {
+        flushTaskBlock();
+        currentTaskBlock.userMessage = msg;
+      } else if (msg.role === "assistant") {
+        if (isStatusMessage(msg.content)) {
+          currentTaskBlock.steps.push(msg);
+        } else {
+          flushTaskBlock();
+          groups.push({ type: "assistant", messages: [msg] });
+        }
+      }
+      continue;
+    }
+    const chatMsg = msg;
+    if (chatMsg.type === "user") {
+      flushTaskBlock();
+      currentTaskBlock.userMessage = msg;
+    } else if (chatMsg.type === "error") {
+      flushTaskBlock();
+      groups.push({ type: "error", messages: [msg] });
+    } else if (chatMsg.type === "assistant") {
+      const content = typeof chatMsg.message === "string" ? chatMsg.message : ((_c = (_b = (_a = chatMsg.message) == null ? void 0 : _a.content) == null ? void 0 : _b[0]) == null ? void 0 : _c.text) || "";
+      const contentBlocks = ((_d = chatMsg.message) == null ? void 0 : _d.content) || [];
+      const hasToolUse = contentBlocks.some((block) => block.type === "tool_use");
+      const shouldBeInTaskBlock = isStatusMessage(content) || hasToolUse || isStreaming && isLastMessage;
+      if (shouldBeInTaskBlock) {
+        currentTaskBlock.steps.push(msg);
+      } else if (content.trim()) {
+        flushTaskBlock();
+        groups.push({ type: "assistant", messages: [msg] });
+      }
+    } else if (chatMsg.type === "tool_use" || chatMsg.type === "tool_result" || chatMsg.type === "result" || chatMsg.type === "done") {
+      currentTaskBlock.steps.push(msg);
+    }
+  }
+  flushTaskBlock();
+  return groups;
+}
+function convertToTaskSteps(messages, isStreaming, startedToolIds = /* @__PURE__ */ new Set(), completedToolIds = /* @__PURE__ */ new Set()) {
+  var _a;
+  const steps = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if ("role" in msg) {
+      if (msg.role === "assistant" && msg.content) {
+        const isCompletion = isCompletionMessage(msg.content);
+        steps.push({
+          type: isCompletion ? "completion" : "status",
+          text: msg.content,
+          isComplete: false,
+          // Will be set later
+          isLast: false
+        });
+      }
+      continue;
+    }
+    const chatMsg = msg;
+    if (chatMsg.type === "assistant") {
+      const contentBlocks = ((_a = chatMsg.message) == null ? void 0 : _a.content) || [];
+      for (const block of contentBlocks) {
+        if (block.type === "text") {
+          const text = block.text || "";
+          if (text && text.trim()) {
+            const isCompletion = isCompletionMessage(text);
+            steps.push({
+              type: isCompletion ? "completion" : "status",
+              text,
+              isComplete: false,
+              // Will be set later
+              isLast: false
+            });
+          }
+        }
+        if (block.type === "tool_use") {
+          const toolDescriptions = {
+            Read: "Reading",
+            Write: "Writing",
+            Edit: "Editing",
+            Glob: "Searching",
+            Grep: "Searching",
+            Bash: "Running",
+            Task: "Running task"
+          };
+          const action = toolDescriptions[block.name] || block.name;
+          let target = "";
+          const input = block.input || {};
+          if (block.name === "Task") {
+            target = input.description || (input.prompt ? input.prompt.split("\n")[0].substring(0, 50) : "");
+          } else if (input.file_path) {
+            const fileName = input.file_path.split("/").pop() || input.file_path;
+            target = fileName;
+          } else if (input.pattern) {
+            target = `"${input.pattern}"`;
+          } else if (input.command) {
+            target = input.command.split(" ")[0];
+          }
+          steps.push({
+            type: "tool",
+            text: action,
+            tool: block.name,
+            target,
+            toolId: block.id,
+            isComplete: false,
+            // Will be set later
+            isLast: false
+          });
+        }
+      }
+    } else if (chatMsg.type === "tool_use") {
+      const toolDescriptions = {
+        read_file: "Reading file",
+        write_file: "Writing file",
+        edit_file: "Editing file",
+        search_files: "Searching files",
+        list_files: "Listing files",
+        run_command: "Running command"
+      };
+      const description = toolDescriptions[chatMsg.tool] || `Running ${chatMsg.tool}`;
+      steps.push({
+        type: "tool",
+        text: description,
+        tool: chatMsg.tool,
+        isComplete: false,
+        // Will be set later
+        isLast: false
+      });
+    } else if (chatMsg.type === "result") {
+      if (chatMsg.result && chatMsg.result.trim()) {
+        steps.push({
+          type: "status",
+          text: chatMsg.result,
+          isComplete: true,
+          isLast: false
+        });
+      }
+    }
+  }
+  if (steps.length > 0) {
+    const lastStepIndex = steps.length - 1;
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      const isLastStep = i === lastStepIndex;
+      step.isLast = isLastStep;
+      if (step.type === "tool") {
+        const toolId = step.toolId;
+        if (toolId) {
+          const hasCompleted = completedToolIds.has(toolId);
+          const hasStarted = startedToolIds.has(toolId);
+          if (!hasCompleted && !isStreaming) {
+            console.warn(`[MessageList] Tool ${toolId} (${step.text}) not in completedToolIds after streaming ended`, {
+              completedToolIds: Array.from(completedToolIds),
+              startedToolIds: Array.from(startedToolIds)
+            });
+          }
+          step.isComplete = !isStreaming || hasCompleted;
+          step.isExecuting = isStreaming && hasStarted && !hasCompleted;
+          step.isQueued = isStreaming && !hasStarted && !hasCompleted;
+        } else {
+          step.isComplete = true;
+          step.isExecuting = false;
+          step.isQueued = false;
+        }
+      } else if (step.type === "status") {
+        step.isComplete = !isStreaming || !isLastStep;
+      } else if (step.type === "completion") {
+        step.isComplete = true;
+      }
+    }
+  }
+  return steps;
+}
+function MessageList({
+  messages,
+  isStreaming,
+  startedToolIds = /* @__PURE__ */ new Set(),
+  completedToolIds = /* @__PURE__ */ new Set(),
+  todos = []
+}) {
+  const messagesEndRef = useRef(null);
+  const groups = useMemo(() => groupMessages(messages, { isStreaming }), [messages, isStreaming]);
+  useEffect(() => {
+    if (messagesEndRef.current) {
+      messagesEndRef.current.scrollIntoView({ behavior: "smooth" });
+    }
+  }, [messages]);
+  if (messages.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "message-list-empty" });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "message-list", children: [
+    todos.length > 0 && /* @__PURE__ */ jsxs("div", { className: "todo-list", children: [
+      /* @__PURE__ */ jsx("div", { className: "todo-list-header", children: "Tasks" }),
+      todos.map((todo, idx) => /* @__PURE__ */ jsxs("div", { className: `todo-item todo-${todo.status}`, children: [
+        /* @__PURE__ */ jsx("div", { className: "todo-indicator", children: todo.status === "completed" ? /* @__PURE__ */ jsx("span", { className: "todo-checkmark", children: "✓" }) : todo.status === "in_progress" ? /* @__PURE__ */ jsx("span", { className: "todo-spinner" }) : /* @__PURE__ */ jsx("span", { className: "todo-pending", children: "○" }) }),
+        /* @__PURE__ */ jsx("span", { className: "todo-text", children: todo.status === "in_progress" ? todo.activeForm : todo.content })
+      ] }, idx))
+    ] }),
+    groups.map((group, groupIndex) => {
+      const isLastGroup = groupIndex === groups.length - 1;
+      if (group.type === "assistant" || group.type === "error") {
+        return /* @__PURE__ */ jsx(MessageItem, { message: group.messages[0] }, groupIndex);
+      }
+      if (group.type === "task-block") {
+        const steps = convertToTaskSteps(
+          group.messages,
+          !!(isStreaming && isLastGroup),
+          startedToolIds,
+          completedToolIds
+        );
+        const allStepsComplete = steps.length === 0 || steps.every((step) => step.isComplete);
+        const shouldShowThinking = isStreaming && isLastGroup && allStepsComplete;
+        const displaySteps = shouldShowThinking ? [
+          ...steps,
+          {
+            type: "status",
+            isComplete: false,
+            isLast: true,
+            isThinkingPlaceholder: true
+          }
+        ] : steps;
+        return /* @__PURE__ */ jsx(
+          TaskBlock,
+          {
+            userMessage: group.userMessage,
+            steps: displaySteps,
+            isStreaming: !!(isStreaming && isLastGroup)
+          },
+          groupIndex
+        );
+      }
+      return null;
+    }),
+    /* @__PURE__ */ jsx("div", { ref: messagesEndRef })
+  ] });
+}
+function getServiceUrl() {
+  var _a, _b;
+  if (typeof window !== "undefined" && ((_a = window.env) == null ? void 0 : _a.NEXT_PUBLIC_AI_EDITOR_SERVICE_URL)) {
+    return window.env.NEXT_PUBLIC_AI_EDITOR_SERVICE_URL;
+  }
+  if (typeof process !== "undefined" && ((_b = process.env) == null ? void 0 : _b.NEXT_PUBLIC_AI_EDITOR_SERVICE_URL)) {
+    return process.env.NEXT_PUBLIC_AI_EDITOR_SERVICE_URL;
+  }
+  return "http://localhost:3456";
+}
+function buildServiceUrl(path) {
+  const baseUrl = getServiceUrl();
+  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+  return `${baseUrl}/${normalizedPath}`;
+}
+function useChatStream(options) {
+  const { threadId, sessionId: initialSessionId, onMessage, onError, onDone } = options;
+  const [state, setState] = useState({
+    messages: [],
+    isConnected: false,
+    isStreaming: false,
+    error: null,
+    sessionId: initialSessionId || null
+  });
+  const wsRef = useRef(null);
+  const [startedToolIds, setStartedToolIds] = useState(/* @__PURE__ */ new Set());
+  const [completedToolIds, setCompletedToolIds] = useState(/* @__PURE__ */ new Set());
+  const [todos, setTodos] = useState([]);
+  const parseEventData = useCallback((data) => {
+    try {
+      return JSON.parse(data);
+    } catch (error) {
+      console.error("Failed to parse SSE data:", data, error);
+      return null;
+    }
+  }, []);
+  const sendMessage = useCallback(
+    async (message, componentContext) => {
+      if (wsRef.current) {
+        wsRef.current.close();
+        wsRef.current = null;
+      }
+      const userMessage = { type: "user", message };
+      setState((prev) => ({
+        ...prev,
+        messages: [...prev.messages, userMessage],
+        isStreaming: true,
+        error: null
+      }));
+      try {
+        const wsUrl = buildServiceUrl("ws/chat").replace(/^http/, "ws");
+        const ws = new WebSocket(wsUrl);
+        wsRef.current = ws;
+        let currentAssistantMessage = null;
+        ws.onopen = () => {
+          console.log("[WebSocket] Connected");
+          const logToServer = (level, ...args) => {
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+            const logMessage = args.map(
+              (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+            ).join(" ");
+            ws.send(JSON.stringify({
+              type: "client_log",
+              level,
+              timestamp,
+              message: logMessage
+            }));
+            console[level](`[${timestamp}]`, ...args);
+          };
+          ws.logToServer = logToServer;
+          ws.send(
+            JSON.stringify({
+              type: "chat",
+              threadId,
+              sessionId: state.sessionId,
+              message,
+              componentContext
+            })
+          );
+        };
+        ws.onmessage = (event) => {
+          var _a, _b;
+          const data = parseEventData(event.data);
+          if (!data) return;
+          if (ws.logToServer) {
+            ws.logToServer("log", `[useChatStream] Received event: ${data.type}`);
+          }
+          if (data.type === "assistant") {
+            const content = ((_a = data.message) == null ? void 0 : _a.content) || [];
+            for (const block of content) {
+              if (block.type === "tool_use" && block.name === "TodoWrite") {
+                const todosData = ((_b = block.input) == null ? void 0 : _b.todos) || [];
+                setTodos(todosData);
+              }
+            }
+            if (currentAssistantMessage) {
+              setState((prev) => {
+                var _a2, _b2, _c;
+                const messages = [...prev.messages];
+                const lastIndex = messages.length - 1;
+                if (((_a2 = messages[lastIndex]) == null ? void 0 : _a2.type) === "assistant") {
+                  const existingContent = ((_b2 = messages[lastIndex].message) == null ? void 0 : _b2.content) || [];
+                  const newContent = ((_c = data.message) == null ? void 0 : _c.content) || [];
+                  messages[lastIndex] = {
+                    ...messages[lastIndex],
+                    message: {
+                      ...messages[lastIndex].message,
+                      content: [...existingContent, ...newContent]
+                    }
+                  };
+                }
+                return { ...prev, messages };
+              });
+            } else {
+              currentAssistantMessage = data;
+              setState((prev) => ({
+                ...prev,
+                messages: [...prev.messages, data]
+              }));
+            }
+            onMessage == null ? void 0 : onMessage(data);
+            return;
+          }
+          currentAssistantMessage = null;
+          if (data.type === "tool_start") {
+            const toolId = data.toolId;
+            if (toolId) {
+              if (ws.logToServer) {
+                ws.logToServer("log", `[CLIENT] Tool STARTED: ${data.toolName} (${toolId})`);
+              }
+              setStartedToolIds((prev) => new Set(prev).add(toolId));
+            }
+            return;
+          }
+          if (data.type === "tool_complete") {
+            const toolId = data.toolId;
+            if (toolId) {
+              if (ws.logToServer) {
+                ws.logToServer("log", `[CLIENT] Tool COMPLETED: ${data.toolName} (${toolId})`);
+              }
+              flushSync(() => {
+                setCompletedToolIds((prev) => new Set(prev).add(toolId));
+              });
+            }
+            return;
+          }
+          if (data.type === "user") {
+            return;
+          }
+          if (data.type === "tool_use") {
+            setState((prev) => ({
+              ...prev,
+              messages: [...prev.messages, data]
+            }));
+            onMessage == null ? void 0 : onMessage(data);
+            return;
+          }
+          if (data.type === "result") {
+            setState((prev) => {
+              var _a2, _b2, _c;
+              const lastMsg = prev.messages[prev.messages.length - 1];
+              if ((lastMsg == null ? void 0 : lastMsg.type) === "assistant") {
+                const lastText = ((_c = (_b2 = (_a2 = lastMsg.message) == null ? void 0 : _a2.content) == null ? void 0 : _b2[0]) == null ? void 0 : _c.text) || "";
+                const resultText = data.result || "";
+                if (lastText.includes(resultText) || resultText.includes(lastText)) {
+                  return prev;
+                }
+              }
+              return {
+                ...prev,
+                messages: [...prev.messages, data]
+              };
+            });
+            onMessage == null ? void 0 : onMessage(data);
+            return;
+          }
+          if (data.type === "connected") {
+            setState((prev) => ({
+              ...prev,
+              sessionId: data.sessionId,
+              isConnected: true
+            }));
+            return;
+          }
+          if (data.type === "done") {
+            setState((prev) => ({
+              ...prev,
+              isStreaming: false,
+              messages: [...prev.messages, data]
+            }));
+            onDone == null ? void 0 : onDone();
+            return;
+          }
+          if (data.type === "error") {
+            setState((prev) => ({
+              ...prev,
+              isStreaming: false,
+              error: data.error,
+              messages: [...prev.messages, data]
+            }));
+            onError == null ? void 0 : onError(data.error);
+            return;
+          }
+          setState((prev) => ({
+            ...prev,
+            messages: [...prev.messages, data]
+          }));
+          onMessage == null ? void 0 : onMessage(data);
+        };
+        ws.onerror = (error) => {
+          console.error("[WebSocket] Error:", error);
+          setState((prev) => ({
+            ...prev,
+            isStreaming: false,
+            error: "WebSocket connection error"
+          }));
+          onError == null ? void 0 : onError("WebSocket connection error");
+        };
+        ws.onclose = () => {
+          console.log("[WebSocket] Disconnected");
+          setState((prev) => ({
+            ...prev,
+            isStreaming: false
+          }));
+        };
+      } catch (error) {
+        const errorMessage = error.message || "Failed to send message";
+        setState((prev) => ({
+          ...prev,
+          isStreaming: false,
+          error: errorMessage
+        }));
+        onError == null ? void 0 : onError(errorMessage);
+      }
+    },
+    [threadId, state.sessionId, parseEventData, onMessage, onError, onDone]
+  );
+  useEffect(() => {
+    return () => {
+      if (wsRef.current) {
+        wsRef.current.close();
+      }
+    };
+  }, []);
+  return {
+    ...state,
+    sendMessage,
+    startedToolIds,
+    completedToolIds,
+    todos
+  };
+}
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+const toCamelCase = (string) => string.replace(
+  /^([A-Z])|[\s-_]+(\w)/g,
+  (match, p1, p2) => p2 ? p2.toUpperCase() : p1.toLowerCase()
+);
+const toPascalCase = (string) => {
+  const camelCase = toCamelCase(string);
+  return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+};
+const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+  return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+}).join(" ").trim();
+const hasA11yProp = (props) => {
+  for (const prop in props) {
+    if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+      return true;
+    }
+  }
+};
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Icon = forwardRef(
+  ({
+    color = "currentColor",
+    size = 24,
+    strokeWidth = 2,
+    absoluteStrokeWidth,
+    className = "",
+    children,
+    iconNode,
+    ...rest
+  }, ref) => createElement(
+    "svg",
+    {
+      ref,
+      ...defaultAttributes,
+      width: size,
+      height: size,
+      stroke: color,
+      strokeWidth: absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth,
+      className: mergeClasses("lucide", className),
+      ...!children && !hasA11yProp(rest) && { "aria-hidden": "true" },
+      ...rest
+    },
+    [
+      ...iconNode.map(([tag, attrs]) => createElement(tag, attrs)),
+      ...Array.isArray(children) ? children : [children]
+    ]
+  )
+);
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const createLucideIcon = (iconName, iconNode) => {
+  const Component = forwardRef(
+    ({ className, ...props }, ref) => createElement(Icon, {
+      ref,
+      iconNode,
+      className: mergeClasses(
+        `lucide-${toKebabCase(toPascalCase(iconName))}`,
+        `lucide-${iconName}`,
+        className
+      ),
+      ...props
+    })
+  );
+  Component.displayName = toPascalCase(iconName);
+  return Component;
+};
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$4 = [
+  [
+    "path",
+    {
+      d: "M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z",
+      key: "hh9hay"
+    }
+  ],
+  ["path", { d: "m3.3 7 8.7 5 8.7-5", key: "g66t2b" }],
+  ["path", { d: "M12 22V12", key: "d0xqtd" }]
+];
+const Box = createLucideIcon("box", __iconNode$4);
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$3 = [
+  [
+    "path",
+    {
+      d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
+      key: "1oefj6"
+    }
+  ],
+  ["path", { d: "M14 2v5a1 1 0 0 0 1 1h5", key: "wfsgrz" }],
+  ["path", { d: "M10 12.5 8 15l2 2.5", key: "1tg20x" }],
+  ["path", { d: "m14 12.5 2 2.5-2 2.5", key: "yinavb" }]
+];
+const FileCode = createLucideIcon("file-code", __iconNode$3);
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$2 = [
+  [
+    "path",
+    {
+      d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",
+      key: "1a8usu"
+    }
+  ],
+  ["path", { d: "m15 5 4 4", key: "1mk7zo" }]
+];
+const Pencil = createLucideIcon("pencil", __iconNode$2);
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode$1 = [
+  ["path", { d: "M12 4v16", key: "1654pz" }],
+  ["path", { d: "M4 7V5a1 1 0 0 1 1-1h14a1 1 0 0 1 1 1v2", key: "e0r10z" }],
+  ["path", { d: "M9 20h6", key: "s66wpe" }]
+];
+const Type = createLucideIcon("type", __iconNode$1);
+/**
+ * @license lucide-react v0.562.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const __iconNode = [
+  ["path", { d: "M18 6 6 18", key: "1bl5f8" }],
+  ["path", { d: "m6 6 12 12", key: "d8bk6v" }]
+];
+const X = createLucideIcon("x", __iconNode);
+function ChatPanel({
+  isExpanded,
+  onToggle,
+  activeTool,
+  onToolChange,
+  attachedContext,
+  onClearContext,
+  theme = "dark"
+}) {
+  const [message, setMessage] = useState("");
+  const [threadId] = useState(() => `thread-${Date.now()}`);
+  const textareaRef = useRef(null);
+  const [contextRanges, setContextRanges] = useState([]);
+  const [isMessagesCollapsed, setMessagesCollapsed] = useState(false);
+  const { messages, isStreaming, sendMessage, startedToolIds, completedToolIds, todos } = useChatStream({
+    threadId
+  });
+  useEffect(() => {
+    if (attachedContext) {
+      setContextRanges((prev) => [...prev, {
+        start: 0,
+        end: 0,
+        context: attachedContext
+      }]);
+      if (textareaRef.current) {
+        textareaRef.current.focus();
+      }
+      onClearContext();
+    }
+  }, [attachedContext, onClearContext]);
+  const handleInput = useCallback((e) => {
+    const target = e.target;
+    setMessage(target.value);
+    target.style.height = "auto";
+    target.style.height = Math.min(target.scrollHeight, 200) + "px";
+  }, []);
+  const handleSend = useCallback(async () => {
+    if (!message.trim() || isStreaming) return;
+    const messageText = message;
+    const componentContext = contextRanges.length > 0 && contextRanges[0].context.type === "component" ? contextRanges[0].context.data : void 0;
+    setMessage("");
+    setContextRanges([]);
+    if (textareaRef.current) {
+      textareaRef.current.style.height = "auto";
+    }
+    await sendMessage(messageText, componentContext);
+  }, [message, isStreaming, contextRanges, sendMessage]);
+  const handleKeyDown = useCallback((e) => {
+    if ((e.ctrlKey || e.metaKey) && e.key === "Enter") {
+      e.preventDefault();
+      handleSend();
+    }
+    if (e.key === "Escape") {
+      e.preventDefault();
+      onToggle();
+    }
+  }, [handleSend, onToggle]);
+  const commentMessages = messages;
+  const visibleCount = useMemo(() => {
+    var _a, _b, _c, _d;
+    let count = 0;
+    let hasUserMessage = false;
+    for (const msg of commentMessages) {
+      if ("role" in msg) {
+        if (msg.role === "user") {
+          if (hasUserMessage) {
+            count++;
+          }
+          hasUserMessage = true;
+        } else if (msg.role === "assistant" && !hasUserMessage) {
+          if ((_a = msg.content) == null ? void 0 : _a.trim()) count++;
+        }
+        continue;
+      }
+      const chatMsg = msg;
+      if (chatMsg.type === "user") {
+        if (hasUserMessage) {
+          count++;
+        }
+        hasUserMessage = true;
+      } else if (chatMsg.type === "error") {
+        if (hasUserMessage) {
+          count++;
+          hasUserMessage = false;
+        }
+        count++;
+      } else if (chatMsg.type === "assistant") {
+        const content = typeof chatMsg.message === "string" ? chatMsg.message : ((_d = (_c = (_b = chatMsg.message) == null ? void 0 : _b.content) == null ? void 0 : _c[0]) == null ? void 0 : _d.text) || "";
+        const isStatus = content && content.trim().length < 80 && (content.endsWith(".") || content.endsWith("..."));
+        if (!isStatus && content.trim() && !hasUserMessage) {
+          count++;
+        }
+      }
+    }
+    if (hasUserMessage) {
+      count++;
+    }
+    return count;
+  }, [commentMessages]);
+  if (!isExpanded) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs("div", { className: `chat-panel ai-editor-ui ${theme} ${commentMessages.length === 0 ? "empty" : ""}`, children: [
+    commentMessages.length > 0 && /* @__PURE__ */ jsxs("div", { className: `chat-panel-messages-container ${isMessagesCollapsed ? "collapsed" : "expanded"}`, children: [
+      /* @__PURE__ */ jsx("div", { className: "chat-panel-messages-header", children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "chat-panel-messages-header-left",
+          onClick: () => setMessagesCollapsed(!isMessagesCollapsed),
+          children: [
+            /* @__PURE__ */ jsxs("span", { className: "chat-panel-messages-title", children: [
+              visibleCount,
+              " task",
+              visibleCount !== 1 ? "s" : ""
+            ] }),
+            /* @__PURE__ */ jsx("span", { className: "chat-panel-messages-toggle", children: "▼" })
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsx("div", { className: "chat-panel-messages", children: /* @__PURE__ */ jsx(
+        MessageList,
+        {
+          messages: commentMessages,
+          isStreaming,
+          startedToolIds,
+          completedToolIds,
+          todos
+        }
+      ) })
+    ] }),
+    commentMessages.length === 0 && /* @__PURE__ */ jsx("div", { className: "chat-panel-empty-content", children: /* @__PURE__ */ jsx(
+      MessageList,
+      {
+        messages: [],
+        isStreaming: false,
+        startedToolIds: /* @__PURE__ */ new Set(),
+        completedToolIds: /* @__PURE__ */ new Set(),
+        todos: []
+      }
+    ) }),
+    /* @__PURE__ */ jsxs("div", { className: "chat-panel-input", children: [
+      contextRanges.length > 0 && /* @__PURE__ */ jsx("div", { className: "context-pills-container", children: contextRanges.map((range, idx) => /* @__PURE__ */ jsxs("div", { className: "context-pill-inline", children: [
+        /* @__PURE__ */ jsx("span", { children: range.context.displayText }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "context-pill-remove",
+            onClick: () => {
+              setContextRanges((prev) => prev.filter((_, i) => i !== idx));
+            },
+            title: "Remove context",
+            children: "×"
+          }
+        )
+      ] }, idx)) }),
+      /* @__PURE__ */ jsxs("div", { className: "input-row", children: [
+        /* @__PURE__ */ jsx(
+          "textarea",
+          {
+            ref: textareaRef,
+            className: "message-input",
+            placeholder: "Ask Claude to edit your code...",
+            value: message,
+            onChange: handleInput,
+            onKeyDown: handleKeyDown,
+            disabled: isStreaming,
+            rows: 1
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "send-button",
+            onClick: handleSend,
+            disabled: !message.trim() || isStreaming,
+            children: "↑"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "chat-panel-toolbar", children: [
+        /* @__PURE__ */ jsxs("div", { className: "chat-panel-tools", children: [
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: `tool-button ${activeTool === "component" ? "active" : ""}`,
+              onClick: () => onToolChange(activeTool === "component" ? null : "component"),
+              title: "Select Component",
+              children: /* @__PURE__ */ jsx(FileCode, { size: 16 })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: `tool-button ${activeTool === "area" ? "active" : ""}`,
+              onClick: () => onToolChange(activeTool === "area" ? null : "area"),
+              title: "Select Area",
+              children: /* @__PURE__ */ jsx(Box, { size: 16 })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: `tool-button ${activeTool === "text" ? "active" : ""}`,
+              onClick: () => onToolChange(activeTool === "text" ? null : "text"),
+              title: "Select Text",
+              children: /* @__PURE__ */ jsx(Type, { size: 16 })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "close-button",
+            onClick: onToggle,
+            title: "Close (Esc)",
+            children: /* @__PURE__ */ jsx(X, { size: 16 })
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+function ControlPill({
+  isExpanded,
+  onToggle,
+  activeTool
+}) {
+  useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
+        return;
+      }
+      if (e.key === " " || e.key === "/") {
+        e.preventDefault();
+        onToggle();
+      }
+      if (e.key === "Escape" && isExpanded) {
+        e.preventDefault();
+        onToggle();
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [onToggle, isExpanded]);
+  if (isExpanded) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "control-pill ai-editor-ui", onClick: onToggle, children: [
+    /* @__PURE__ */ jsxs("div", { className: "control-pill-inner", children: [
+      /* @__PURE__ */ jsx(Pencil, { size: 16, className: "pill-icon" }),
+      /* @__PURE__ */ jsx("span", { className: "pill-label", children: "Edit" }),
+      activeTool && /* @__PURE__ */ jsxs("span", { className: "active-tool-indicator", title: `${activeTool} tool active`, children: [
+        activeTool === "component" && "🎯",
+        activeTool === "area" && "⬛",
+        activeTool === "text" && "📝"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "control-pill-hint", children: [
+      "Press ",
+      /* @__PURE__ */ jsx("kbd", { children: "Space" }),
+      " or ",
+      /* @__PURE__ */ jsx("kbd", { children: "/" }),
+      " to toggle"
+    ] })
+  ] });
+}
+const sourceResolutionCache = /* @__PURE__ */ new Map();
+const inflightSourceResolutions = /* @__PURE__ */ new Map();
+function inferComponentNameFromPath(filePath) {
+  const fileName = filePath.split("/").pop() || "";
+  const nameWithoutExt = fileName.replace(/\.(tsx?|jsx?)$/, "");
+  return nameWithoutExt.charAt(0).toUpperCase() + nameWithoutExt.slice(1);
+}
+async function resolveSourceLocation(source) {
+  if (typeof window === "undefined" || process.env.NODE_ENV !== "development") {
+    return null;
+  }
+  if (!source.debugStack) {
+    console.warn("No debugStack available for resolution:", source);
+    return null;
+  }
+  const cacheKey = source.debugStack;
+  const cached = sourceResolutionCache.get(cacheKey);
+  if (cached) {
+    const resolved2 = { ...source, ...cached };
+    if (resolved2.componentName === "Unknown" && resolved2.filePath) {
+      resolved2.componentName = inferComponentNameFromPath(resolved2.filePath);
+    }
+    return resolved2;
+  }
+  let inflight = inflightSourceResolutions.get(cacheKey);
+  if (!inflight) {
+    inflight = fetch(buildServiceUrl("api/resolve"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ debugStack: cacheKey })
+    }).then(async (res) => {
+      if (!res.ok) {
+        console.error(`Resolve API error ${res.status}`);
+        return null;
+      }
+      const data = await res.json();
+      if ((data == null ? void 0 : data.success) && data.filePath && data.lineNumber) {
+        const resolved2 = {
+          filePath: data.filePath,
+          lineNumber: data.lineNumber,
+          columnNumber: typeof data.columnNumber === "number" ? data.columnNumber : source.columnNumber
+        };
+        sourceResolutionCache.set(cacheKey, resolved2);
+        return resolved2;
+      }
+      return null;
+    }).catch((err) => {
+      console.error("Error calling resolve API:", err);
+      return null;
+    }).finally(() => {
+      inflightSourceResolutions.delete(cacheKey);
+    });
+    inflightSourceResolutions.set(cacheKey, inflight);
+  }
+  const resolvedInfo = await inflight;
+  if (!resolvedInfo) return null;
+  const resolved = {
+    ...source,
+    filePath: resolvedInfo.filePath,
+    lineNumber: resolvedInfo.lineNumber,
+    columnNumber: resolvedInfo.columnNumber
+  };
+  if (resolved.componentName === "Unknown" && resolved.filePath) {
+    resolved.componentName = inferComponentNameFromPath(resolved.filePath);
+  }
+  return resolved;
+}
+const EditorContext = createContext(null);
+function AIEditorProvider({
+  children,
+  theme = "dark",
+  enabled
+}) {
+  const [serverEnabled, setServerEnabled] = useState(null);
+  useEffect(() => {
+    if (enabled !== void 0) return;
+    fetch(buildServiceUrl("api/config")).then((res) => res.json()).then((data) => {
+      setServerEnabled(data.enabled === true);
+    }).catch(() => {
+      setServerEnabled(false);
+    });
+  }, [enabled]);
+  const isEditorEnabled = enabled ?? serverEnabled;
+  const [isEnabled, setEnabled] = useState(false);
+  const [isHistoryOpen, setHistoryOpen] = useState(false);
+  const [isChatExpanded, setChatExpanded] = useState(false);
+  const [activeTool, setActiveTool] = useState(null);
+  const [attachedContext, setAttachedContext] = useState(null);
+  const handleChatToggle = useCallback(() => {
+    setChatExpanded((prev) => !prev);
+  }, []);
+  const handleToolChange = useCallback((tool) => {
+    setActiveTool(tool);
+    if (tool === null) {
+      setAttachedContext(null);
+    }
+  }, []);
+  const handleClearContext = useCallback(() => {
+    setAttachedContext(null);
+    setActiveTool(null);
+  }, []);
+  useEffect(() => {
+    const handleKey = (e) => {
+      if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key.toLowerCase() === "e") {
+        e.preventDefault();
+        setEnabled((p) => !p);
+      }
+      if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key.toLowerCase() === "h") {
+        e.preventDefault();
+        setHistoryOpen((p) => !p);
+      }
+      if (e.key === "Escape" && isHistoryOpen) {
+        e.preventDefault();
+        setHistoryOpen(false);
+      }
+    };
+    window.addEventListener("keydown", handleKey);
+    return () => window.removeEventListener("keydown", handleKey);
+  }, [isHistoryOpen]);
+  if (!isEditorEnabled) {
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsxs(
+    EditorContext.Provider,
+    {
+      value: {
+        isEnabled,
+        setEnabled
+      },
+      children: [
+        children,
+        activeTool === "component" && /* @__PURE__ */ jsx(
+          EditorOverlay,
+          {
+            theme,
+            onComponentSelect: (source, position) => {
+              const contextData = {
+                type: "component",
+                data: source,
+                displayText: `${source.componentName} (${source.filePath}:${source.lineNumber})`
+              };
+              setAttachedContext(contextData);
+              setActiveTool(null);
+              if (!isChatExpanded) {
+                setChatExpanded(true);
+              }
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: `editor-container ai-editor-ui ${isChatExpanded ? "expanded" : "collapsed"} ${theme}`,
+            children: [
+              /* @__PURE__ */ jsx(
+                ChatPanel,
+                {
+                  isExpanded: isChatExpanded,
+                  onToggle: handleChatToggle,
+                  activeTool,
+                  onToolChange: handleToolChange,
+                  attachedContext,
+                  onClearContext: handleClearContext,
+                  theme
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                ControlPill,
+                {
+                  isExpanded: isChatExpanded,
+                  onToggle: handleChatToggle,
+                  activeTool
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          TaskHistoryPanel,
+          {
+            isOpen: isHistoryOpen,
+            onClose: () => setHistoryOpen(false),
+            tasks: []
+          }
+        )
+      ]
+    }
+  );
+}
+function EditorOverlay({ theme, onComponentSelect }) {
+  var _a;
+  const [hoveredSource, setHoveredSource] = useState(
+    null
+  );
+  const [hoveredElement, setHoveredElement] = useState(null);
+  const [hoveredRect, setHoveredRect] = useState(null);
+  const [mousePos, setMousePos] = useState({ x: 0, y: 0 });
+  const [isResolvingSource, setIsResolvingSource] = useState(false);
+  const lastHoverStateRef = useRef(null);
+  useEffect(() => {
+    if (hoveredSource && hoveredElement) {
+      lastHoverStateRef.current = {
+        source: hoveredSource,
+        element: hoveredElement
+      };
+    }
+  }, [hoveredSource, hoveredElement]);
+  const isDark = theme === "dark";
+  const c = {
+    text: isDark ? "#e4e4e7" : "#18181b",
+    muted: isDark ? "#71717a" : "#a1a1aa",
+    accent: "#818cf8",
+    bg: isDark ? "#0d0d14" : "#fff",
+    border: isDark ? "#27273f" : "#e4e4e7",
+    success: "#34d399"
+  };
+  useEffect(() => {
+    let lastEl = null;
+    let raf;
+    const onMove = (e) => {
+      setMousePos({ x: e.clientX, y: e.clientY });
+      cancelAnimationFrame(raf);
+      raf = requestAnimationFrame(() => {
+        const el = document.elementFromPoint(e.clientX, e.clientY);
+        if (!el || el.closest(".ai-editor-ui") || el === lastEl) return;
+        lastEl = el;
+        const source = getSourceFromElement(el);
+        if (source) {
+          setHoveredElement(el);
+          setHoveredRect(el.getBoundingClientRect());
+          const isCompiledPath = source.filePath.includes(".next/") || source.filePath.includes("/chunks/") || source.filePath.startsWith("file://") || source.filePath.endsWith(".js") && (source.filePath.includes("/server/") || source.filePath.includes("/static/"));
+          if (isCompiledPath && source.debugStack) {
+            setIsResolvingSource(true);
+            resolveSourceLocation(source).then((resolved) => {
+              setIsResolvingSource(false);
+              setHoveredSource(resolved || source);
+            }).catch((err) => {
+              console.error("Error resolving source location:", err);
+              setIsResolvingSource(false);
+              setHoveredSource(source);
+            });
+          } else {
+            setIsResolvingSource(false);
+            setHoveredSource(source);
+          }
+        } else {
+          setHoveredSource(null);
+          setHoveredElement(null);
+          setHoveredRect(null);
+          setIsResolvingSource(false);
+        }
+      });
+    };
+    const onClick = async (e) => {
+      if (e.target.closest(".ai-editor-ui")) {
+        return;
+      }
+      const el = e.target;
+      const source = getSourceFromElement(el);
+      if (source) {
+        e.preventDefault();
+        e.stopPropagation();
+        const isCompiledPath = source.filePath.includes(".next/") || source.filePath.includes("/chunks/") || source.filePath.startsWith("file://") || source.filePath.endsWith(".js") && (source.filePath.includes("/server/") || source.filePath.includes("/static/"));
+        if (isCompiledPath && source.debugStack) {
+          const resolved = await resolveSourceLocation(source);
+          onComponentSelect(resolved || source, { x: e.clientX, y: e.clientY });
+        } else {
+          onComponentSelect(source, { x: e.clientX, y: e.clientY });
+        }
+      }
+    };
+    document.addEventListener("mousemove", onMove, { passive: true });
+    document.addEventListener("click", onClick, true);
+    return () => {
+      document.removeEventListener("mousemove", onMove);
+      document.removeEventListener("click", onClick, true);
+      cancelAnimationFrame(raf);
+    };
+  }, [onComponentSelect]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "ai-editor-ui",
+      style: { fontFamily: "system-ui, sans-serif" },
+      children: [
+        hoveredRect && /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              position: "fixed",
+              left: hoveredRect.left - 2,
+              top: hoveredRect.top - 2,
+              width: hoveredRect.width + 4,
+              height: hoveredRect.height + 4,
+              border: `2px solid ${c.accent}`,
+              borderRadius: 6,
+              background: `${c.accent}15`,
+              pointerEvents: "none",
+              zIndex: 99998
+            }
+          }
+        ),
+        hoveredSource && !isResolvingSource && /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              position: "fixed",
+              left: Math.min(mousePos.x + 14, window.innerWidth - 340),
+              top: mousePos.y + 14,
+              background: c.bg,
+              color: c.text,
+              border: `1px solid ${c.border}`,
+              borderRadius: 10,
+              padding: "12px 16px",
+              fontSize: 12,
+              fontFamily: "ui-monospace, monospace",
+              zIndex: 99999,
+              boxShadow: `0 8px 30px rgba(0,0,0,${isDark ? 0.5 : 0.15})`,
+              maxWidth: 320,
+              pointerEvents: "none"
+            },
+            children: [
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    fontWeight: 700,
+                    color: c.accent,
+                    marginBottom: 4,
+                    fontSize: 14
+                  },
+                  children: [
+                    "<",
+                    hoveredSource.componentName,
+                    " />"
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxs("div", { style: { color: c.muted, fontSize: 11 }, children: [
+                hoveredSource.filePath,
+                ":",
+                hoveredSource.lineNumber
+              ] }),
+              ((_a = hoveredSource.elementContext) == null ? void 0 : _a.textContent) && /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    color: c.muted,
+                    fontSize: 10,
+                    marginTop: 4,
+                    fontStyle: "italic"
+                  },
+                  children: [
+                    '"',
+                    hoveredSource.elementContext.textContent,
+                    '"'
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              position: "fixed",
+              bottom: 20,
+              right: 20,
+              background: c.bg,
+              color: c.success,
+              padding: "10px 16px",
+              borderRadius: 20,
+              fontSize: 13,
+              fontWeight: 600,
+              zIndex: 99997,
+              display: "flex",
+              alignItems: "center",
+              gap: 8,
+              border: `1px solid ${c.border}`,
+              boxShadow: `0 4px 20px rgba(0,0,0,${isDark ? 0.4 : 0.1})`
+            },
+            children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  style: {
+                    width: 8,
+                    height: 8,
+                    borderRadius: "50%",
+                    background: c.success
+                  }
+                }
+              ),
+              "Select Component"
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
 export {
-  A as AIEditorProvider,
-  C as ChatPanel,
-  a as ControlPill,
-  j as extractComponentName,
-  t as extractComponentNameFromStack,
-  g as fileExists,
-  l as findTargetElement,
-  o as getAttributeValue,
-  m as getJSXMemberName,
-  x as getOriginalPositionFromDebugStack,
-  h as handleAIEditorRequest,
-  d as handleAbsolutePath,
-  f as handleCommentsRequest,
-  a2 as handleRead,
-  c as handleResolve,
-  b as handleUndo,
-  e as handleValidateSession,
-  i as isPathSecure,
-  n as normalizePath,
-  q as parseDebugStack,
-  u as parseDebugStackFrames,
-  p as parseFile,
-  r as resolveFilePath,
-  w as resolveOriginalPosition,
-  s as scoreElementMatch,
-  v as validateDevMode,
-  k as validateGeneratedCode
+  AIEditorProvider,
+  ChatPanel,
+  ControlPill,
+  buildServiceUrl,
+  getServiceUrl
 };
 //# sourceMappingURL=index.js.map