super-feedback-mcp 0.1.1 → 0.2.0

package/README.md

@@ -64,36 +64,47 @@ Or if published to npm:
 
 ## Available Tools
 
-### 1. `get_open_feedback`
+### 1. `get_feedback_summary`
 
-Retrieves all open (unresolved) feedback comments for your project.
+Gets a lightweight summary of all feedback for the project.
 
 **Parameters:**
-- `includeResolved` (boolean, optional): Include resolved comments too
 - `pageFilter` (string, optional): Filter to a specific page path (e.g., `/pricing`)
 
 **Returns:**
 - Project name
-- Total count of matching feedback
-- Array of feedback items with:
-  - Feedback text
-  - Element context (tag, text, test IDs, CSS classes)
-  - Page URL and extracted route path
-  - Hints for locating code (possible file paths, search terms)
+- Total count, open count, resolved count
+- Brief list of comments (ID, feedback preview, status, page path)
 
-### 2. `mark_feedback_resolved`
+Use this first to understand what feedback exists.
 
-Marks a feedback comment as resolved after you've fixed the issue.
+### 2. `get_comment_details`
+
+Gets complete details for a specific feedback comment.
 
 **Parameters:**
-- `commentId` (string): The comment ID to mark as resolved
+- `commentId` (string): The comment ID to get full details for
 
-### 3. `get_feedback_details`
+**Returns:**
+- Full feedback text and author info
+- Complete element data:
+  - `tagName`, `elementText`, `nearbyText`
+  - `section`, `sectionSelector`
+  - `selectors` (cssPath, nthPath, testId, id)
+  - `xpath`, `boundingBox`
+  - `parentChain`, `dataAttributes`, `computedStyles`
+- Page URL and file path hints
+- Search terms for code location
+- All replies/thread history
+- Design suggestions (if any)
+- Cross-element references (if any)
+
+### 3. `mark_feedback_resolved`
 
-Gets full details for a specific feedback comment.
+Marks a feedback comment as resolved after you've fixed the issue.
 
 **Parameters:**
-- `commentId` (string): The comment ID to get details for
+- `commentId` (string): The comment ID to mark as resolved
 
 ## Usage Example
 
@@ -102,10 +113,11 @@ In Cursor, you can ask the AI agent:
 > "Get all open feedback for my project and fix them"
 
 The agent will:
-1. Call `get_open_feedback` to retrieve all open comments
-2. For each comment, use the hints to search your codebase
-3. Make the necessary code changes
-4. Call `mark_feedback_resolved` to update the status
+1. Call `get_feedback_summary` to see what feedback exists
+2. Call `get_comment_details` for each open comment to get full context
+3. Use the selectors and hints to search your codebase
+4. Make the necessary code changes
+5. Call `mark_feedback_resolved` to update the status
 
 ## How It Works
 

package/dist/index.js

@@ -11,6 +11,15 @@ if (!ACCESS_CODE && !ADMIN_CODE) {
     console.error("Error: Either SUPER_FEEDBACK_ACCESS_CODE or SUPER_FEEDBACK_ADMIN_CODE environment variable is required");
     process.exit(1);
 }
+// Helper to get auth params
+function getAuthParams() {
+    const params = new URLSearchParams();
+    if (ACCESS_CODE)
+        params.set("accessCode", ACCESS_CODE);
+    if (ADMIN_CODE)
+        params.set("adminCode", ADMIN_CODE);
+    return params;
+}
 // API call helper
 async function callConvexAPI(endpoint, options) {
     const url = `${CONVEX_URL}${endpoint}`;
@@ -30,54 +39,71 @@ async function callConvexAPI(endpoint, options) {
 // Create MCP server
 const server = new McpServer({
     name: "super-feedback",
-    version: "0.1.0",
+    version: "0.2.0",
 });
-// Tool 1: Get open feedback
-server.registerTool("get_open_feedback", {
-    title: "Get Open Feedback",
-    description: `Retrieves all open (unresolved) feedback comments for the configured Super Feedback project.
-    
-Returns feedback formatted for AI consumption with:
-- The actual feedback/comment text
-- Element context (tag, text content, CSS classes, test IDs)
-- Page URL and likely file paths
-- Search hints to help locate the code
+// Tool 1: Get feedback summary (lightweight overview)
+server.registerTool("get_feedback_summary", {
+    title: "Get Feedback Summary",
+    description: `Gets a lightweight summary of all feedback for the project.
+
+Returns:
+- Total comment count
+- Open (unresolved) count  
+- Resolved count
+- List of comment IDs with brief info (feedback text, status, page path)
 
-Use this to understand what changes clients have requested.`,
+Use this first to understand what feedback exists, then use get_comment_details for full context on specific comments.`,
     inputSchema: {
-        includeResolved: z.boolean().optional().describe("Include resolved comments too (default: false)"),
         pageFilter: z.string().optional().describe("Filter to specific page path (e.g., '/pricing')"),
     },
     outputSchema: {
         projectName: z.string(),
         totalCount: z.number(),
-        comments: z.array(z.any()), // Flexible schema to allow all API fields
+        openCount: z.number(),
+        resolvedCount: z.number(),
+        comments: z.array(z.object({
+            id: z.string(),
+            index: z.number(),
+            feedback: z.string(),
+            status: z.string(),
+            page: z.string(),
+        })),
     },
-}, async ({ includeResolved = false, pageFilter }) => {
+}, async ({ pageFilter }) => {
     try {
-        // Build query params
-        const params = new URLSearchParams();
-        if (ACCESS_CODE)
-            params.set("accessCode", ACCESS_CODE);
-        if (ADMIN_CODE)
-            params.set("adminCode", ADMIN_CODE);
-        if (!includeResolved)
-            params.set("status", "open");
+        const params = getAuthParams();
+        params.set("status", "all"); // Get all to count properly
         if (pageFilter)
             params.set("page", pageFilter);
-        // Use the AI-optimized endpoint
-        const response = await callConvexAPI(`/api/feedback/ai?${params.toString()}`);
+        const response = await callConvexAPI(`/api/feedback/ai/summary?${params.toString()}`);
         const output = {
             projectName: response.project?.name || "Unknown Project",
             totalCount: response.totalCount,
-            comments: response.comments,
+            openCount: response.openCount,
+            resolvedCount: response.resolvedCount,
+            comments: response.comments.map(c => ({
+                id: c.id,
+                index: c.index,
+                feedback: c.feedback.slice(0, 100) + (c.feedback.length > 100 ? "..." : ""),
+                status: c.status,
+                page: c.page.path,
+            })),
         };
         // Create human-readable summary
-        const summary = response.comments.map(c => `#${c.index} [${c.status}] "${c.feedback}" on <${c.element?.tag || "element"}> "${c.element?.text || ""}" (${c.page.path})`).join("\n");
+        const openComments = response.comments.filter(c => c.status === "open");
+        const summary = openComments.length > 0
+            ? openComments.map(c => `• #${c.index} [${c.status}] "${c.feedback.slice(0, 50)}..." (${c.page.path})`).join("\n")
+            : "No open feedback.";
         return {
             content: [{
                     type: "text",
-                    text: `Found ${response.totalCount} feedback item(s):\n\n${summary}\n\nFull data available in structuredContent.`,
+                    text: `📊 Feedback Summary for "${response.project?.name || "Project"}"
+
+Total: ${response.totalCount} | Open: ${response.openCount} | Resolved: ${response.resolvedCount}
+
+${response.openCount > 0 ? `Open feedback:\n${summary}` : "All feedback resolved! 🎉"}
+
+Use get_comment_details(commentId) to get full context for a specific comment.`,
                 }],
             structuredContent: output,
         };
@@ -85,18 +111,116 @@ Use this to understand what changes clients have requested.`,
     catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
         return {
-            content: [{ type: "text", text: `Error fetching feedback: ${message}` }],
+            content: [{ type: "text", text: `Error fetching feedback summary: ${message}` }],
             isError: true,
         };
     }
 });
-// Tool 2: Mark feedback as resolved
+// Tool 2: Get full details for a single comment
+server.registerTool("get_comment_details", {
+    title: "Get Comment Details",
+    description: `Gets complete details for a specific feedback comment.
+
+Returns everything needed to work on the feedback:
+- Full feedback text and author info
+- Complete element data (tagName, text, selectors, xpath, boundingBox)
+- CSS selectors (cssPath, nthPath, testId, id)
+- Section context and nearby text
+- Page URL and file path hints
+- All replies/thread history
+- Design suggestions (if any)
+- Cross-element references (if any)
+
+Use this after get_feedback_summary to dive into a specific comment.`,
+    inputSchema: {
+        commentId: z.string().describe("The comment ID to get full details for"),
+    },
+    outputSchema: {
+        found: z.boolean(),
+        comment: z.any().nullable(),
+    },
+}, async ({ commentId }) => {
+    try {
+        const params = getAuthParams();
+        params.set("commentId", commentId);
+        const response = await callConvexAPI(`/api/feedback/ai/comment?${params.toString()}`);
+        if (!response.found || !response.comment) {
+            return {
+                content: [{ type: "text", text: `Comment ${commentId} not found` }],
+                structuredContent: { found: false, comment: null },
+            };
+        }
+        const c = response.comment;
+        const el = c.element;
+        // Build comprehensive text summary
+        let text = `📝 Feedback #${commentId}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💬 Feedback: "${c.feedback}"
+👤 Author: ${c.author}${c.authorEmail ? ` (${c.authorEmail})` : ""}
+📅 Created: ${c.createdAt}
+🔖 Status: ${c.status}
+🔗 Page: ${c.page.path}`;
+        if (el) {
+            text += `
+
+🎯 Element Details:
+├─ Tag: <${el.tagName}>
+├─ Text: "${el.elementText}"
+├─ Section: ${el.section}${el.sectionSelector ? ` (${el.sectionSelector})` : ""}
+├─ Nearby: "${el.nearbyText.slice(0, 100)}..."
+│
+├─ Selectors:
+│  ├─ CSS Path: ${el.selectors.cssPath}
+│  ├─ Nth Path: ${el.selectors.nthPath}
+│  ├─ XPath: ${el.xpath}
+│  ${el.selectors.testId ? `├─ Test ID: ${el.selectors.testId}` : ""}
+│  ${el.selectors.id ? `├─ Element ID: ${el.selectors.id}` : ""}
+│
+└─ Bounding Box: x:${el.boundingBox.x} y:${el.boundingBox.y} w:${el.boundingBox.width} h:${el.boundingBox.height}`;
+            if (el.dataAttributes && Object.keys(el.dataAttributes).length > 0) {
+                text += `\n\n📦 Data Attributes: ${JSON.stringify(el.dataAttributes)}`;
+            }
+        }
+        if (c.hints.searchTerms.length > 0) {
+            text += `\n\n🔍 Search Terms: ${c.hints.searchTerms.join(", ")}`;
+        }
+        if (c.hints.possibleFiles.length > 0) {
+            text += `\n📁 Possible Files: ${c.hints.possibleFiles.join(", ")}`;
+        }
+        if (c.replies && c.replies.length > 0) {
+            text += `\n\n💬 Thread (${c.replies.length} replies):`;
+            c.replies.forEach((r, i) => {
+                text += `\n${i + 1}. ${r.authorName}: "${r.content}" (${r.createdAt})`;
+            });
+        }
+        if (c.designSuggestion) {
+            text += `\n\n🎨 Design Suggestion:`;
+            c.designSuggestion.changes.forEach(change => {
+                text += `\n  ${change.property}: ${change.oldValue} → ${change.newValue}`;
+            });
+        }
+        return {
+            content: [{ type: "text", text }],
+            structuredContent: { found: true, comment: c },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+            content: [{ type: "text", text: `Error fetching comment details: ${message}` }],
+            structuredContent: { found: false, comment: null },
+            isError: true,
+        };
+    }
+});
+// Tool 3: Mark feedback as resolved
 server.registerTool("mark_feedback_resolved", {
     title: "Mark Feedback Resolved",
     description: `Marks a feedback comment as resolved after you've fixed the issue.
     
 Call this after making the code changes to update the feedback status.
-The comment ID can be obtained from get_open_feedback.
+The comment ID can be obtained from get_feedback_summary.
 
 Note: Requires SUPER_FEEDBACK_ADMIN_CODE to be configured.`,
     inputSchema: {
@@ -125,7 +249,7 @@ Note: Requires SUPER_FEEDBACK_ADMIN_CODE to be configured.`,
         });
         const output = {
             success: true,
-            message: `Comment ${commentId} marked as resolved`,
+            message: `✅ Comment ${commentId} marked as resolved`,
         };
         return {
             content: [{ type: "text", text: output.message }],
@@ -141,57 +265,6 @@ Note: Requires SUPER_FEEDBACK_ADMIN_CODE to be configured.`,
         };
     }
 });
-// Tool 3: Get feedback details
-server.registerTool("get_feedback_details", {
-    title: "Get Feedback Details",
-    description: `Gets full details for a specific feedback comment, including all element data and metadata.
-    
-Use this when you need more context about a specific piece of feedback.`,
-    inputSchema: {
-        commentId: z.string().describe("The comment ID to get details for"),
-    },
-    outputSchema: {
-        found: z.boolean(),
-        comment: z.any().nullable(),
-    },
-}, async ({ commentId }) => {
-    try {
-        // Build query params - get all comments and find the specific one
-        const params = new URLSearchParams();
-        if (ACCESS_CODE)
-            params.set("accessCode", ACCESS_CODE);
-        if (ADMIN_CODE)
-            params.set("adminCode", ADMIN_CODE);
-        params.set("status", "all"); // Get all statuses
-        const response = await callConvexAPI(`/api/feedback/ai?${params.toString()}`);
-        const comment = response.comments?.find(c => c.id === commentId);
-        if (!comment) {
-            return {
-                content: [{ type: "text", text: `Comment ${commentId} not found` }],
-                structuredContent: { found: false, comment: null },
-            };
-        }
-        const output = {
-            found: true,
-            comment: comment,
-        };
-        return {
-            content: [{
-                    type: "text",
-                    text: `Feedback: "${comment.feedback}"\nElement: <${comment.element?.tag || "unknown"}> "${comment.element?.text || ""}"\nPage: ${comment.page.path}\nSearch terms: ${comment.hints.searchTerms.join(", ")}`,
-                }],
-            structuredContent: output,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            structuredContent: { found: false, comment: null },
-            isError: true,
-        };
-    }
-});
 // Start the server
 async function main() {
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "super-feedback-mcp",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MCP server for Super Feedback - enables AI agents to query and resolve client feedback",
   "type": "module",
   "main": "dist/index.js",

package/src/index.ts

@@ -4,33 +4,74 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import * as z from "zod";
 
 // Types for API responses
-interface FeedbackComment {
+interface CommentSummary {
   id: string;
   index: number;
   feedback: string;
   author: string;
   status: string;
   createdAt: string;
-  element: {
-    tag?: string;
-    text?: string;
-    testId?: string;
-    id?: string;
-    cssPath?: string;
-    section?: string;
-    nearbyText?: string;
-    selector?: string;
-  } | null;
-  page: { url: string; path: string };
-  hints: { possibleFiles: string[]; searchTerms: string[] };
-  raw?: { elementSelector?: string; elementXPath?: string };
+  page: { path: string };
 }
 
-interface FeedbackResponse {
+interface FeedbackSummaryResponse {
   project: { id: string; name: string; url: string };
-  isAdmin?: boolean;
   totalCount: number;
-  comments: FeedbackComment[];
+  openCount: number;
+  resolvedCount: number;
+  comments: CommentSummary[];
+}
+
+interface Reply {
+  id: string;
+  content: string;
+  authorName: string;
+  createdAt: string;
+}
+
+interface FullCommentDetails {
+  id: string;
+  feedback: string;
+  author: string;
+  authorEmail?: string;
+  status: string;
+  createdAt: string;
+  editedAt?: string;
+  page: { url: string; path: string };
+  element: {
+    tagName: string;
+    elementText: string;
+    nearbyText: string;
+    section: string;
+    sectionSelector?: string;
+    selectors: {
+      id?: string;
+      testId?: string;
+      cssPath: string;
+      nthPath: string;
+    };
+    xpath: string;
+    boundingBox: { x: number; y: number; width: number; height: number };
+    parentChain?: Array<{ tag: string; id?: string; classes: string[] }>;
+    dataAttributes?: Record<string, string>;
+    computedStyles?: {
+      fontSize?: string;
+      fontWeight?: string;
+      color?: string;
+      backgroundColor?: string;
+    };
+  } | null;
+  hints: { possibleFiles: string[]; searchTerms: string[] };
+  replies: Reply[];
+  designSuggestion?: {
+    changes: Array<{ property: string; oldValue: string; newValue: string }>;
+    elementSelector: string;
+  };
+  references?: Array<{
+    selector: string;
+    elementText: string;
+    label?: string;
+  }>;
 }
 
 // Configuration from environment
@@ -44,6 +85,14 @@ if (!ACCESS_CODE && !ADMIN_CODE) {
   process.exit(1);
 }
 
+// Helper to get auth params
+function getAuthParams(): URLSearchParams {
+  const params = new URLSearchParams();
+  if (ACCESS_CODE) params.set("accessCode", ACCESS_CODE);
+  if (ADMIN_CODE) params.set("adminCode", ADMIN_CODE);
+  return params;
+}
+
 // API call helper
 async function callConvexAPI<T>(endpoint: string, options?: RequestInit): Promise<T> {
   const url = `${CONVEX_URL}${endpoint}`;
@@ -66,76 +115,209 @@ async function callConvexAPI<T>(endpoint: string, options?: RequestInit): Promis
 // Create MCP server
 const server = new McpServer({
   name: "super-feedback",
-  version: "0.1.0",
+  version: "0.2.0",
 });
 
-// Tool 1: Get open feedback
+// Tool 1: Get feedback summary (lightweight overview)
 server.registerTool(
-  "get_open_feedback",
+  "get_feedback_summary",
   {
-    title: "Get Open Feedback",
-    description: `Retrieves all open (unresolved) feedback comments for the configured Super Feedback project.
-    
-Returns feedback formatted for AI consumption with:
-- The actual feedback/comment text
-- Element context (tag, text content, CSS classes, test IDs)
-- Page URL and likely file paths
-- Search hints to help locate the code
+    title: "Get Feedback Summary",
+    description: `Gets a lightweight summary of all feedback for the project.
+
+Returns:
+- Total comment count
+- Open (unresolved) count  
+- Resolved count
+- List of comment IDs with brief info (feedback text, status, page path)
 
-Use this to understand what changes clients have requested.`,
+Use this first to understand what feedback exists, then use get_comment_details for full context on specific comments.`,
     inputSchema: {
-      includeResolved: z.boolean().optional().describe("Include resolved comments too (default: false)"),
       pageFilter: z.string().optional().describe("Filter to specific page path (e.g., '/pricing')"),
     },
     outputSchema: {
       projectName: z.string(),
       totalCount: z.number(),
-      comments: z.array(z.any()), // Flexible schema to allow all API fields
+      openCount: z.number(),
+      resolvedCount: z.number(),
+      comments: z.array(z.object({
+        id: z.string(),
+        index: z.number(),
+        feedback: z.string(),
+        status: z.string(),
+        page: z.string(),
+      })),
     },
   },
-  async ({ includeResolved = false, pageFilter }) => {
+  async ({ pageFilter }) => {
     try {
-      // Build query params
-      const params = new URLSearchParams();
-      if (ACCESS_CODE) params.set("accessCode", ACCESS_CODE);
-      if (ADMIN_CODE) params.set("adminCode", ADMIN_CODE);
-      if (!includeResolved) params.set("status", "open");
+      const params = getAuthParams();
+      params.set("status", "all"); // Get all to count properly
       if (pageFilter) params.set("page", pageFilter);
       
-      // Use the AI-optimized endpoint
-      const response = await callConvexAPI<FeedbackResponse>(
-        `/api/feedback/ai?${params.toString()}`
+      const response = await callConvexAPI<FeedbackSummaryResponse>(
+        `/api/feedback/ai/summary?${params.toString()}`
       );
       
       const output = {
         projectName: response.project?.name || "Unknown Project",
         totalCount: response.totalCount,
-        comments: response.comments,
+        openCount: response.openCount,
+        resolvedCount: response.resolvedCount,
+        comments: response.comments.map(c => ({
+          id: c.id,
+          index: c.index,
+          feedback: c.feedback.slice(0, 100) + (c.feedback.length > 100 ? "..." : ""),
+          status: c.status,
+          page: c.page.path,
+        })),
       };
       
       // Create human-readable summary
-      const summary = response.comments.map(c => 
-        `#${c.index} [${c.status}] "${c.feedback}" on <${c.element?.tag || "element"}> "${c.element?.text || ""}" (${c.page.path})`
-      ).join("\n");
+      const openComments = response.comments.filter(c => c.status === "open");
+      const summary = openComments.length > 0
+        ? openComments.map(c => `• #${c.index} [${c.status}] "${c.feedback.slice(0, 50)}..." (${c.page.path})`).join("\n")
+        : "No open feedback.";
       
       return {
         content: [{
           type: "text",
-          text: `Found ${response.totalCount} feedback item(s):\n\n${summary}\n\nFull data available in structuredContent.`,
+          text: `📊 Feedback Summary for "${response.project?.name || "Project"}"
+
+Total: ${response.totalCount} | Open: ${response.openCount} | Resolved: ${response.resolvedCount}
+
+${response.openCount > 0 ? `Open feedback:\n${summary}` : "All feedback resolved! 🎉"}
+
+Use get_comment_details(commentId) to get full context for a specific comment.`,
         }],
         structuredContent: output,
       };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       return {
-        content: [{ type: "text", text: `Error fetching feedback: ${message}` }],
+        content: [{ type: "text", text: `Error fetching feedback summary: ${message}` }],
         isError: true,
       };
     }
   }
 );
 
-// Tool 2: Mark feedback as resolved
+// Tool 2: Get full details for a single comment
+server.registerTool(
+  "get_comment_details",
+  {
+    title: "Get Comment Details",
+    description: `Gets complete details for a specific feedback comment.
+
+Returns everything needed to work on the feedback:
+- Full feedback text and author info
+- Complete element data (tagName, text, selectors, xpath, boundingBox)
+- CSS selectors (cssPath, nthPath, testId, id)
+- Section context and nearby text
+- Page URL and file path hints
+- All replies/thread history
+- Design suggestions (if any)
+- Cross-element references (if any)
+
+Use this after get_feedback_summary to dive into a specific comment.`,
+    inputSchema: {
+      commentId: z.string().describe("The comment ID to get full details for"),
+    },
+    outputSchema: {
+      found: z.boolean(),
+      comment: z.any().nullable(),
+    },
+  },
+  async ({ commentId }) => {
+    try {
+      const params = getAuthParams();
+      params.set("commentId", commentId);
+      
+      const response = await callConvexAPI<{ found: boolean; comment: FullCommentDetails | null }>(
+        `/api/feedback/ai/comment?${params.toString()}`
+      );
+      
+      if (!response.found || !response.comment) {
+        return {
+          content: [{ type: "text", text: `Comment ${commentId} not found` }],
+          structuredContent: { found: false, comment: null },
+        };
+      }
+      
+      const c = response.comment;
+      const el = c.element;
+      
+      // Build comprehensive text summary
+      let text = `📝 Feedback #${commentId}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💬 Feedback: "${c.feedback}"
+👤 Author: ${c.author}${c.authorEmail ? ` (${c.authorEmail})` : ""}
+📅 Created: ${c.createdAt}
+🔖 Status: ${c.status}
+🔗 Page: ${c.page.path}`;
+
+      if (el) {
+        text += `
+
+🎯 Element Details:
+├─ Tag: <${el.tagName}>
+├─ Text: "${el.elementText}"
+├─ Section: ${el.section}${el.sectionSelector ? ` (${el.sectionSelector})` : ""}
+├─ Nearby: "${el.nearbyText.slice(0, 100)}..."
+│
+├─ Selectors:
+│  ├─ CSS Path: ${el.selectors.cssPath}
+│  ├─ Nth Path: ${el.selectors.nthPath}
+│  ├─ XPath: ${el.xpath}
+│  ${el.selectors.testId ? `├─ Test ID: ${el.selectors.testId}` : ""}
+│  ${el.selectors.id ? `├─ Element ID: ${el.selectors.id}` : ""}
+│
+└─ Bounding Box: x:${el.boundingBox.x} y:${el.boundingBox.y} w:${el.boundingBox.width} h:${el.boundingBox.height}`;
+
+        if (el.dataAttributes && Object.keys(el.dataAttributes).length > 0) {
+          text += `\n\n📦 Data Attributes: ${JSON.stringify(el.dataAttributes)}`;
+        }
+      }
+
+      if (c.hints.searchTerms.length > 0) {
+        text += `\n\n🔍 Search Terms: ${c.hints.searchTerms.join(", ")}`;
+      }
+
+      if (c.hints.possibleFiles.length > 0) {
+        text += `\n📁 Possible Files: ${c.hints.possibleFiles.join(", ")}`;
+      }
+
+      if (c.replies && c.replies.length > 0) {
+        text += `\n\n💬 Thread (${c.replies.length} replies):`;
+        c.replies.forEach((r, i) => {
+          text += `\n${i + 1}. ${r.authorName}: "${r.content}" (${r.createdAt})`;
+        });
+      }
+
+      if (c.designSuggestion) {
+        text += `\n\n🎨 Design Suggestion:`;
+        c.designSuggestion.changes.forEach(change => {
+          text += `\n  ${change.property}: ${change.oldValue} → ${change.newValue}`;
+        });
+      }
+
+      return {
+        content: [{ type: "text", text }],
+        structuredContent: { found: true, comment: c },
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [{ type: "text", text: `Error fetching comment details: ${message}` }],
+        structuredContent: { found: false, comment: null },
+        isError: true,
+      };
+    }
+  }
+);
+
+// Tool 3: Mark feedback as resolved
 server.registerTool(
   "mark_feedback_resolved",
   {
@@ -143,7 +325,7 @@ server.registerTool(
     description: `Marks a feedback comment as resolved after you've fixed the issue.
     
 Call this after making the code changes to update the feedback status.
-The comment ID can be obtained from get_open_feedback.
+The comment ID can be obtained from get_feedback_summary.
 
 Note: Requires SUPER_FEEDBACK_ADMIN_CODE to be configured.`,
     inputSchema: {
@@ -175,7 +357,7 @@ Note: Requires SUPER_FEEDBACK_ADMIN_CODE to be configured.`,
       
       const output = {
         success: true,
-        message: `Comment ${commentId} marked as resolved`,
+        message: `✅ Comment ${commentId} marked as resolved`,
       };
       
       return {
@@ -193,66 +375,6 @@ Note: Requires SUPER_FEEDBACK_ADMIN_CODE to be configured.`,
   }
 );
 
-// Tool 3: Get feedback details
-server.registerTool(
-  "get_feedback_details",
-  {
-    title: "Get Feedback Details",
-    description: `Gets full details for a specific feedback comment, including all element data and metadata.
-    
-Use this when you need more context about a specific piece of feedback.`,
-    inputSchema: {
-      commentId: z.string().describe("The comment ID to get details for"),
-    },
-    outputSchema: {
-      found: z.boolean(),
-      comment: z.any().nullable(),
-    },
-  },
-  async ({ commentId }) => {
-    try {
-      // Build query params - get all comments and find the specific one
-      const params = new URLSearchParams();
-      if (ACCESS_CODE) params.set("accessCode", ACCESS_CODE);
-      if (ADMIN_CODE) params.set("adminCode", ADMIN_CODE);
-      params.set("status", "all"); // Get all statuses
-      
-      const response = await callConvexAPI<FeedbackResponse>(
-        `/api/feedback/ai?${params.toString()}`
-      );
-      
-      const comment = response.comments?.find(c => c.id === commentId);
-      
-      if (!comment) {
-        return {
-          content: [{ type: "text", text: `Comment ${commentId} not found` }],
-          structuredContent: { found: false, comment: null },
-        };
-      }
-      
-      const output = {
-        found: true,
-        comment: comment,
-      };
-      
-      return {
-        content: [{
-          type: "text",
-          text: `Feedback: "${comment.feedback}"\nElement: <${comment.element?.tag || "unknown"}> "${comment.element?.text || ""}"\nPage: ${comment.page.path}\nSearch terms: ${comment.hints.searchTerms.join(", ")}`,
-        }],
-        structuredContent: output,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        structuredContent: { found: false, comment: null },
-        isError: true,
-      };
-    }
-  }
-);
-
 // Start the server
 async function main() {
   const transport = new StdioServerTransport();