@vibetasks/mcp-server 0.2.2 → 0.4.0

package/dist/index.js

@@ -18,14 +18,19 @@ function setupTools(taskOps) {
     // create_task
     {
       name: "create_task",
-      description: "Create a new task in TaskFlow. Can optionally be a subtask by providing parent_task_id.",
+      description: "Create a new task in VibeTasks. Use this instead of TodoWrite - tasks persist across sessions and sync everywhere.",
       inputSchema: z.object({
         title: z.string().describe("Task title (required)"),
-        notes: z.string().optional().describe("Task notes in markdown"),
+        description: z.string().optional().describe("Brief description of what this task involves"),
+        notes: z.string().optional().describe("Detailed notes in markdown"),
+        subtasks: z.array(z.object({
+          title: z.string().describe("Subtask title"),
+          done: z.boolean().default(false).describe("Is this subtask completed?"),
+          notes: z.string().optional().describe("Progress notes for this subtask")
+        })).optional().describe("Inline subtasks - each with title, done status, and optional notes"),
         due_date: z.string().optional().describe("Due date (ISO 8601 format)"),
         priority: z.enum(["none", "low", "medium", "high"]).default("none").describe("Task priority"),
-        tags: z.array(z.string()).optional().describe("Tag names to attach"),
-        parent_task_id: z.string().optional().describe("Parent task ID to create this as a subtask")
+        tags: z.array(z.string()).optional().describe("Tag names to attach")
       }),
       handler: async (args, taskOps2) => {
         let tagIds = [];
@@ -35,13 +40,20 @@ function setupTools(taskOps) {
             tagIds.push(tag.id);
           }
         }
+        const subtasksJson = args.subtasks?.map((st) => ({
+          id: crypto.randomUUID(),
+          title: st.title,
+          done: st.done || false,
+          notes: st.notes
+        })) || [];
         const task = await taskOps2.createTask({
           title: args.title,
+          description: args.description,
           notes: args.notes,
           notes_format: "markdown",
           due_date: args.due_date,
           priority: args.priority,
-          parent_task_id: args.parent_task_id
+          subtasks_json: subtasksJson
         });
         if (tagIds.length > 0) {
           await taskOps2.linkTaskTags(task.id, tagIds);
@@ -56,9 +68,10 @@ function setupTools(taskOps) {
                   task: {
                     id: task.id,
                     title: task.title,
+                    description: task.description,
                     priority: task.priority,
                     due_date: task.due_date,
-                    parent_task_id: task.parent_task_id,
+                    subtasks: subtasksJson,
                     created_at: task.created_at
                   }
                 },
@@ -515,8 +528,644 @@ Generated by TaskFlow MCP Server`;
           ]
         };
       }
+    },
+    // archive_task
+    {
+      name: "archive_task",
+      description: "Archive a completed task. Moves the task to archived status, hiding it from default views. Use this to clean up completed tasks without deleting them.",
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID to archive")
+      }),
+      handler: async (args, taskOps2) => {
+        const task = await taskOps2.archiveTask(args.task_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    status: "archived",
+                    archived_at: task.archived_at
+                  },
+                  message: "Task archived successfully. Use get_archived_tasks to view archived tasks."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // get_archived_tasks
+    {
+      name: "get_archived_tasks",
+      description: "Get all archived tasks. Returns tasks that have been archived, sorted by archive date (most recent first).",
+      inputSchema: z.object({
+        limit: z.number().default(50).describe("Maximum number of archived tasks to return")
+      }),
+      handler: async (args, taskOps2) => {
+        const tasks = await taskOps2.getArchivedTasks(args.limit);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  archived_tasks: tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    completed_at: t.completed_at,
+                    archived_at: t.archived_at,
+                    priority: t.priority,
+                    tags: t.tags?.map((tag) => tag.name) || []
+                  })),
+                  count: tasks.length
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // unarchive_task
+    {
+      name: "unarchive_task",
+      description: "Restore an archived task. Moves the task from archived status back to done (or optionally another status).",
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID to unarchive"),
+        restore_status: z.enum(["todo", "vibing", "done"]).default("done").describe("Status to restore the task to (default: done)")
+      }),
+      handler: async (args, taskOps2) => {
+        const task = await taskOps2.unarchiveTask(args.task_id, args.restore_status);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    status: task.status
+                  },
+                  message: `Task restored to '${args.restore_status}' status.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // capture_error
+    {
+      name: "capture_error",
+      description: "Parse error text from clipboard, terminal, or direct paste. Extracts structured information from common error formats (Node.js, Python, Expo, webpack, TypeScript, etc.) for AI consumption.",
+      inputSchema: z.object({
+        error_text: z.string().describe("The raw error text to parse"),
+        source: z.enum(["terminal", "browser", "expo", "other"]).default("other").describe("Source of the error (helps with parsing)")
+      }),
+      handler: async (args, _taskOps) => {
+        const { error_text, source } = args;
+        const parsed = parseError(error_text, source);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  ...parsed
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // summarize_errors
+    {
+      name: "summarize_errors",
+      description: "Summarize and deduplicate large error logs (up to thousands of lines). Groups errors by type/file, deduplicates similar errors using pattern matching, filters out node_modules frames, and returns a condensed summary (50-100 lines max).",
+      inputSchema: z.object({
+        log_text: z.string().describe("The raw log output containing errors"),
+        max_lines: z.number().default(100).describe("Maximum lines in the summary output (default: 100)")
+      }),
+      handler: async (args, _taskOps) => {
+        const { log_text, max_lines = 100 } = args;
+        const result = summarizeErrors(log_text, max_lines);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  ...result
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // update_subtask
+    {
+      name: "update_subtask",
+      description: "Update a subtask within a task. Mark it done, add progress notes, or update the title. Use this to track progress on individual steps.",
+      inputSchema: z.object({
+        task_id: z.string().describe("Parent task ID"),
+        subtask_id: z.string().describe("Subtask ID to update"),
+        done: z.boolean().optional().describe("Mark subtask as done/not done"),
+        title: z.string().optional().describe("Update subtask title"),
+        notes: z.string().optional().describe('Add progress notes (e.g., "Completed auth module, need to test edge cases")')
+      }),
+      handler: async (args, taskOps2) => {
+        const task = await taskOps2.getTask(args.task_id);
+        const subtasks = task.subtasks_json || task.subtasks || [];
+        const subtaskIndex = subtasks.findIndex((st) => st.id === args.subtask_id);
+        if (subtaskIndex === -1) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ success: false, error: `Subtask ${args.subtask_id} not found` }, null, 2)
+              }
+            ]
+          };
+        }
+        if (args.done !== void 0) subtasks[subtaskIndex].done = args.done;
+        if (args.title !== void 0) subtasks[subtaskIndex].title = args.title;
+        if (args.notes !== void 0) subtasks[subtaskIndex].notes = args.notes;
+        const updated = await taskOps2.updateTask(args.task_id, { subtasks_json: subtasks });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task_id: args.task_id,
+                  subtask: subtasks[subtaskIndex],
+                  all_subtasks: subtasks,
+                  progress: `${subtasks.filter((s) => s.done).length}/${subtasks.length} done`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // add_subtask
+    {
+      name: "add_subtask",
+      description: "Add a new subtask to an existing task. Use this when you discover new steps while working.",
+      inputSchema: z.object({
+        task_id: z.string().describe("Parent task ID"),
+        title: z.string().describe("Subtask title"),
+        notes: z.string().optional().describe("Optional notes")
+      }),
+      handler: async (args, taskOps2) => {
+        const task = await taskOps2.getTask(args.task_id);
+        const subtasks = task.subtasks_json || task.subtasks || [];
+        const newSubtask = {
+          id: crypto.randomUUID(),
+          title: args.title,
+          done: false,
+          notes: args.notes
+        };
+        subtasks.push(newSubtask);
+        await taskOps2.updateTask(args.task_id, { subtasks_json: subtasks });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task_id: args.task_id,
+                  new_subtask: newSubtask,
+                  total_subtasks: subtasks.length
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // get_task_images
+    {
+      name: "get_task_images",
+      description: "Get image attachments for a task. Returns signed URLs that can be viewed. Use this to see mockups, screenshots, or error images attached to a task.",
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID to get images for")
+      }),
+      handler: async (args, taskOps2) => {
+        const task = await taskOps2.getTask(args.task_id);
+        const attachments = task.attachments || [];
+        const images = attachments.filter((a) => a.is_image || a.file_type?.startsWith("image/"));
+        const imageData = await Promise.all(
+          images.map(async (img) => {
+            const url = await taskOps2.getAttachmentUrl(img.storage_path);
+            return {
+              id: img.id,
+              file_name: img.file_name,
+              file_type: img.file_type,
+              url,
+              alt_text: img.alt_text,
+              ai_description: img.ai_description
+            };
+          })
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task_id: args.task_id,
+                  task_title: task.title,
+                  images: imageData,
+                  count: imageData.length
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // get_current_task
+    {
+      name: "get_current_task",
+      description: 'Get the task you should be working on right now. Returns the first "vibing" task with full details including subtasks, description, context notes, and images. Call this at the start of a session to know where you left off.',
+      inputSchema: z.object({}),
+      handler: async (_args, taskOps2) => {
+        const allTasks = await taskOps2.getTasks("all");
+        const vibingTasks = allTasks.filter((t) => t.status === "vibing");
+        if (vibingTasks.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    success: true,
+                    current_task: null,
+                    message: "No tasks currently vibing. Use list_tasks to see available tasks, or create_task to add one."
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        const task = await taskOps2.getTask(vibingTasks[0].id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  current_task: {
+                    id: task.id,
+                    title: task.title,
+                    description: task.description,
+                    context_notes: task.context_notes,
+                    subtasks: task.subtasks_json || task.subtasks || [],
+                    progress: task.subtasks_json ? `${task.subtasks_json.filter((s) => s.done).length}/${task.subtasks_json.length} subtasks done` : null,
+                    priority: task.priority,
+                    has_images: (task.attachments || []).some((a) => a.is_image || a.file_type?.startsWith("image/"))
+                  },
+                  other_vibing_count: vibingTasks.length - 1
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    }
+  ];
+}
+function parseError(errorText, source) {
+  const lines = errorText.split("\n");
+  let errorType = "Unknown";
+  let file = null;
+  let line = null;
+  let column = null;
+  let message = "";
+  const stackFrames = [];
+  const patterns = {
+    // Node.js/JavaScript: "TypeError: Cannot read property 'x' of undefined"
+    jsError: /^(\w+Error):\s*(.+)$/,
+    // Python: "TypeError: unsupported operand type(s)"
+    pythonError: /^(\w+Error|Exception):\s*(.+)$/,
+    // Stack frame patterns
+    // Node.js: "    at functionName (file.js:10:5)"
+    nodeStackFrame: /^\s*at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?$/,
+    // Python: '  File "script.py", line 10, in function_name'
+    pythonStackFrame: /^\s*File\s+"([^"]+)",\s*line\s*(\d+)(?:,\s*in\s+(.+))?$/,
+    // Webpack/bundler: "ERROR in ./src/file.tsx:10:5"
+    webpackError: /^ERROR\s+in\s+\.?(.+?):(\d+):(\d+)$/,
+    // TypeScript: "src/file.ts(10,5): error TS2345:"
+    tsError: /^(.+?)\((\d+),(\d+)\):\s*(error\s+TS\d+):\s*(.+)$/,
+    // Expo/React Native: "Error: ..." with component stack
+    expoError: /^Error:\s*(.+)$/,
+    // Generic file:line:col pattern
+    genericFileLine: /([^\s:]+\.[a-zA-Z]+):(\d+)(?::(\d+))?/,
+    // ESLint/Prettier style: "  10:5  error  Message"
+    lintError: /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+)$/
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const trimmedLine = lines[i].trim();
+    if (!trimmedLine) continue;
+    const tsMatch = trimmedLine.match(patterns.tsError);
+    if (tsMatch) {
+      file = tsMatch[1];
+      line = parseInt(tsMatch[2], 10);
+      column = parseInt(tsMatch[3], 10);
+      errorType = tsMatch[4];
+      message = tsMatch[5];
+      continue;
+    }
+    const webpackMatch = trimmedLine.match(patterns.webpackError);
+    if (webpackMatch) {
+      file = webpackMatch[1];
+      line = parseInt(webpackMatch[2], 10);
+      column = parseInt(webpackMatch[3], 10);
+      errorType = "WebpackError";
+      continue;
+    }
+    const jsMatch = trimmedLine.match(patterns.jsError);
+    if (jsMatch && !message) {
+      errorType = jsMatch[1];
+      message = jsMatch[2];
+      continue;
+    }
+    const pythonMatch = trimmedLine.match(patterns.pythonError);
+    if (pythonMatch && !message) {
+      errorType = pythonMatch[1];
+      message = pythonMatch[2];
+      continue;
+    }
+    if (source === "expo") {
+      const expoMatch = trimmedLine.match(patterns.expoError);
+      if (expoMatch && !message) {
+        errorType = "ExpoError";
+        message = expoMatch[1];
+        continue;
+      }
+    }
+    const nodeFrameMatch = trimmedLine.match(patterns.nodeStackFrame);
+    if (nodeFrameMatch) {
+      const framePath = nodeFrameMatch[2];
+      const frameLine = nodeFrameMatch[3];
+      const frameCol = nodeFrameMatch[4];
+      const funcName = nodeFrameMatch[1] || "<anonymous>";
+      if (!isLibraryFrame(framePath)) {
+        stackFrames.push(`${funcName} at ${framePath}:${frameLine}:${frameCol}`);
+        if (!file) {
+          file = framePath;
+          line = parseInt(frameLine, 10);
+          column = parseInt(frameCol, 10);
+        }
+      }
+      continue;
+    }
+    const pythonFrameMatch = trimmedLine.match(patterns.pythonStackFrame);
+    if (pythonFrameMatch) {
+      const framePath = pythonFrameMatch[1];
+      const frameLine = pythonFrameMatch[2];
+      const funcName = pythonFrameMatch[3] || "<module>";
+      if (!isLibraryFrame(framePath)) {
+        stackFrames.push(`${funcName} at ${framePath}:${frameLine}`);
+        file = framePath;
+        line = parseInt(frameLine, 10);
+      }
+      continue;
+    }
+    const lintMatch = trimmedLine.match(patterns.lintError);
+    if (lintMatch) {
+      line = parseInt(lintMatch[1], 10);
+      column = parseInt(lintMatch[2], 10);
+      errorType = lintMatch[3] === "error" ? "LintError" : "LintWarning";
+      message = lintMatch[4];
+      continue;
+    }
+    if (!file) {
+      const genericMatch = trimmedLine.match(patterns.genericFileLine);
+      if (genericMatch && !isLibraryFrame(genericMatch[1])) {
+        file = genericMatch[1];
+        line = parseInt(genericMatch[2], 10);
+        column = genericMatch[3] ? parseInt(genericMatch[3], 10) : null;
+      }
+    }
+    if (errorType !== "Unknown" && !message && trimmedLine && !trimmedLine.startsWith("at ")) {
+      message = trimmedLine;
     }
+  }
+  if (!message) {
+    message = lines.find((l) => l.trim())?.trim() || "No error message found";
+  }
+  const rawExcerpt = lines.slice(0, 10).join("\n");
+  return {
+    error_type: errorType,
+    file,
+    line,
+    column,
+    message,
+    stack_summary: stackFrames.slice(0, 5),
+    // Limit to 5 frames
+    raw_excerpt: rawExcerpt
+  };
+}
+function isLibraryFrame(filePath) {
+  const libraryPatterns = [
+    /node_modules/,
+    /site-packages/,
+    /dist-packages/,
+    /\.pnpm/,
+    /\.yarn/,
+    /internal\//,
+    /^node:/,
+    /<anonymous>/,
+    /webpack-internal/,
+    /react-dom/,
+    /react-native/,
+    /expo/,
+    /metro/,
+    /hermes/
+  ];
+  return libraryPatterns.some((pattern) => pattern.test(filePath));
+}
+function summarizeErrors(logText, maxLines = 100) {
+  const errorTypePatterns = [
+    { type: "TypeError", pattern: /TypeError:\s*(.+)/i },
+    { type: "SyntaxError", pattern: /SyntaxError:\s*(.+)/i },
+    { type: "ReferenceError", pattern: /ReferenceError:\s*(.+)/i },
+    { type: "RangeError", pattern: /RangeError:\s*(.+)/i },
+    { type: "EvalError", pattern: /EvalError:\s*(.+)/i },
+    { type: "URIError", pattern: /URIError:\s*(.+)/i },
+    { type: "AggregateError", pattern: /AggregateError:\s*(.+)/i },
+    { type: "InternalError", pattern: /InternalError:\s*(.+)/i },
+    { type: "AssertionError", pattern: /AssertionError:\s*(.+)/i },
+    { type: "ValidationError", pattern: /ValidationError:\s*(.+)/i },
+    { type: "NetworkError", pattern: /NetworkError:\s*(.+)/i },
+    { type: "TimeoutError", pattern: /TimeoutError:\s*(.+)/i },
+    { type: "ENOENT", pattern: /ENOENT:\s*(.+)/i },
+    { type: "EACCES", pattern: /EACCES:\s*(.+)/i },
+    { type: "ECONNREFUSED", pattern: /ECONNREFUSED:\s*(.+)/i },
+    { type: "ETIMEDOUT", pattern: /ETIMEDOUT:\s*(.+)/i },
+    { type: "ModuleNotFoundError", pattern: /ModuleNotFoundError:\s*(.+)/i },
+    { type: "ImportError", pattern: /ImportError:\s*(.+)/i },
+    { type: "AttributeError", pattern: /AttributeError:\s*(.+)/i },
+    { type: "KeyError", pattern: /KeyError:\s*(.+)/i },
+    { type: "ValueError", pattern: /ValueError:\s*(.+)/i },
+    { type: "IndexError", pattern: /IndexError:\s*(.+)/i },
+    { type: "Error", pattern: /(?:^|\s)Error:\s*(.+)/i },
+    { type: "Warning", pattern: /(?:^|\s)(?:Warning|WARN):\s*(.+)/i },
+    { type: "Failed", pattern: /(?:FAILED|Failed|failed):\s*(.+)/i },
+    { type: "Exception", pattern: /Exception:\s*(.+)/i }
   ];
+  const lines = logText.split("\n");
+  const totalLines = lines.length;
+  const errorMap = /* @__PURE__ */ new Map();
+  let totalErrorCount = 0;
+  const filePathPattern = /(?:at\s+(?:.*?\s+\()?)?([A-Za-z]:)?([/\\](?!node_modules)[^\s:()]+\.[a-z]+)(?::(\d+))?(?::(\d+))?/gi;
+  const nodeModulesPattern = /node_modules/i;
+  function normalizeMessage(msg) {
+    return msg.replace(/['"`].*?['"`]/g, "<string>").replace(/\b\d+\b/g, "<num>").replace(/0x[0-9a-fA-F]+/g, "<hex>").replace(/\{[^}]*\}/g, "<obj>").replace(/\[[^\]]*\]/g, "<arr>").replace(
+      /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi,
+      "<uuid>"
+    ).replace(/\s+/g, " ").trim().substring(0, 200);
+  }
+  function extractAppFiles(line) {
+    const files = [];
+    const matches = line.matchAll(filePathPattern);
+    for (const match of matches) {
+      const fullPath = (match[1] || "") + match[2];
+      if (!nodeModulesPattern.test(fullPath)) {
+        const lineNum = match[3] ? `:${match[3]}` : "";
+        files.push(fullPath + lineNum);
+      }
+    }
+    return files;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+    for (const { type, pattern } of errorTypePatterns) {
+      const match = line.match(pattern);
+      if (match) {
+        totalErrorCount++;
+        const message = match[1] || line;
+        const normalized = normalizeMessage(message);
+        const key = `${type}:${normalized}`;
+        const contextLines = lines.slice(i, Math.min(i + 6, lines.length));
+        const files = /* @__PURE__ */ new Set();
+        for (const contextLine of contextLines) {
+          extractAppFiles(contextLine).forEach((f) => files.add(f));
+        }
+        if (errorMap.has(key)) {
+          const existing = errorMap.get(key);
+          existing.count++;
+          files.forEach((f) => existing.files.add(f));
+        } else {
+          let example = line;
+          for (let j = i + 1; j < Math.min(i + 6, lines.length); j++) {
+            const stackLine = lines[j];
+            if (stackLine.trim().startsWith("at ") && !nodeModulesPattern.test(stackLine)) {
+              example += "\n" + stackLine;
+            }
+          }
+          errorMap.set(key, {
+            type,
+            message: message.substring(0, 150),
+            normalizedMessage: normalized,
+            files,
+            count: 1,
+            firstOccurrence: i + 1,
+            example: example.substring(0, 500)
+          });
+        }
+        break;
+      }
+    }
+  }
+  const groupedErrors = Array.from(errorMap.values()).sort((a, b) => b.count - a.count).map((e) => ({
+    type: e.type,
+    count: e.count,
+    example: e.example,
+    files: Array.from(e.files).slice(0, 5)
+    // Limit files per error
+  }));
+  const summaryLines = [];
+  summaryLines.push(`=== ERROR SUMMARY ===`);
+  summaryLines.push(`Total lines processed: ${totalLines}`);
+  summaryLines.push(`Total errors found: ${totalErrorCount}`);
+  summaryLines.push(`Unique error patterns: ${groupedErrors.length}`);
+  summaryLines.push("");
+  const typeCount = /* @__PURE__ */ new Map();
+  for (const err of groupedErrors) {
+    typeCount.set(err.type, (typeCount.get(err.type) || 0) + err.count);
+  }
+  summaryLines.push("--- Errors by Type ---");
+  for (const [type, count] of Array.from(typeCount.entries()).sort(
+    (a, b) => b[1] - a[1]
+  )) {
+    summaryLines.push(`  ${type}: ${count}`);
+  }
+  summaryLines.push("");
+  summaryLines.push("--- Top Errors (by frequency) ---");
+  let currentLines = summaryLines.length;
+  const maxDetailedErrors = Math.min(groupedErrors.length, 20);
+  for (let i = 0; i < maxDetailedErrors && currentLines < maxLines - 5; i++) {
+    const err = groupedErrors[i];
+    summaryLines.push("");
+    summaryLines.push(`[${i + 1}] ${err.type} (x${err.count})`);
+    const exampleLines = err.example.split("\n");
+    for (const exLine of exampleLines) {
+      if (currentLines >= maxLines - 3) break;
+      summaryLines.push(`    ${exLine}`);
+      currentLines++;
+    }
+    if (err.files.length > 0) {
+      summaryLines.push(`    Files: ${err.files.join(", ")}`);
+    }
+    currentLines = summaryLines.length;
+  }
+  const summary = summaryLines.slice(0, maxLines).join("\n");
+  return {
+    summary,
+    error_count: totalErrorCount,
+    unique_errors: groupedErrors.length,
+    grouped_errors: groupedErrors.slice(0, 50)
+    // Limit to top 50
+  };
 }
 
 // src/resources/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetasks/mcp-server",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "VibeTasks MCP Server for Claude Code, Cursor, and AI coding tools. Status-based task management: todo → vibing → done.",
   "author": "Vyas",
   "license": "MIT",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^0.5.0",
-    "@vibetasks/core": "^0.2.0",
+    "@vibetasks/core": "^0.4.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {