next-ai-editor 0.2.5 → 1.0.0

package/dist/comments-2HX-AAwu.cjs

@@ -1,1512 +0,0 @@
-"use strict";
-const server = require("next/server");
-const fs = require("fs/promises");
-const path = require("path");
-const sourceMap = require("@jridgewell/source-map");
-const pathUtils = require("./path-utils-DYzEWUGy.cjs");
-const parser = require("@babel/parser");
-const traverse = require("@babel/traverse");
-const t = require("@babel/types");
-const crypto = require("crypto");
-const claudeAgentSdk = require("@anthropic-ai/claude-agent-sdk");
-const fs$1 = require("fs");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const parser__namespace = /* @__PURE__ */ _interopNamespaceDefault(parser);
-const t__namespace = /* @__PURE__ */ _interopNamespaceDefault(t);
-function validateDevMode() {
-  if (process.env.NODE_ENV !== "development") {
-    return server.NextResponse.json(
-      { success: false, error: "Development mode only" },
-      { status: 403 }
-    );
-  }
-  return null;
-}
-function normalizePath(filePath) {
-  return filePath.replace(/^webpack-internal:\/\/\/\([^)]+\)\/\.?/, "").replace(/^webpack:\/\/[^/]*\//, "").replace(/^\.\//, "").replace(/\?.*$/, "");
-}
-async function resolveFilePath(projectRoot, normalizedPath) {
-  const candidates = [
-    path.resolve(projectRoot, normalizedPath),
-    path.resolve(projectRoot, "src", normalizedPath),
-    path.resolve(projectRoot, "app", normalizedPath)
-  ];
-  for (const candidate of candidates) {
-    if (!candidate.startsWith(projectRoot)) continue;
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function isPathSecure(absolutePath, projectRoot) {
-  return absolutePath.startsWith(projectRoot);
-}
-async function fileExists$1(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function parseDebugStack(stack) {
-  if (!stack) return null;
-  const stackStr = typeof stack === "string" ? stack : 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) {
-      let filePath = match[2];
-      const line = parseInt(match[3], 10);
-      const column = parseInt(match[4], 10);
-      let chunkId;
-      const chunkMatch = filePath.match(/\?([^:]+)$/);
-      if (chunkMatch) {
-        chunkId = chunkMatch[1];
-        filePath = filePath.replace(/\?[^:]*$/, "");
-      }
-      filePath = pathUtils.cleanPath(filePath);
-      if (!pathUtils.shouldSkipPath(filePath)) {
-        console.log("parseDebugStack extracted:", { filePath, line, column });
-        return { filePath, line, column, chunkId };
-      }
-    }
-  }
-  console.log(
-    "parseDebugStack: no valid frame found in stack:",
-    stackStr.substring(0, 200)
-  );
-  return null;
-}
-function extractComponentNameFromStack(stack) {
-  if (!stack) return null;
-  const stackStr = typeof stack === "string" ? stack : stack.stack || String(stack);
-  const frames = stackStr.split("\n");
-  const skipPatterns = [
-    "node_modules",
-    "SegmentViewNode",
-    "LayoutRouter",
-    "ErrorBoundary",
-    "fakeJSXCallSite",
-    "react_stack_bottom_frame"
-  ];
-  for (const frame of frames) {
-    if (skipPatterns.some((p) => frame.includes(p))) continue;
-    const match = frame.match(/at\s+(\w+)\s+\(/);
-    if (match && match[1]) {
-      const componentName = match[1];
-      if (componentName !== "Object" && componentName !== "anonymous") {
-        return componentName;
-      }
-    }
-  }
-  return null;
-}
-function parseDebugStackFrames(stack) {
-  if (!stack) return [];
-  const stackStr = typeof stack === "string" ? stack : stack.stack || String(stack);
-  const frames = stackStr.split("\n");
-  const skipPatterns = [
-    "node_modules",
-    "SegmentViewNode",
-    "LayoutRouter",
-    "ErrorBoundary",
-    "fakeJSXCallSite",
-    "react_stack_bottom_frame"
-  ];
-  const positions = [];
-  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) {
-      match[1];
-      let filePath = match[2];
-      const line = parseInt(match[3], 10);
-      const column = parseInt(match[4], 10);
-      let chunkId;
-      const chunkMatch = filePath.match(/\?([^:]+)$/);
-      if (chunkMatch) {
-        chunkId = chunkMatch[1];
-        filePath = filePath.replace(/\?[^:]*$/, "");
-      }
-      filePath = pathUtils.cleanPath(filePath);
-      if (!pathUtils.shouldSkipPath(filePath)) {
-        positions.push({ filePath, line, column, chunkId });
-        if (positions.length >= 2) break;
-      }
-    }
-  }
-  console.log(`parseDebugStackFrames extracted ${positions.length} frames:`, positions);
-  return positions;
-}
-async function resolveOriginalPosition(compiledPos, projectRoot) {
-  try {
-    console.log("resolveOriginalPosition called with:", compiledPos);
-    let compiledFilePath = compiledPos.filePath;
-    compiledFilePath = pathUtils.cleanPath(compiledFilePath);
-    console.log("After cleanPath:", compiledFilePath);
-    if (compiledFilePath.startsWith("http://") || compiledFilePath.startsWith("https://")) {
-      const url = new URL(compiledFilePath);
-      const pathname = url.pathname;
-      if (pathname.startsWith("/_next/")) {
-        const relativePath = pathname.substring("/_next/".length);
-        compiledFilePath = path.join(projectRoot, ".next", "dev", relativePath);
-      } else {
-        console.warn("Unexpected HTTP URL path:", pathname);
-        return null;
-      }
-    } else if (!path.isAbsolute(compiledFilePath)) {
-      if (compiledFilePath.startsWith(".next/")) {
-        compiledFilePath = path.resolve(projectRoot, compiledFilePath);
-      } else {
-        const resolved = path.resolve(projectRoot, compiledFilePath);
-        if (await fileExists(resolved)) {
-          compiledFilePath = resolved;
-        } else {
-          const possiblePaths = [
-            path.join(projectRoot, ".next", "dev", compiledFilePath),
-            path.join(projectRoot, compiledFilePath)
-          ];
-          for (const tryPath of possiblePaths) {
-            if (await fileExists(tryPath)) {
-              compiledFilePath = tryPath;
-              break;
-            }
-          }
-        }
-      }
-    } else {
-      compiledFilePath = path.normalize(compiledFilePath);
-    }
-    console.log("Normalized compiled file path:", compiledFilePath);
-    const compiledExists = await fileExists(compiledFilePath);
-    console.log(
-      "Compiled file exists:",
-      compiledExists,
-      "at:",
-      compiledFilePath
-    );
-    if (!compiledExists) {
-      console.error(
-        `Compiled file not found: ${compiledFilePath} (from parsed: ${compiledPos.filePath})`
-      );
-    }
-    const sourceMapPath = compiledFilePath + ".map";
-    console.log("Looking for source map at:", sourceMapPath);
-    const sourceMapExists = await fileExists(sourceMapPath);
-    console.log("Source map exists:", sourceMapExists);
-    if (!sourceMapExists) {
-      console.error(
-        `Source map not found: ${sourceMapPath} (from compiled: ${compiledPos.filePath}, normalized: ${compiledFilePath})`
-      );
-      const altPaths = [
-        compiledFilePath.replace(/\.js$/, ".map"),
-        path.join(
-          path.dirname(compiledFilePath),
-          path.basename(compiledFilePath) + ".map"
-        )
-      ];
-      console.log("Trying alternative paths:", altPaths);
-      for (const altPath of altPaths) {
-        if (await fileExists(altPath)) {
-          console.log("Found source map at alternative path:", altPath);
-          return await resolveFromSourceMap(altPath, compiledPos, projectRoot);
-        }
-      }
-      return null;
-    }
-    return await resolveFromSourceMap(sourceMapPath, compiledPos, projectRoot);
-  } catch (error) {
-    console.error("Error resolving source map:", error);
-    return null;
-  }
-}
-async function resolveFromSourceMap(sourceMapPath, compiledPos, projectRoot) {
-  try {
-    const sourceMapContent = await fs.readFile(sourceMapPath, "utf-8");
-    const sourceMap$1 = JSON.parse(sourceMapContent);
-    if ((!sourceMap$1.sources || sourceMap$1.sources.length === 0) && (!sourceMap$1.sections || sourceMap$1.sections.length === 0)) {
-      console.warn(
-        "Empty source map detected, cannot resolve position:",
-        sourceMapPath
-      );
-      return null;
-    }
-    if (sourceMap$1.sections) {
-      let matchingSection = null;
-      for (let i = sourceMap$1.sections.length - 1; i >= 0; i--) {
-        const section = sourceMap$1.sections[i];
-        const offset = section.offset;
-        const sectionStartLine1Indexed = offset.line + 1;
-        if (compiledPos.line > sectionStartLine1Indexed || compiledPos.line === sectionStartLine1Indexed && compiledPos.column >= offset.column) {
-          matchingSection = section;
-          break;
-        }
-      }
-      if (matchingSection && matchingSection.map) {
-        const sectionMap = matchingSection.map;
-        const offset = matchingSection.offset;
-        let consumer2;
-        try {
-          consumer2 = await new sourceMap.SourceMapConsumer(sectionMap);
-        } catch (error) {
-          console.error("Error creating SourceMapConsumer:", error);
-          return null;
-        }
-        try {
-          const adjustedLine = compiledPos.line - offset.line;
-          const adjustedColumn = compiledPos.line === offset.line + 1 ? compiledPos.column - offset.column : compiledPos.column;
-          const originalPos = consumer2.originalPositionFor({
-            line: adjustedLine,
-            column: adjustedColumn
-          });
-          if (originalPos.source && originalPos.line !== null) {
-            const source = pathUtils.normalizeSourcePath(
-              originalPos.source || "",
-              projectRoot
-            );
-            return {
-              source,
-              line: originalPos.line,
-              column: originalPos.column ?? 0
-            };
-          }
-        } finally {
-          consumer2.destroy();
-        }
-      }
-      return null;
-    }
-    const consumer = await new sourceMap.SourceMapConsumer(sourceMap$1);
-    try {
-      const originalPos = consumer.originalPositionFor({
-        line: compiledPos.line,
-        column: compiledPos.column
-      });
-      if (originalPos.source && originalPos.line !== null) {
-        const source = pathUtils.normalizeSourcePath(
-          originalPos.source || "",
-          projectRoot
-        );
-        return {
-          source,
-          line: originalPos.line,
-          column: originalPos.column ?? 0
-        };
-      }
-    } finally {
-      consumer.destroy();
-    }
-    return null;
-  } catch (error) {
-    console.error("Error resolving source map:", error);
-    return null;
-  }
-}
-async function fileExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getOriginalPositionFromDebugStack(debugStack, projectRoot) {
-  const compiledPos = parseDebugStack(debugStack);
-  if (!compiledPos) return null;
-  return await resolveOriginalPosition(compiledPos, projectRoot);
-}
-function parseFile(content) {
-  try {
-    return parser__namespace.parse(content, {
-      sourceType: "module",
-      plugins: [
-        "jsx",
-        "typescript",
-        "decorators-legacy",
-        "classProperties",
-        "optionalChaining",
-        "nullishCoalescingOperator"
-      ]
-    });
-  } catch (e) {
-    console.error("Parse error:", e);
-    return null;
-  }
-}
-function extractComponentName(ast) {
-  let componentName = null;
-  traverse(ast, {
-    ExportDefaultDeclaration(path2) {
-      var _a;
-      if (t__namespace.isFunctionDeclaration(path2.node.declaration)) {
-        componentName = ((_a = path2.node.declaration.id) == null ? void 0 : _a.name) || null;
-      } else if (t__namespace.isArrowFunctionExpression(path2.node.declaration)) {
-        componentName = "default";
-      } else if (t__namespace.isIdentifier(path2.node.declaration)) {
-        componentName = path2.node.declaration.name;
-      }
-    },
-    ExportNamedDeclaration(path2) {
-      var _a;
-      if (t__namespace.isFunctionDeclaration(path2.node.declaration)) {
-        componentName = ((_a = path2.node.declaration.id) == null ? void 0 : _a.name) || null;
-      } else if (t__namespace.isVariableDeclaration(path2.node.declaration)) {
-        const declarator = path2.node.declaration.declarations[0];
-        if (t__namespace.isIdentifier(declarator.id)) {
-          componentName = declarator.id.name;
-        }
-      } else if (path2.node.specifiers && path2.node.specifiers.length > 0) {
-        const specifier = path2.node.specifiers[0];
-        if (t__namespace.isExportSpecifier(specifier) && t__namespace.isIdentifier(specifier.exported)) {
-          componentName = specifier.exported.name;
-        }
-      }
-    }
-  });
-  return componentName;
-}
-function validateGeneratedCode(newCode, originalCode, fileContent) {
-  try {
-    const isFullComponent = /^(export\s+)?(default\s+)?function\s+\w+/.test(newCode.trim()) || /^(export\s+)?(default\s+)?const\s+\w+\s*=/.test(newCode.trim());
-    if (isFullComponent) {
-      let codeToValidate = newCode;
-      if (fileContent) {
-        const interfaceMatches = fileContent.match(
-          /^(interface|type)\s+\w+[^}]*\}/gm
-        );
-        if (interfaceMatches) {
-          codeToValidate = interfaceMatches.join("\n\n") + "\n\n" + newCode;
-        }
-      }
-      parser__namespace.parse(codeToValidate, {
-        sourceType: "module",
-        plugins: ["jsx", "typescript"]
-      });
-    } else {
-      const wrapped = `function _() { return (${newCode}); }`;
-      parser__namespace.parse(wrapped, {
-        sourceType: "module",
-        plugins: ["jsx", "typescript"]
-      });
-    }
-  } catch (e) {
-    console.error("Generated code parse error:", e);
-    return false;
-  }
-  const origBraces = (originalCode.match(/[{}]/g) || []).length;
-  const newBraces = (newCode.match(/[{}]/g) || []).length;
-  const origTags = (originalCode.match(/[<>]/g) || []).length;
-  const newTags = (newCode.match(/[<>]/g) || []).length;
-  if (Math.abs(origBraces - newBraces) > 4 || Math.abs(origTags - newTags) > 4) {
-    console.warn(
-      `Structure changed significantly: braces ${origBraces}->${newBraces}, tags ${origTags}->${newTags}`
-    );
-  }
-  return true;
-}
-function findTargetElement(ast, fileContent, options) {
-  const { componentName, lineNumber, elementContext } = options;
-  let componentNode = null;
-  let componentStart = 0;
-  let componentEnd = Infinity;
-  let fallbackExportDefault = null;
-  traverse(ast, {
-    FunctionDeclaration(path2) {
-      var _a, _b, _c;
-      if (((_a = path2.node.id) == null ? void 0 : _a.name) === componentName) {
-        componentNode = path2.node;
-        componentStart = ((_b = path2.node.loc) == null ? void 0 : _b.start.line) || 0;
-        componentEnd = ((_c = path2.node.loc) == null ? void 0 : _c.end.line) || Infinity;
-      }
-    },
-    VariableDeclarator(path2) {
-      var _a, _b;
-      if (t__namespace.isIdentifier(path2.node.id) && path2.node.id.name === componentName) {
-        componentNode = path2.node;
-        const parent = path2.parentPath.parent;
-        componentStart = ((_a = parent == null ? void 0 : parent.loc) == null ? void 0 : _a.start.line) || 0;
-        componentEnd = ((_b = parent == null ? void 0 : parent.loc) == null ? void 0 : _b.end.line) || Infinity;
-      }
-    },
-    ExportDefaultDeclaration(path2) {
-      var _a, _b, _c, _d, _e;
-      if (t__namespace.isFunctionDeclaration(path2.node.declaration)) {
-        const funcName = (_a = path2.node.declaration.id) == null ? void 0 : _a.name;
-        if (funcName === componentName || !funcName) {
-          componentNode = path2.node;
-          componentStart = ((_b = path2.node.loc) == null ? void 0 : _b.start.line) || 0;
-          componentEnd = ((_c = path2.node.loc) == null ? void 0 : _c.end.line) || Infinity;
-        } else if (!componentNode) {
-          fallbackExportDefault = {
-            node: path2.node,
-            start: ((_d = path2.node.loc) == null ? void 0 : _d.start.line) || 0,
-            end: ((_e = path2.node.loc) == null ? void 0 : _e.end.line) || Infinity
-          };
-        }
-      }
-    }
-  });
-  if (!componentNode && fallbackExportDefault !== null) {
-    const fallback = fallbackExportDefault;
-    console.log(
-      `⚠️  Component "${componentName}" not found, using export default function as fallback`
-    );
-    componentNode = fallback.node;
-    componentStart = fallback.start;
-    componentEnd = fallback.end;
-  }
-  const allElementsByTag = /* @__PURE__ */ new Map();
-  const elementsAtLine = [];
-  traverse(ast, {
-    JSXElement(path2) {
-      const loc = path2.node.loc;
-      if (!loc) return;
-      const startLine = loc.start.line;
-      const endLine = loc.end.line;
-      if (startLine < componentStart || endLine > componentEnd) return;
-      const opening = path2.node.openingElement;
-      if (t__namespace.isJSXIdentifier(opening.name)) {
-        const tagName = opening.name.name;
-        if (!allElementsByTag.has(tagName)) {
-          allElementsByTag.set(tagName, []);
-        }
-        allElementsByTag.get(tagName).push({ node: path2.node, startLine, endLine, score: 0 });
-      }
-      if (startLine === lineNumber) {
-        elementsAtLine.push({ node: path2.node, startLine, endLine, score: 0 });
-      }
-    }
-  });
-  if (elementsAtLine.length > 0) {
-    if (elementsAtLine.length === 1) {
-      const target = elementsAtLine[0];
-      return {
-        startLine: target.startLine,
-        endLine: target.endLine,
-        componentStart,
-        componentEnd
-      };
-    }
-    if (elementContext) {
-      for (const elem of elementsAtLine) {
-        if (t__namespace.isJSXElement(elem.node)) {
-          const score = scoreElementMatch(elem.node, elementContext, fileContent);
-          elem.score = score;
-        }
-      }
-      elementsAtLine.sort((a, b) => b.score - a.score);
-      if (elementsAtLine[0].score > 0) {
-        return {
-          startLine: elementsAtLine[0].startLine,
-          endLine: elementsAtLine[0].endLine,
-          componentStart,
-          componentEnd
-        };
-      }
-    }
-    return {
-      startLine: elementsAtLine[0].startLine,
-      endLine: elementsAtLine[0].endLine,
-      componentStart,
-      componentEnd
-    };
-  }
-  if (elementContext == null ? void 0 : elementContext.tagName) {
-    const allOfTag = allElementsByTag.get(elementContext.tagName);
-    if (allOfTag && allOfTag.length > 0) {
-      if (elementContext.textContent || elementContext.className) {
-        for (const elem of allOfTag) {
-          if (t__namespace.isJSXElement(elem.node)) {
-            elem.score = scoreElementMatch(elem.node, elementContext, fileContent);
-          }
-        }
-        allOfTag.sort((a, b) => b.score - a.score);
-        if (allOfTag[0].score > 50) {
-          return {
-            startLine: allOfTag[0].startLine,
-            endLine: allOfTag[0].endLine,
-            componentStart,
-            componentEnd
-          };
-        }
-      }
-      if (elementContext.nthOfType && allOfTag.length >= elementContext.nthOfType) {
-        const target = allOfTag[elementContext.nthOfType - 1];
-        return {
-          startLine: target.startLine,
-          endLine: target.endLine,
-          componentStart,
-          componentEnd
-        };
-      }
-    }
-  }
-  const nearbyElements = [];
-  traverse(ast, {
-    JSXElement(path2) {
-      const loc = path2.node.loc;
-      if (!loc) return;
-      const startLine = loc.start.line;
-      const endLine = loc.end.line;
-      if (startLine < componentStart || endLine > componentEnd) return;
-      if (Math.abs(startLine - lineNumber) <= 5) {
-        const score = elementContext ? scoreElementMatch(path2.node, elementContext, fileContent) : 100 - Math.abs(startLine - lineNumber);
-        nearbyElements.push({ node: path2.node, startLine, endLine, score });
-      }
-    }
-  });
-  if (nearbyElements.length > 0) {
-    nearbyElements.sort((a, b) => b.score - a.score);
-    return {
-      startLine: nearbyElements[0].startLine,
-      endLine: nearbyElements[0].endLine,
-      componentStart,
-      componentEnd
-    };
-  }
-  if (componentNode && componentStart > 0) {
-    return {
-      startLine: componentStart,
-      endLine: componentEnd,
-      componentStart,
-      componentEnd
-    };
-  }
-  return null;
-}
-function scoreElementMatch(node, context, fileContent) {
-  let score = 0;
-  const opening = node.openingElement;
-  if (t__namespace.isJSXIdentifier(opening.name)) {
-    if (opening.name.name === context.tagName) {
-      score += 50;
-    } else {
-      return 0;
-    }
-  } else if (t__namespace.isJSXMemberExpression(opening.name)) {
-    const fullName = getJSXMemberName(opening.name);
-    if (fullName === context.tagName || fullName.endsWith(`.${context.tagName}`)) {
-      score += 50;
-    } else {
-      return 0;
-    }
-  }
-  if (context.className) {
-    const classAttr = opening.attributes.find(
-      (attr) => t__namespace.isJSXAttribute(attr) && t__namespace.isJSXIdentifier(attr.name) && attr.name.name === "className"
-    );
-    if (classAttr && t__namespace.isJSXAttribute(classAttr)) {
-      const classValue = getAttributeValue(classAttr);
-      if (classValue && context.className.split(/\s+/).some((c) => classValue.includes(c))) {
-        score += 20;
-      }
-    }
-  }
-  if (context.textContent && node.loc) {
-    const elementCode = fileContent.split("\n").slice(node.loc.start.line - 1, node.loc.end.line).join("\n");
-    const normalizedContent = context.textContent.toLowerCase().trim();
-    const normalizedElement = elementCode.toLowerCase();
-    if (normalizedElement.includes(normalizedContent)) {
-      score += 30;
-    }
-  }
-  if (context.props) {
-    for (const [key, value] of Object.entries(context.props)) {
-      if (key.startsWith("_")) continue;
-      const attr = opening.attributes.find(
-        (a) => t__namespace.isJSXAttribute(a) && t__namespace.isJSXIdentifier(a.name) && a.name.name === key
-      );
-      if (attr) {
-        score += 5;
-        if (typeof value === "string" && t__namespace.isJSXAttribute(attr)) {
-          const attrValue = getAttributeValue(attr);
-          if (attrValue === value) score += 10;
-        }
-      }
-    }
-  }
-  return score;
-}
-function getJSXMemberName(node) {
-  if (t__namespace.isJSXIdentifier(node.object)) {
-    return `${node.object.name}.${node.property.name}`;
-  }
-  if (t__namespace.isJSXMemberExpression(node.object)) {
-    return `${getJSXMemberName(node.object)}.${node.property.name}`;
-  }
-  return node.property.name;
-}
-function getAttributeValue(attr) {
-  if (!attr.value) return null;
-  if (t__namespace.isStringLiteral(attr.value)) return attr.value.value;
-  if (t__namespace.isJSXExpressionContainer(attr.value) && t__namespace.isStringLiteral(attr.value.expression)) {
-    return attr.value.expression.value;
-  }
-  return null;
-}
-async function handleRead(req) {
-  const devModeError = validateDevMode();
-  if (devModeError) return devModeError;
-  const { searchParams } = new URL(req.url);
-  let filePath = searchParams.get("path") || "";
-  let lineNumber = parseInt(searchParams.get("line") || "1");
-  const debugStack = searchParams.get("debugStack") || "";
-  const tagName = searchParams.get("tagName") || "";
-  const nthOfType = parseInt(searchParams.get("nthOfType") || "0");
-  const textContent = searchParams.get("textContent") || "";
-  const className = searchParams.get("className") || "";
-  const elementContext = tagName ? {
-    tagName,
-    nthOfType: nthOfType > 0 ? nthOfType : void 0,
-    textContent: textContent || void 0,
-    className: className || void 0
-  } : void 0;
-  const parentFilePath = searchParams.get("parentFilePath") || "";
-  const parentLine = parseInt(searchParams.get("parentLine") || "0");
-  const parentComponentName = searchParams.get("parentComponentName") || "";
-  const parentDebugStack = searchParams.get("parentDebugStack") || "";
-  const childKey = searchParams.get("childKey") || "";
-  const projectRoot = process.cwd();
-  if (debugStack) {
-    const compiledPos = parseDebugStack(debugStack);
-    if (compiledPos) {
-      const originalPos = await resolveOriginalPosition(
-        compiledPos,
-        projectRoot
-      );
-      if (originalPos) {
-        filePath = originalPos.source;
-        lineNumber = originalPos.line;
-      }
-    }
-  }
-  const normalizedPath = normalizePath(filePath);
-  const absolutePath = await resolveFilePath(projectRoot, normalizedPath);
-  if (!absolutePath) {
-    return server.NextResponse.json(
-      { success: false, error: "File not found" },
-      { status: 404 }
-    );
-  }
-  const content = await fs.readFile(absolutePath, "utf-8");
-  const ast = parseFile(content);
-  if (!ast) {
-    return server.NextResponse.json(
-      { success: false, error: "Failed to parse file" },
-      { status: 400 }
-    );
-  }
-  const componentName = extractComponentName(ast);
-  if (!componentName) {
-    return server.NextResponse.json({
-      success: true,
-      content,
-      lineStart: 1,
-      lineEnd: content.split("\n").length
-    });
-  }
-  const target = findTargetElement(ast, content, {
-    componentName,
-    lineNumber,
-    elementContext
-  });
-  if (!target) {
-    return server.NextResponse.json({
-      success: true,
-      content,
-      lineStart: 1,
-      lineEnd: content.split("\n").length
-    });
-  }
-  const lines = content.split("\n");
-  const componentLines = lines.slice(
-    target.componentStart - 1,
-    target.componentEnd
-  );
-  const preview = componentLines.join("\n");
-  let parentInstance = null;
-  if (parentDebugStack) {
-    try {
-      let resolvedParentPath = parentFilePath;
-      let resolvedParentLine = parentLine;
-      let resolvedParentComponentName = parentComponentName;
-      if (!resolvedParentComponentName && parentDebugStack) {
-        resolvedParentComponentName = extractComponentNameFromStack(parentDebugStack) || "";
-      }
-      if (parentDebugStack) {
-        const compiledPos = parseDebugStack(parentDebugStack);
-        if (compiledPos) {
-          const originalPos = await resolveOriginalPosition(
-            compiledPos,
-            projectRoot
-          );
-          if (originalPos) {
-            resolvedParentPath = originalPos.source;
-            resolvedParentLine = originalPos.line;
-          }
-        }
-      }
-      const normalizedParentPath = normalizePath(resolvedParentPath);
-      const absoluteParentPath = await resolveFilePath(
-        projectRoot,
-        normalizedParentPath
-      );
-      if (absoluteParentPath && resolvedParentComponentName) {
-        const parentContent = await fs.readFile(absoluteParentPath, "utf-8");
-        const parentAst = parseFile(parentContent);
-        if (parentAst) {
-          let nthOfType2 = void 0;
-          if (childKey) {
-            const keyAsNumber = parseInt(childKey, 10);
-            if (!isNaN(keyAsNumber)) {
-              nthOfType2 = keyAsNumber + 1;
-            }
-          }
-          const parentTarget = findTargetElement(parentAst, parentContent, {
-            componentName: resolvedParentComponentName,
-            lineNumber: 0,
-            // Don't use line number - rely on element context to find correct instance
-            elementContext: {
-              tagName: componentName,
-              // Search for child component usage
-              nthOfType: nthOfType2,
-              // Find specific instance if key is numeric
-              textContent: textContent || void 0
-              // Use text content to match the specific instance
-            }
-          });
-          if (parentTarget) {
-            const parentLines = parentContent.split("\n");
-            const parentComponentLines = parentLines.slice(
-              parentTarget.componentStart - 1,
-              parentTarget.componentEnd
-            );
-            parentInstance = {
-              filePath: resolvedParentPath,
-              content: parentComponentLines.join("\n"),
-              lineStart: parentTarget.componentStart,
-              lineEnd: parentTarget.componentEnd,
-              usageLineStart: parentTarget.startLine,
-              usageLineEnd: parentTarget.endLine,
-              componentName: resolvedParentComponentName
-            };
-          }
-        }
-      }
-    } catch (error) {
-      console.error("Error resolving parent instance:", error);
-    }
-  }
-  return server.NextResponse.json({
-    success: true,
-    content: preview,
-    lineStart: target.componentStart,
-    lineEnd: target.componentEnd,
-    targetStartLine: target.startLine,
-    targetEndLine: target.endLine,
-    componentName,
-    // Return the actual component name parsed from code
-    parentInstance
-    // Optional: where this component is used
-  });
-}
-async function handleUndo(req) {
-  const devModeError = validateDevMode();
-  if (devModeError) return devModeError;
-  try {
-    const body = await req.json();
-    const { filePath, content } = body;
-    if (!filePath || typeof content !== "string") {
-      return server.NextResponse.json(
-        {
-          success: false,
-          error: "Invalid request: filePath and content required"
-        },
-        { status: 400 }
-      );
-    }
-    const projectRoot = process.cwd();
-    const normalizedPath = normalizePath(filePath);
-    const absolutePath = await resolveFilePath(projectRoot, normalizedPath);
-    if (!absolutePath) {
-      return server.NextResponse.json(
-        { success: false, error: `File not found: ${normalizedPath}` },
-        { status: 404 }
-      );
-    }
-    if (!isPathSecure(absolutePath, projectRoot)) {
-      return server.NextResponse.json(
-        { success: false, error: "Access denied: File outside project root" },
-        { status: 403 }
-      );
-    }
-    await fs.writeFile(absolutePath, content, "utf-8");
-    console.log(`✅ Undo: Restored ${normalizedPath}`);
-    return server.NextResponse.json({ success: true });
-  } catch (error) {
-    console.error("Undo error:", error);
-    return server.NextResponse.json(
-      { success: false, error: String(error) },
-      { status: 500 }
-    );
-  }
-}
-async function handleResolve(req) {
-  const devModeError = validateDevMode();
-  if (devModeError) return devModeError;
-  try {
-    const body = await req.json();
-    const debugStack = body == null ? void 0 : body.debugStack;
-    if (!debugStack || typeof debugStack !== "string") {
-      return server.NextResponse.json(
-        { success: false, error: "Missing debugStack" },
-        { status: 400 }
-      );
-    }
-    const compiledFrames = parseDebugStackFrames(debugStack);
-    if (compiledFrames.length === 0) {
-      const compiledPos = parseDebugStack(debugStack);
-      if (!compiledPos) {
-        console.error("Could not parse debug stack:", debugStack);
-        return server.NextResponse.json(
-          { success: false, error: "Could not parse stack" },
-          { status: 422 }
-        );
-      }
-      const originalPos = await resolveOriginalPosition(
-        compiledPos,
-        process.cwd()
-      );
-      if (!originalPos) {
-        return server.NextResponse.json(
-          { success: false, error: "Source map lookup failed" },
-          { status: 404 }
-        );
-      }
-      return server.NextResponse.json({
-        success: true,
-        filePath: originalPos.source,
-        lineNumber: originalPos.line,
-        columnNumber: originalPos.column ?? 0
-      });
-    }
-    const resolvedFrames = [];
-    for (const frame of compiledFrames) {
-      const originalPos = await resolveOriginalPosition(frame, process.cwd());
-      if (originalPos) {
-        resolvedFrames.push({
-          filePath: originalPos.source,
-          lineNumber: originalPos.line,
-          columnNumber: originalPos.column ?? 0
-        });
-      }
-    }
-    if (resolvedFrames.length === 0) {
-      return server.NextResponse.json(
-        { success: false, error: "Source map lookup failed for all frames" },
-        { status: 404 }
-      );
-    }
-    console.log("Resolved frames:", resolvedFrames);
-    return server.NextResponse.json({
-      success: true,
-      filePath: resolvedFrames[0].filePath,
-      lineNumber: resolvedFrames[0].lineNumber,
-      columnNumber: resolvedFrames[0].columnNumber,
-      frames: resolvedFrames
-      // [componentDefinition, parentInstance]
-    });
-  } catch (error) {
-    console.error("Source resolve error:", error);
-    return server.NextResponse.json(
-      { success: false, error: "Internal error" },
-      { status: 500 }
-    );
-  }
-}
-async function handleAbsolutePath(req) {
-  const devModeError = validateDevMode();
-  if (devModeError) return devModeError;
-  const { searchParams } = new URL(req.url);
-  const filePath = searchParams.get("path") || "";
-  if (!filePath) {
-    return server.NextResponse.json(
-      { success: false, error: "Missing path" },
-      { status: 400 }
-    );
-  }
-  const projectRoot = process.cwd();
-  const normalizedPath = normalizePath(filePath);
-  const absolutePath = await resolveFilePath(projectRoot, normalizedPath);
-  if (!absolutePath) {
-    return server.NextResponse.json(
-      { success: false, error: "File not found" },
-      { status: 404 }
-    );
-  }
-  return server.NextResponse.json({
-    success: true,
-    absolutePath
-  });
-}
-async function handleValidateSession(req) {
-  const devModeError = validateDevMode();
-  if (devModeError) return devModeError;
-  try {
-    const body = await req.json();
-    const { filePath, lastKnownHash, lastKnownSize } = body;
-    if (!filePath || !lastKnownHash || lastKnownSize === void 0) {
-      return server.NextResponse.json(
-        { success: false, error: "Missing required fields" },
-        { status: 400 }
-      );
-    }
-    const projectRoot = process.cwd();
-    const normalizedPath = normalizePath(filePath);
-    const absolutePath = await resolveFilePath(projectRoot, normalizedPath);
-    if (!absolutePath) {
-      return server.NextResponse.json(
-        { success: false, error: "File not found" },
-        { status: 404 }
-      );
-    }
-    if (!isPathSecure(absolutePath, projectRoot)) {
-      return server.NextResponse.json(
-        { success: false, error: "Access denied" },
-        { status: 403 }
-      );
-    }
-    const content = await fs.readFile(absolutePath, "utf-8");
-    const hash = crypto.createHash("sha256").update(content).digest("hex");
-    const stats = await fs.stat(absolutePath);
-    const isValid = hash === lastKnownHash && content.length === lastKnownSize;
-    console.log(`[validate-session] ${filePath}:`);
-    console.log(`  Hash match: ${hash === lastKnownHash}`);
-    console.log(`  Size match: ${content.length === lastKnownSize}`);
-    console.log(`  Is valid: ${isValid}`);
-    return server.NextResponse.json({
-      success: true,
-      isValid,
-      currentHash: hash,
-      currentSize: content.length,
-      lastModifiedTime: stats.mtimeMs
-    });
-  } catch (error) {
-    console.error("Validation error:", error);
-    return server.NextResponse.json(
-      { success: false, error: String(error) },
-      { status: 500 }
-    );
-  }
-}
-class AIEditorAgent {
-  constructor(session, projectRoot) {
-    this.session = session;
-    this.projectRoot = projectRoot;
-  }
-  /**
-   * Create a new agent instance
-   */
-  static async create(config) {
-    const sessionOptions = {
-      model: "claude-sonnet-4-5-20250929",
-      // Enable auto-apply for edits without permission prompts
-      permissionMode: "acceptEdits",
-      env: {
-        ...process.env,
-        ANTHROPIC_API_KEY: config.apiKey,
-        // Set working directory
-        PWD: config.projectRoot
-      },
-      // Explicitly allow core development tools
-      allowedTools: config.allowedTools || ["Read", "Edit", "Glob", "Grep"],
-      disallowedTools: config.disallowedTools || []
-    };
-    let session;
-    if (config.sessionId) {
-      session = claudeAgentSdk.unstable_v2_resumeSession(config.sessionId, sessionOptions);
-    } else {
-      session = claudeAgentSdk.unstable_v2_createSession(sessionOptions);
-    }
-    return new AIEditorAgent(session, config.projectRoot);
-  }
-  /**
-   * Send a message to the agent and stream responses
-   */
-  async *sendMessage(message, componentContext) {
-    let fullMessage = `<response_style>
-KEEP RESPONSES EXTREMELY BRIEF AND STATUS-LIKE.
-- Use terse status messages: "Reading file.tsx", "Changing color", "Done"
-- NO conversational language (avoid: "I'll", "Let me", "Sure", "Great", "I can see")
-- NO explanations unless explicitly asked
-- State ONLY what you're doing, nothing more
-- Format: Action + target (e.g., "Updating StatsCard.tsx:24")
-</response_style>
-
-`;
-    if (componentContext) {
-      fullMessage += `[Component: ${componentContext.componentName} at ${componentContext.filePath}:${componentContext.lineNumber}]
-
-`;
-    }
-    fullMessage += message;
-    await this.session.send(fullMessage);
-    for await (const event of this.session.stream()) {
-      yield event;
-    }
-  }
-  /**
-   * Get the session ID
-   */
-  getSessionId() {
-    return this.session.sessionId;
-  }
-  /**
-   * Close the session
-   */
-  close() {
-    this.session.close();
-  }
-  /**
-   * Async disposal support
-   */
-  async [Symbol.asyncDispose]() {
-    await this.session[Symbol.asyncDispose]();
-  }
-}
-class AgentSessionStore {
-  // 5 minutes
-  constructor() {
-    this.sessions = /* @__PURE__ */ new Map();
-    this.SESSION_TIMEOUT = 1e3 * 60 * 30;
-    this.CLEANUP_INTERVAL = 1e3 * 60 * 5;
-    this.startCleanupTimer();
-  }
-  /**
-   * Create or resume a session
-   */
-  async createSession(config) {
-    const sessionId = config.sessionId || this.generateSessionId();
-    const existing = this.sessions.get(sessionId);
-    if (existing) {
-      existing.lastActive = Date.now();
-      existing.threadId = config.threadId;
-      return existing;
-    }
-    const agent = await AIEditorAgent.create({
-      apiKey: config.apiKey,
-      projectRoot: config.projectRoot,
-      sessionId: config.sessionId,
-      allowedTools: config.allowedTools,
-      disallowedTools: config.disallowedTools
-    });
-    const session = {
-      sessionId,
-      threadId: config.threadId,
-      agent,
-      createdAt: Date.now(),
-      lastActive: Date.now(),
-      isLocked: false
-    };
-    this.sessions.set(sessionId, session);
-    return session;
-  }
-  /**
-   * Get a session by ID
-   */
-  getSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.lastActive = Date.now();
-    }
-    return session;
-  }
-  /**
-   * Acquire a lock on a session to prevent concurrent edits
-   * Returns true if lock was acquired, false if already locked
-   */
-  acquireLock(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
-    }
-    if (session.isLocked) {
-      return false;
-    }
-    session.isLocked = true;
-    session.lastActive = Date.now();
-    return true;
-  }
-  /**
-   * Release a lock on a session
-   */
-  releaseLock(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.isLocked = false;
-      session.lastActive = Date.now();
-    }
-  }
-  /**
-   * Check if any session is currently locked (to prevent concurrent edits)
-   */
-  hasActiveLock() {
-    for (const session of this.sessions.values()) {
-      if (session.isLocked) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Get all active sessions for a thread
-   */
-  getSessionsByThread(threadId) {
-    const sessions = [];
-    for (const session of this.sessions.values()) {
-      if (session.threadId === threadId) {
-        sessions.push(session);
-      }
-    }
-    return sessions;
-  }
-  /**
-   * Delete a session
-   */
-  deleteSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.agent.close();
-      this.sessions.delete(sessionId);
-    }
-  }
-  /**
-   * Delete all sessions for a thread
-   */
-  deleteSessionsByThread(threadId) {
-    for (const [sessionId, session] of this.sessions.entries()) {
-      if (session.threadId === threadId) {
-        session.agent.close();
-        this.sessions.delete(sessionId);
-      }
-    }
-  }
-  /**
-   * Get all active sessions
-   */
-  getAllSessions() {
-    return Array.from(this.sessions.values());
-  }
-  /**
-   * Clean up expired sessions
-   */
-  cleanupExpiredSessions() {
-    const now = Date.now();
-    const expiredSessions = [];
-    for (const [sessionId, session] of this.sessions.entries()) {
-      const inactiveTime = now - session.lastActive;
-      if (inactiveTime > this.SESSION_TIMEOUT && !session.isLocked) {
-        expiredSessions.push(sessionId);
-      }
-    }
-    for (const sessionId of expiredSessions) {
-      console.log(
-        `[AgentSessionStore] Cleaning up expired session: ${sessionId}`
-      );
-      this.deleteSession(sessionId);
-    }
-    if (expiredSessions.length > 0) {
-      console.log(
-        `[AgentSessionStore] Cleaned up ${expiredSessions.length} expired sessions`
-      );
-    }
-  }
-  /**
-   * Start periodic cleanup timer
-   */
-  startCleanupTimer() {
-    setInterval(() => {
-      this.cleanupExpiredSessions();
-    }, this.CLEANUP_INTERVAL);
-  }
-  /**
-   * Generate a unique session ID
-   */
-  generateSessionId() {
-    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-  }
-  /**
-   * Get statistics about the session store
-   */
-  getStats() {
-    return {
-      totalSessions: this.sessions.size,
-      lockedSessions: Array.from(this.sessions.values()).filter(
-        (s) => s.isLocked
-      ).length,
-      sessions: Array.from(this.sessions.values()).map((s) => ({
-        sessionId: s.sessionId,
-        threadId: s.threadId,
-        isLocked: s.isLocked,
-        ageMinutes: Math.floor((Date.now() - s.createdAt) / 1e3 / 60),
-        inactiveMinutes: Math.floor((Date.now() - s.lastActive) / 1e3 / 60)
-      }))
-    };
-  }
-}
-let sessionStore = null;
-function getSessionStore() {
-  if (!sessionStore) {
-    sessionStore = new AgentSessionStore();
-  }
-  return sessionStore;
-}
-async function handleChat(req) {
-  const devModeError = validateDevMode();
-  if (devModeError) return devModeError;
-  try {
-    const body = await req.json();
-    const { sessionId, threadId, message, componentContext } = body;
-    if (!threadId || !message) {
-      return server.NextResponse.json(
-        { error: "threadId and message are required" },
-        { status: 400 }
-      );
-    }
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-      return server.NextResponse.json(
-        { error: "ANTHROPIC_API_KEY not configured" },
-        { status: 500 }
-      );
-    }
-    const sessionStore2 = getSessionStore();
-    const projectRoot = process.cwd();
-    const session = await sessionStore2.createSession({
-      sessionId,
-      threadId,
-      apiKey,
-      projectRoot
-    });
-    if (!sessionStore2.acquireLock(session.sessionId)) {
-      return server.NextResponse.json(
-        {
-          error: "Another operation is in progress. Please wait for it to complete."
-        },
-        { status: 409 }
-      );
-    }
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-      async start(controller) {
-        try {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({ type: "connected", sessionId: session.sessionId })}
-
-`
-            )
-          );
-          for await (const event of session.agent.sendMessage(
-            message,
-            componentContext
-          )) {
-            console.log("[AGENT EVENT]", event.type, JSON.stringify(event, null, 2));
-            controller.enqueue(
-              encoder.encode(`data: ${JSON.stringify(event)}
-
-`)
-            );
-          }
-          controller.enqueue(
-            encoder.encode(`data: ${JSON.stringify({ type: "done" })}
-
-`)
-          );
-          controller.close();
-        } catch (error) {
-          console.error("[handleChat] Error:", error);
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({ type: "error", error: error.message || String(error) })}
-
-`
-            )
-          );
-          controller.close();
-        } finally {
-          sessionStore2.releaseLock(session.sessionId);
-        }
-      }
-    });
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  } catch (error) {
-    console.error("[handleChat] Request error:", error);
-    return server.NextResponse.json(
-      { error: String(error) },
-      { status: 500 }
-    );
-  }
-}
-async function handleConfig() {
-  const enabled = process.env.NEXT_PUBLIC_AI_EDITOR_ENABLED === "true" || process.env.VITE_AI_EDITOR_ENABLED === "true" || process.env.REACT_APP_AI_EDITOR_ENABLED === "true";
-  return server.NextResponse.json({
-    enabled,
-    // Include NODE_ENV for debugging
-    nodeEnv: process.env.NODE_ENV
-  });
-}
-async function handleAIEditorRequest(req, context) {
-  const { path: path2 } = await context.params;
-  const endpoint = path2[0];
-  const method = req.method;
-  switch (endpoint) {
-    case "read":
-      if (method === "GET") return handleRead(req);
-      break;
-    case "undo":
-      if (method === "POST") return handleUndo(req);
-      break;
-    case "resolve":
-      if (method === "POST") return handleResolve(req);
-      break;
-    case "absolute-path":
-      if (method === "GET") return handleAbsolutePath(req);
-      break;
-    case "validate-session":
-      if (method === "POST") return handleValidateSession(req);
-      break;
-    case "chat":
-      if (method === "POST") return handleChat(req);
-      break;
-    case "config":
-      if (method === "GET") return handleConfig();
-      break;
-  }
-  return server.NextResponse.json(
-    { error: `Unknown endpoint: ${endpoint}` },
-    { status: 404 }
-  );
-}
-const STORAGE_DIR = ".ai-editor";
-const STORAGE_FILE = "comments.json";
-function getProjectRoot() {
-  return process.cwd();
-}
-function getStoragePath() {
-  return path.join(getProjectRoot(), STORAGE_DIR, STORAGE_FILE);
-}
-async function ensureStorageDir() {
-  const dir = path.join(getProjectRoot(), STORAGE_DIR);
-  if (!fs$1.existsSync(dir)) {
-    await fs.mkdir(dir, { recursive: true });
-  }
-}
-async function handleCommentsRequest(request) {
-  if (process.env.NODE_ENV !== "development") {
-    return server.NextResponse.json(
-      { error: "Comments API only available in development" },
-      { status: 403 }
-    );
-  }
-  try {
-    if (request.method === "GET") {
-      const storagePath = getStoragePath();
-      if (!fs$1.existsSync(storagePath)) {
-        return server.NextResponse.json({ comments: [] });
-      }
-      const data = await fs.readFile(storagePath, "utf-8");
-      const comments = JSON.parse(data);
-      return server.NextResponse.json({ comments });
-    }
-    if (request.method === "POST") {
-      const body = await request.json();
-      const { action } = body;
-      if (action === "save") {
-        const { comments } = body;
-        await ensureStorageDir();
-        const storagePath = getStoragePath();
-        await fs.writeFile(storagePath, JSON.stringify(comments, null, 2), "utf-8");
-        return server.NextResponse.json({ success: true });
-      }
-      if (action === "clear") {
-        await ensureStorageDir();
-        const storagePath = getStoragePath();
-        await fs.writeFile(storagePath, JSON.stringify([]), "utf-8");
-        return server.NextResponse.json({ success: true });
-      }
-      return server.NextResponse.json(
-        { error: "Invalid action" },
-        { status: 400 }
-      );
-    }
-    return server.NextResponse.json(
-      { error: "Method not allowed" },
-      { status: 405 }
-    );
-  } catch (error) {
-    console.error("Comment storage error:", error);
-    return server.NextResponse.json(
-      { error: "Internal server error" },
-      { status: 500 }
-    );
-  }
-}
-exports.extractComponentName = extractComponentName;
-exports.extractComponentNameFromStack = extractComponentNameFromStack;
-exports.fileExists = fileExists$1;
-exports.findTargetElement = findTargetElement;
-exports.getAttributeValue = getAttributeValue;
-exports.getJSXMemberName = getJSXMemberName;
-exports.getOriginalPositionFromDebugStack = getOriginalPositionFromDebugStack;
-exports.handleAIEditorRequest = handleAIEditorRequest;
-exports.handleAbsolutePath = handleAbsolutePath;
-exports.handleCommentsRequest = handleCommentsRequest;
-exports.handleRead = handleRead;
-exports.handleResolve = handleResolve;
-exports.handleUndo = handleUndo;
-exports.handleValidateSession = handleValidateSession;
-exports.isPathSecure = isPathSecure;
-exports.normalizePath = normalizePath;
-exports.parseDebugStack = parseDebugStack;
-exports.parseDebugStackFrames = parseDebugStackFrames;
-exports.parseFile = parseFile;
-exports.resolveFilePath = resolveFilePath;
-exports.resolveOriginalPosition = resolveOriginalPosition;
-exports.scoreElementMatch = scoreElementMatch;
-exports.validateDevMode = validateDevMode;
-exports.validateGeneratedCode = validateGeneratedCode;
-//# sourceMappingURL=comments-2HX-AAwu.cjs.map