next-ai-editor 0.1.0

package/dist/index-BFa7H-uO.js

@@ -0,0 +1,1145 @@
+import { NextResponse } from "next/server";
+import fs from "fs/promises";
+import * as parser from "@babel/parser";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { SystemMessage, HumanMessage } from "@langchain/core/messages";
+import path from "path";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { SourceMapConsumer } from "@jridgewell/source-map";
+import crypto from "crypto";
+function validateDevMode() {
+  if (process.env.NODE_ENV !== "development") {
+    return 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 parseFile(content) {
+  try {
+    return parser.parse(content, {
+      sourceType: "module",
+      plugins: [
+        "jsx",
+        "typescript",
+        "decorators-legacy",
+        "classProperties",
+        "optionalChaining",
+        "nullishCoalescingOperator"
+      ]
+    });
+  } catch (e) {
+    console.error("Parse error:", e);
+    return null;
+  }
+}
+function findTargetElement(ast, fileContent, options) {
+  const { componentName, lineNumber, elementContext } = options;
+  const matches = [];
+  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.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.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();
+  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.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 (elementContext) {
+        const score = scoreElementMatch(path2.node, elementContext, fileContent);
+        if (score > 0) {
+          matches.push({ node: path2.node, startLine, endLine, score });
+        }
+      } else if (Math.abs(startLine - lineNumber) <= 5) {
+        matches.push({
+          node: path2.node,
+          startLine,
+          endLine,
+          score: 100 - Math.abs(startLine - lineNumber)
+        });
+      }
+    }
+  });
+  if (matches.length === 0) {
+    if (componentNode && componentStart > 0) {
+      return {
+        startLine: componentStart,
+        endLine: componentEnd,
+        componentStart,
+        componentEnd
+      };
+    }
+    return null;
+  }
+  if ((elementContext == null ? void 0 : elementContext.nthOfType) && elementContext.tagName) {
+    const allOfTag = allElementsByTag.get(elementContext.tagName);
+    if (allOfTag && allOfTag.length >= elementContext.nthOfType) {
+      const target = allOfTag[elementContext.nthOfType - 1];
+      console.log(
+        `   Using nthOfType=${elementContext.nthOfType}: found ${allOfTag.length} <${elementContext.tagName}> elements`
+      );
+      return {
+        startLine: target.startLine,
+        endLine: target.endLine,
+        componentStart,
+        componentEnd
+      };
+    } else {
+      console.log(
+        `   nthOfType=${elementContext.nthOfType} but only found ${(allOfTag == null ? void 0 : allOfTag.length) || 0} <${elementContext.tagName}> elements`
+      );
+    }
+  }
+  matches.sort((a, b) => b.score - a.score);
+  const best = matches[0];
+  return {
+    startLine: best.startLine,
+    endLine: best.endLine,
+    componentStart,
+    componentEnd
+  };
+}
+function scoreElementMatch(node, context, fileContent) {
+  let score = 0;
+  const opening = node.openingElement;
+  if (t.isJSXIdentifier(opening.name)) {
+    if (opening.name.name === context.tagName) {
+      score += 50;
+    } else {
+      return 0;
+    }
+  } else if (t.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.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "className"
+    );
+    if (classAttr && t.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.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === key
+      );
+      if (attr) {
+        score += 5;
+        if (typeof value === "string" && t.isJSXAttribute(attr)) {
+          const attrValue = getAttributeValue(attr);
+          if (attrValue === value) score += 10;
+        }
+      }
+    }
+  }
+  return score;
+}
+function getJSXMemberName(node) {
+  if (t.isJSXIdentifier(node.object)) {
+    return `${node.object.name}.${node.property.name}`;
+  }
+  if (t.isJSXMemberExpression(node.object)) {
+    return `${getJSXMemberName(node.object)}.${node.property.name}`;
+  }
+  return node.property.name;
+}
+function getAttributeValue(attr) {
+  if (!attr.value) return null;
+  if (t.isStringLiteral(attr.value)) return attr.value.value;
+  if (t.isJSXExpressionContainer(attr.value) && t.isStringLiteral(attr.value.expression)) {
+    return attr.value.expression.value;
+  }
+  return null;
+}
+async function handleEdit(req) {
+  var _a;
+  const devModeError = validateDevMode();
+  if (devModeError) return devModeError;
+  try {
+    const body = await req.json();
+    const {
+      filePath,
+      lineNumber,
+      componentName,
+      suggestion,
+      elementContext,
+      editHistory
+    } = body;
+    const projectRoot = process.cwd();
+    const normalizedPath = normalizePath(filePath);
+    const absolutePath = await resolveFilePath(projectRoot, normalizedPath);
+    if (!absolutePath) {
+      return NextResponse.json(
+        { success: false, error: `File not found: ${normalizedPath}` },
+        { status: 404 }
+      );
+    }
+    const fileContent = await fs.readFile(absolutePath, "utf-8");
+    console.log(`[/edit] componentName="${componentName}", filePath="${filePath}"`);
+    const ast = parseFile(fileContent);
+    if (!ast) {
+      return NextResponse.json(
+        { success: false, error: "Failed to parse file" },
+        { status: 400 }
+      );
+    }
+    const target = findTargetElement(ast, fileContent, {
+      componentName,
+      lineNumber,
+      elementContext
+    });
+    if (!target) {
+      return NextResponse.json(
+        { success: false, error: "Could not locate target element" },
+        { status: 400 }
+      );
+    }
+    console.log(
+      `📍 Found element <${(elementContext == null ? void 0 : elementContext.tagName) || "component"}> at lines ${target.startLine}-${target.endLine} (component: ${target.componentStart}-${target.componentEnd})`
+    );
+    console.log(
+      `   Element context: tagName=${elementContext == null ? void 0 : elementContext.tagName}, nthOfType=${elementContext == null ? void 0 : elementContext.nthOfType}, textContent="${elementContext == null ? void 0 : elementContext.textContent}"`
+    );
+    const lines = fileContent.split("\n");
+    const foundElementCode = lines.slice(target.startLine - 1, Math.min(target.startLine + 2, target.endLine)).join("\n");
+    console.log(`   Found element preview:
+${foundElementCode}`);
+    const targetCode = lines.slice(target.startLine - 1, target.endLine).join("\n");
+    const baseIndentation = ((_a = lines[target.startLine - 1].match(/^(\s*)/)) == null ? void 0 : _a[1]) || "";
+    if (target.componentStart <= 0 || target.componentEnd === Infinity) {
+      console.error("❌ Invalid component bounds detected");
+      return NextResponse.json({
+        success: false,
+        error: `Could not determine component bounds. Component: ${target.componentStart}-${target.componentEnd}`
+      });
+    }
+    const componentLines = lines.slice(
+      target.componentStart - 1,
+      target.componentEnd
+    );
+    const annotatedLines = componentLines.map((line, idx) => {
+      const lineNum = target.componentStart + idx;
+      const isTargetStart = lineNum === target.startLine;
+      const isTargetEnd = lineNum === target.endLine;
+      const isWithinTarget = lineNum >= target.startLine && lineNum <= target.endLine;
+      let annotation = "";
+      if (isTargetStart && isTargetEnd) {
+        annotation = " // ← CLICKED ELEMENT (single line)";
+      } else if (isTargetStart) {
+        annotation = " // ← CLICKED ELEMENT STARTS";
+      } else if (isTargetEnd) {
+        annotation = " // ← CLICKED ELEMENT ENDS";
+      } else if (isWithinTarget) {
+        annotation = " // ← (clicked element)";
+      }
+      return line + annotation;
+    });
+    const fullComponentCode = annotatedLines.join("\n");
+    const newCode = await generateEdit({
+      targetCode,
+      fullComponentCode,
+      suggestion,
+      elementContext,
+      baseIndentation,
+      targetLine: target.startLine,
+      targetEndLine: target.endLine,
+      componentStart: target.componentStart,
+      componentEnd: target.componentEnd,
+      editHistory: editHistory || []
+    });
+    if (!newCode) {
+      return NextResponse.json({
+        success: false,
+        error: "AI failed to generate valid edit"
+      });
+    }
+    console.log("Raw AI response length:", newCode.length);
+    console.log("Looking for // FULL_COMPONENT marker...");
+    const fullComponentMatch = newCode.match(/\/\/ FULL_COMPONENT\s*\n([\s\S]+)/);
+    let codeToApply = newCode;
+    let startLineToReplace = target.startLine;
+    let endLineToReplace = target.endLine;
+    if (fullComponentMatch) {
+      console.log("Found // FULL_COMPONENT marker, extracting full component code");
+      codeToApply = fullComponentMatch[1].trim();
+      startLineToReplace = target.componentStart;
+      endLineToReplace = target.componentEnd;
+      console.log(
+        `🔄 AI returned full component modification (lines ${startLineToReplace}-${endLineToReplace})`
+      );
+      console.log("Extracted component code length:", codeToApply.length);
+      console.log("Extracted component code (first 300 chars):", codeToApply.substring(0, 300));
+    } else {
+      console.log("No // FULL_COMPONENT marker found, treating as target element modification");
+      console.log(
+        `🔄 AI returned target element modification (lines ${startLineToReplace}-${endLineToReplace})`
+      );
+    }
+    console.log("Code to apply (first 200 chars):", codeToApply.substring(0, 200));
+    if (!validateGeneratedCode(codeToApply, targetCode, fileContent)) {
+      console.error("❌ Generated code failed validation");
+      console.error("=== Generated code START ===");
+      console.error(codeToApply);
+      console.error("=== Generated code END ===");
+      console.error(`Length: ${codeToApply.length} chars, ${codeToApply.split("\n").length} lines`);
+      return NextResponse.json({
+        success: false,
+        error: "Generated code is invalid - check server logs for details"
+      });
+    }
+    const newLines = [...lines];
+    newLines.splice(
+      startLineToReplace - 1,
+      endLineToReplace - startLineToReplace + 1,
+      ...codeToApply.split("\n")
+    );
+    await fs.writeFile(absolutePath, newLines.join("\n"), "utf-8");
+    console.log(`✅ Updated ${normalizedPath}`);
+    return NextResponse.json({
+      success: true,
+      fileSnapshot: fileContent,
+      // Original file content for undo
+      generatedCode: codeToApply,
+      // AI-generated code
+      modifiedLines: {
+        start: startLineToReplace,
+        end: endLineToReplace
+      }
+    });
+  } catch (error) {
+    console.error("AI Editor error:", error);
+    return NextResponse.json(
+      { success: false, error: String(error) },
+      { status: 500 }
+    );
+  }
+}
+async function generateEdit(options) {
+  const {
+    fullComponentCode,
+    suggestion,
+    baseIndentation,
+    editHistory
+  } = options;
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) throw new Error("ANTHROPIC_API_KEY not set");
+  const model = new ChatAnthropic({
+    apiKey,
+    modelName: "claude-sonnet-4-5-20250929",
+    maxTokens: 4096,
+    temperature: 0
+  });
+  const systemPrompt = `You are a precise code editor for React/JSX components.
+
+WHAT YOU'LL SEE:
+- Full component code with line annotations
+- The clicked element is marked with "// ← CLICKED ELEMENT STARTS" and "// ← CLICKED ELEMENT ENDS"
+- Lines within the element have "// ← (clicked element)"
+- These are just annotations to help you - they are NOT part of the actual code
+
+YOUR TASK:
+Modify ONLY the marked element (unless the request requires changing its parent/wrapper).
+
+OUTPUT:
+- Just the modified element code (WITHOUT the annotation comments)
+- OR if broader changes needed: "// FULL_COMPONENT\\n" + complete modified component (WITHOUT annotation comments)
+
+RULES:
+- Output ONLY code, no explanations
+- No markdown fences
+- Do NOT include the "// ← CLICKED ELEMENT" annotation comments in your output
+- Preserve indentation
+- Make minimal changes
+- Do NOT modify unrelated elements`;
+  let userPrompt = "";
+  if (editHistory.length > 0) {
+    userPrompt += "Previous edits made to this element:\n";
+    editHistory.forEach((item, idx) => {
+      userPrompt += `${idx + 1}. ${item.suggestion} ${item.success ? "(✓ applied)" : "(✗ failed)"}
+`;
+    });
+    userPrompt += "\n";
+  }
+  userPrompt += `Component (clicked element is annotated with "// ← CLICKED ELEMENT" comments):
+
+\`\`\`jsx
+${fullComponentCode}
+\`\`\`
+
+User request: "${suggestion}"
+${editHistory.length > 0 ? "\n(Build upon previous changes)" : ""}
+
+Modify the annotated element to fulfill this request. Remember: do NOT include the annotation comments in your output.`;
+  try {
+    const response = await model.invoke([
+      new SystemMessage(systemPrompt),
+      new HumanMessage(userPrompt)
+    ]);
+    let code = typeof response.content === "string" ? response.content : String(response.content);
+    code = cleanGeneratedCode(code, baseIndentation);
+    return code || null;
+  } catch (e) {
+    console.error("AI generation error:", e);
+    return null;
+  }
+}
+function cleanGeneratedCode(code, baseIndentation) {
+  var _a, _b, _c;
+  const isFullComponent = code.trim().startsWith("// FULL_COMPONENT");
+  let marker = "";
+  if (isFullComponent) {
+    marker = "// FULL_COMPONENT\n";
+    code = code.replace(/^\/\/ FULL_COMPONENT\n?/, "");
+  }
+  code = code.replace(/^```[\w]*\n?/gm, "").replace(/\n?```$/gm, "").trim();
+  code = code.replace(/^(Here'?s?|Here is|Modified|Output|Result)[:\s]*/i, "").replace(/\s*(Done|Complete|That'?s? it)\.?$/i, "").trim();
+  code = code.replace(/\s*\/\/ ← CLICKED ELEMENT STARTS/g, "").replace(/\s*\/\/ ← CLICKED ELEMENT ENDS/g, "").replace(/\s*\/\/ ← CLICKED ELEMENT \(single line\)/g, "").replace(/\s*\/\/ ← \(clicked element\)/g, "").trim();
+  if (!code) return "";
+  if (!isFullComponent) {
+    const lines = code.split("\n");
+    const firstLineIndent = ((_b = (_a = lines[0]) == null ? void 0 : _a.match(/^(\s*)/)) == null ? void 0 : _b[1]) || "";
+    const indentDiff = baseIndentation.length - firstLineIndent.length;
+    if (indentDiff !== 0) {
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim()) {
+          const currentIndent = ((_c = lines[i].match(/^(\s*)/)) == null ? void 0 : _c[1]) || "";
+          const newIndentLength = Math.max(
+            0,
+            currentIndent.length + indentDiff
+          );
+          lines[i] = " ".repeat(newIndentLength) + lines[i].trimStart();
+        }
+      }
+      code = lines.join("\n");
+    }
+  }
+  return marker + code;
+}
+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.parse(codeToValidate, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript"]
+      });
+    } else {
+      const wrapped = `function _() { return (${newCode}); }`;
+      parser.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 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 = cleanPathTurbopack(filePath);
+      if (!shouldSkip(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 cleanPathTurbopack(p) {
+  let cleaned = p;
+  cleaned = cleaned.replace(/^about:\/\/React\/Server\//, "");
+  if (cleaned.startsWith("file://")) {
+    cleaned = cleaned.replace(/^file:\/\//, "");
+  }
+  try {
+    if (cleaned.includes("%")) {
+      cleaned = decodeURIComponent(cleaned);
+    }
+  } catch (e) {
+    console.warn("Failed to decode URL-encoded path:", cleaned, e);
+  }
+  cleaned = cleaned.replace(/^webpack-internal:\/\/\/\([^)]+\)\/\.\//, "").replace(/^webpack-internal:\/\/\/\([^)]+\)\//, "").replace(/^webpack-internal:\/\//, "").replace(/^webpack:\/\/[^/]*\//, "").replace(/^\([^)]+\)\//, "").replace(/\?.*$/, "");
+  if (cleaned.startsWith(".next/") || path.isAbsolute(cleaned)) {
+    return cleaned;
+  }
+  return cleaned;
+}
+function cleanPath(p) {
+  return cleanPathTurbopack(p);
+}
+function normalizeSourcePath(source, projectRoot) {
+  let cleaned = cleanPath(source);
+  cleaned = cleaned.replace(/\\/g, "/");
+  if (cleaned.startsWith(projectRoot)) {
+    cleaned = cleaned.substring(projectRoot.length + 1);
+  }
+  return cleaned.replace(/^\/+/, "");
+}
+function shouldSkip(p) {
+  if (!p) return true;
+  return ["node_modules", "next/dist", "react-dom"].some((s) => p.includes(s));
+}
+async function resolveOriginalPosition(compiledPos, projectRoot) {
+  try {
+    console.log("resolveOriginalPosition called with:", compiledPos);
+    let compiledFilePath = compiledPos.filePath;
+    compiledFilePath = cleanPathTurbopack(compiledFilePath);
+    console.log("After cleanPathTurbopack:", 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 = JSON.parse(sourceMapContent);
+    if ((!sourceMap.sources || sourceMap.sources.length === 0) && (!sourceMap.sections || sourceMap.sections.length === 0)) {
+      console.warn(
+        "Empty source map detected, cannot resolve position:",
+        sourceMapPath
+      );
+      return null;
+    }
+    if (sourceMap.sections) {
+      let matchingSection = null;
+      for (let i = sourceMap.sections.length - 1; i >= 0; i--) {
+        const section = sourceMap.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 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 = normalizeSourcePath(
+              originalPos.source || "",
+              projectRoot
+            );
+            return {
+              source,
+              line: originalPos.line,
+              column: originalPos.column ?? 0
+            };
+          }
+        } finally {
+          consumer2.destroy();
+        }
+      }
+      return null;
+    }
+    const consumer = await new SourceMapConsumer(sourceMap);
+    try {
+      const originalPos = consumer.originalPositionFor({
+        line: compiledPos.line,
+        column: compiledPos.column
+      });
+      if (originalPos.source && originalPos.line !== null) {
+        const source = 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);
+}
+async function handleRead(req) {
+  var _a;
+  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 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 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 NextResponse.json(
+      { success: false, error: "Failed to parse file" },
+      { status: 400 }
+    );
+  }
+  let componentName = "";
+  traverse(ast, {
+    ExportDefaultDeclaration(path2) {
+      var _a2;
+      if (t.isFunctionDeclaration(path2.node.declaration)) {
+        componentName = ((_a2 = path2.node.declaration.id) == null ? void 0 : _a2.name) || "";
+      }
+    },
+    ExportNamedDeclaration(path2) {
+      var _a2;
+      if (t.isFunctionDeclaration(path2.node.declaration)) {
+        componentName = ((_a2 = path2.node.declaration.id) == null ? void 0 : _a2.name) || "";
+      }
+    }
+  });
+  if (!componentName) {
+    return NextResponse.json({
+      success: true,
+      content,
+      lineStart: 1,
+      lineEnd: content.split("\n").length
+    });
+  }
+  const target = findTargetElement(ast, content, {
+    componentName,
+    lineNumber,
+    elementContext
+  });
+  if (!target) {
+    return NextResponse.json({
+      success: true,
+      content,
+      lineStart: 1,
+      lineEnd: content.split("\n").length
+    });
+  }
+  console.log(`[/read] Found element:`);
+  console.log(
+    `  Component: ${componentName} (lines ${target.componentStart}-${target.componentEnd})`
+  );
+  console.log(`  Target element: lines ${target.startLine}-${target.endLine}`);
+  console.log(
+    `  Element context: tagName=${elementContext == null ? void 0 : elementContext.tagName}, nthOfType=${elementContext == null ? void 0 : elementContext.nthOfType}`
+  );
+  const foundLines = content.split("\n").slice(
+    target.startLine - 1,
+    Math.min(target.startLine + 2, target.endLine)
+  );
+  console.log(`  Preview: ${(_a = foundLines[0]) == null ? void 0 : _a.trim()}`);
+  console.log(
+    `  textContent="${elementContext == null ? void 0 : elementContext.textContent}", className="${elementContext == null ? void 0 : elementContext.className}"`
+  );
+  const lines = content.split("\n");
+  const componentLines = lines.slice(
+    target.componentStart - 1,
+    target.componentEnd
+  );
+  const preview = componentLines.join("\n");
+  return 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
+  });
+}
+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 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 NextResponse.json(
+        { success: false, error: `File not found: ${normalizedPath}` },
+        { status: 404 }
+      );
+    }
+    if (!isPathSecure(absolutePath, projectRoot)) {
+      return 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 NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Undo error:", error);
+    return 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 NextResponse.json(
+        { success: false, error: "Missing debugStack" },
+        { status: 400 }
+      );
+    }
+    const compiledPos = parseDebugStack(debugStack);
+    if (!compiledPos) {
+      console.error("Could not parse debug stack:", debugStack);
+      return NextResponse.json(
+        { success: false, error: "Could not parse stack" },
+        { status: 422 }
+      );
+    }
+    console.log("Parsed compiled position:", compiledPos);
+    const originalPos = await resolveOriginalPosition(
+      compiledPos,
+      process.cwd()
+    );
+    if (!originalPos) {
+      console.error(
+        "Source map lookup failed for:",
+        compiledPos.filePath,
+        "at line",
+        compiledPos.line
+      );
+      return NextResponse.json(
+        { success: false, error: "Source map lookup failed" },
+        { status: 404 }
+      );
+    }
+    console.log("Resolved original position:", originalPos);
+    return NextResponse.json({
+      success: true,
+      filePath: originalPos.source,
+      lineNumber: originalPos.line,
+      columnNumber: originalPos.column ?? 0
+    });
+  } catch (error) {
+    console.error("Source resolve error:", error);
+    return 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 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 NextResponse.json(
+      { success: false, error: "File not found" },
+      { status: 404 }
+    );
+  }
+  return 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 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 NextResponse.json(
+        { success: false, error: "File not found" },
+        { status: 404 }
+      );
+    }
+    if (!isPathSecure(absolutePath, projectRoot)) {
+      return 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 NextResponse.json({
+      success: true,
+      isValid,
+      currentHash: hash,
+      currentSize: content.length,
+      lastModifiedTime: stats.mtimeMs
+    });
+  } catch (error) {
+    console.error("Validation error:", error);
+    return NextResponse.json(
+      { success: false, error: String(error) },
+      { status: 500 }
+    );
+  }
+}
+async function handleAIEditorRequest(req, context) {
+  const { path: path2 } = await context.params;
+  const endpoint = path2[0];
+  const method = req.method;
+  switch (endpoint) {
+    case "edit":
+      if (method === "POST") return handleEdit(req);
+      break;
+    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;
+  }
+  return NextResponse.json(
+    { error: `Unknown endpoint: ${endpoint}` },
+    { status: 404 }
+  );
+}
+export {
+  handleEdit as a,
+  handleRead as b,
+  handleUndo as c,
+  handleResolve as d,
+  handleAbsolutePath as e,
+  handleValidateSession as f,
+  fileExists$1 as g,
+  handleAIEditorRequest as h,
+  isPathSecure as i,
+  findTargetElement as j,
+  getJSXMemberName as k,
+  getAttributeValue as l,
+  parseDebugStack as m,
+  normalizePath as n,
+  resolveOriginalPosition as o,
+  parseFile as p,
+  getOriginalPositionFromDebugStack as q,
+  resolveFilePath as r,
+  scoreElementMatch as s,
+  validateDevMode as v
+};
+//# sourceMappingURL=index-BFa7H-uO.js.map