next-ai-editor 0.1.3 → 0.2.1

package/dist/{index-CNJqd4EQ.cjs → comments-Daur80r4.cjs}

@@ -10,6 +10,8 @@ const t = require("@babel/types");
 const sourceMap = require("@jridgewell/source-map");
 const pathUtils = require("./path-utils-DYzEWUGy.cjs");
 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) {
@@ -1533,6 +1535,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 = 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 handleAIEditorRequest(req, context) {
   const { path: path2 } = await context.params;
   const endpoint = path2[0];
@@ -1559,12 +1916,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 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;
@@ -1574,6 +1998,7 @@ exports.getJSXMemberName = getJSXMemberName;
 exports.getOriginalPositionFromDebugStack = getOriginalPositionFromDebugStack;
 exports.handleAIEditorRequest = handleAIEditorRequest;
 exports.handleAbsolutePath = handleAbsolutePath;
+exports.handleCommentsRequest = handleCommentsRequest;
 exports.handleEdit = handleEdit;
 exports.handleRead = handleRead;
 exports.handleResolve = handleResolve;
@@ -1590,4 +2015,4 @@ exports.resolveOriginalPosition = resolveOriginalPosition;
 exports.scoreElementMatch = scoreElementMatch;
 exports.validateDevMode = validateDevMode;
 exports.validateGeneratedCode = validateGeneratedCode;
-//# sourceMappingURL=index-CNJqd4EQ.cjs.map
+//# sourceMappingURL=comments-Daur80r4.cjs.map