next-ai-editor 0.1.2 → 0.2.0

package/dist/{index-3OMXRwpD.js → comments-D3m0RsOO.js}

@@ -1,14 +1,16 @@
 import { NextResponse } from "next/server";
-import fs from "fs/promises";
+import fs, { readFile, writeFile, mkdir } from "fs/promises";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { SystemMessage, HumanMessage } from "@langchain/core/messages";
-import path from "path";
+import path, { join } from "path";
 import * as parser from "@babel/parser";
 import traverse from "@babel/traverse";
 import * as t from "@babel/types";
 import { SourceMapConsumer } from "@jridgewell/source-map";
 import { c as cleanPath, s as shouldSkipPath, n as normalizeSourcePath } from "./path-utils-Bai2xKx9.js";
 import crypto from "crypto";
+import { unstable_v2_resumeSession, unstable_v2_createSession } from "@anthropic-ai/claude-agent-sdk";
+import { existsSync } from "fs";
 function validateDevMode() {
   if (process.env.NODE_ENV !== "development") {
     return NextResponse.json(
@@ -88,6 +90,11 @@ function extractComponentName(ast) {
         if (t.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.isExportSpecifier(specifier) && t.isIdentifier(specifier.exported)) {
+          componentName = specifier.exported.name;
+        }
       }
     }
   });
@@ -239,16 +246,34 @@ function findTargetElement(ast, fileContent, options) {
       componentEnd
     };
   }
-  if ((elementContext == null ? void 0 : elementContext.nthOfType) && elementContext.tagName) {
+  if (elementContext == null ? void 0 : elementContext.tagName) {
     const allOfTag = allElementsByTag.get(elementContext.tagName);
-    if (allOfTag && allOfTag.length >= elementContext.nthOfType) {
-      const target = allOfTag[elementContext.nthOfType - 1];
-      return {
-        startLine: target.startLine,
-        endLine: target.endLine,
-        componentStart,
-        componentEnd
-      };
+    if (allOfTag && allOfTag.length > 0) {
+      if (elementContext.textContent || elementContext.className) {
+        for (const elem of allOfTag) {
+          if (t.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 = [];
@@ -695,6 +720,30 @@ function parseDebugStack(stack) {
   );
   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);
@@ -995,7 +1044,10 @@ async function handleRead(req) {
       let resolvedParentPath = parentFilePath;
       let resolvedParentLine = parentLine;
       let resolvedParentComponentName = parentComponentName;
-      if (resolvedParentComponentName && parentDebugStack) {
+      if (!resolvedParentComponentName && parentDebugStack) {
+        resolvedParentComponentName = extractComponentNameFromStack(parentDebugStack) || "";
+      }
+      if (parentDebugStack) {
         const compiledPos = parseDebugStack(parentDebugStack);
         if (compiledPos) {
           const originalPos = await resolveOriginalPosition(
@@ -1027,12 +1079,14 @@ async function handleRead(req) {
           const parentTarget = findTargetElement(parentAst, parentContent, {
             componentName: resolvedParentComponentName,
             lineNumber: 0,
-            // Don't use line number - rely on nthOfType to find correct instance
+            // Don't use line number - rely on element context to find correct instance
             elementContext: {
               tagName: componentName,
               // Search for child component usage
-              nthOfType: nthOfType2
+              nthOfType: nthOfType2,
               // Find specific instance if key is numeric
+              textContent: textContent || void 0
+              // Use text content to match the specific instance
             }
           });
           if (parentTarget) {
@@ -1054,6 +1108,7 @@ async function handleRead(req) {
         }
       }
     } catch (error) {
+      console.error("Error resolving parent instance:", error);
     }
   }
   return NextResponse.json({
@@ -1461,6 +1516,361 @@ Generate 6-8 initial suggestions:`;
     return null;
   }
 }
+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 = unstable_v2_resumeSession(config.sessionId, sessionOptions);
+    } else {
+      session = 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 NextResponse.json(
+        { error: "threadId and message are required" },
+        { status: 400 }
+      );
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      return 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 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 NextResponse.json(
+      { error: String(error) },
+      { status: 500 }
+    );
+  }
+}
 async function handleAIEditorRequest(req, context) {
   const { path: path2 } = await context.params;
   const endpoint = path2[0];
@@ -1487,12 +1897,79 @@ async function handleAIEditorRequest(req, context) {
     case "suggestions":
       if (method === "GET") return handleSuggestions(req);
       break;
+    case "chat":
+      if (method === "POST") return handleChat(req);
+      break;
   }
   return 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 join(getProjectRoot(), STORAGE_DIR, STORAGE_FILE);
+}
+async function ensureStorageDir() {
+  const dir = join(getProjectRoot(), STORAGE_DIR);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+async function handleCommentsRequest(request) {
+  if (process.env.NODE_ENV !== "development") {
+    return NextResponse.json(
+      { error: "Comments API only available in development" },
+      { status: 403 }
+    );
+  }
+  try {
+    if (request.method === "GET") {
+      const storagePath = getStoragePath();
+      if (!existsSync(storagePath)) {
+        return NextResponse.json({ comments: [] });
+      }
+      const data = await readFile(storagePath, "utf-8");
+      const comments = JSON.parse(data);
+      return 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 writeFile(storagePath, JSON.stringify(comments, null, 2), "utf-8");
+        return NextResponse.json({ success: true });
+      }
+      if (action === "clear") {
+        await ensureStorageDir();
+        const storagePath = getStoragePath();
+        await writeFile(storagePath, JSON.stringify([]), "utf-8");
+        return NextResponse.json({ success: true });
+      }
+      return NextResponse.json(
+        { error: "Invalid action" },
+        { status: 400 }
+      );
+    }
+    return NextResponse.json(
+      { error: "Method not allowed" },
+      { status: 405 }
+    );
+  } catch (error) {
+    console.error("Comment storage error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
 export {
   handleEdit as a,
   handleRead as b,
@@ -1502,21 +1979,23 @@ export {
   handleValidateSession as f,
   handleSuggestions as g,
   handleAIEditorRequest as h,
-  isPathSecure as i,
-  fileExists$1 as j,
-  extractComponentName as k,
-  validateGeneratedCode as l,
-  findTargetElement as m,
+  handleCommentsRequest as i,
+  isPathSecure as j,
+  fileExists$1 as k,
+  extractComponentName as l,
+  validateGeneratedCode as m,
   normalizePath as n,
-  getJSXMemberName as o,
+  findTargetElement as o,
   parseFile as p,
-  getAttributeValue as q,
+  getJSXMemberName as q,
   resolveFilePath as r,
   scoreElementMatch as s,
-  parseDebugStack as t,
-  parseDebugStackFrames as u,
+  getAttributeValue as t,
+  parseDebugStack as u,
   validateDevMode as v,
-  resolveOriginalPosition as w,
-  getOriginalPositionFromDebugStack as x
+  extractComponentNameFromStack as w,
+  parseDebugStackFrames as x,
+  resolveOriginalPosition as y,
+  getOriginalPositionFromDebugStack as z
 };
-//# sourceMappingURL=index-3OMXRwpD.js.map
+//# sourceMappingURL=comments-D3m0RsOO.js.map