@vibetasks/mcp-server 0.2.1 → 0.3.0

package/dist/index.js

@@ -303,6 +303,171 @@ function setupTools(taskOps) {
         };
       }
     },
+    // start_vibing
+    {
+      name: "start_vibing",
+      description: 'Start vibing on a task (move to "vibing" status). Max 3 tasks vibing at once - research shows more causes 40% productivity loss.',
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID to start vibing on")
+      }),
+      handler: async (args, taskOps2) => {
+        const allTasks = await taskOps2.getTasks("all");
+        const vibingTasks = allTasks.filter((t) => t.status === "vibing");
+        const WIP_LIMIT = 3;
+        if (vibingTasks.length >= WIP_LIMIT) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    success: false,
+                    error: `WIP limit reached! You have ${vibingTasks.length} tasks vibing. Complete one before starting another.`,
+                    vibing_tasks: vibingTasks.map((t) => ({ id: t.id, title: t.title })),
+                    wip_limit: WIP_LIMIT
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        const task = await taskOps2.updateTask(args.task_id, { status: "vibing" });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    status: "vibing"
+                  },
+                  wip_count: vibingTasks.length + 1,
+                  wip_limit: WIP_LIMIT
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // get_vibing_tasks
+    {
+      name: "get_vibing_tasks",
+      description: 'Get all tasks currently in "vibing" status. Use this to check what the user is actively working on.',
+      inputSchema: z.object({}),
+      handler: async (args, taskOps2) => {
+        const allTasks = await taskOps2.getTasks("all");
+        const vibingTasks = allTasks.filter((t) => t.status === "vibing");
+        const WIP_LIMIT = 3;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  vibing_tasks: vibingTasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    context_notes: t.context_notes,
+                    priority: t.priority,
+                    due_date: t.due_date
+                  })),
+                  count: vibingTasks.length,
+                  wip_limit: WIP_LIMIT,
+                  at_limit: vibingTasks.length >= WIP_LIMIT
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // set_context_notes
+    {
+      name: "set_context_notes",
+      description: 'Save "where I left off" notes for a task. Use this before pausing work or ending a session to capture context for later.',
+      inputSchema: z.object({
+        task_id: z.string().describe("Task ID"),
+        context_notes: z.string().describe("Where you left off - file, line, next step, blockers")
+      }),
+      handler: async (args, taskOps2) => {
+        const task = await taskOps2.updateTask(args.task_id, {
+          context_notes: args.context_notes
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  task: {
+                    id: task.id,
+                    title: task.title,
+                    context_notes: task.context_notes
+                  },
+                  message: "Context notes saved. You can resume seamlessly later."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
+    // list_tasks (with status filter)
+    {
+      name: "list_tasks",
+      description: "List tasks filtered by status (todo, vibing, done) or all tasks",
+      inputSchema: z.object({
+        status: z.enum(["todo", "vibing", "done", "all"]).default("all").describe("Filter by status"),
+        limit: z.number().default(50).describe("Maximum results")
+      }),
+      handler: async (args, taskOps2) => {
+        const allTasks = await taskOps2.getTasks("all");
+        let tasks = allTasks;
+        if (args.status !== "all") {
+          tasks = allTasks.filter((t) => t.status === args.status);
+        }
+        tasks = tasks.slice(0, args.limit);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  tasks: tasks.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    status: t.status,
+                    priority: t.priority,
+                    due_date: t.due_date,
+                    context_notes: t.context_notes,
+                    tags: t.tags?.map((tag) => tag.name) || []
+                  })),
+                  count: tasks.length,
+                  filter: args.status
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    },
     // log_ai_session
     {
       name: "log_ai_session",
@@ -350,9 +515,459 @@ 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
+              )
+            }
+          ]
+        };
+      }
     }
   ];
 }
+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
 function setupResources(taskOps) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibetasks/mcp-server",
-  "version": "0.2.1",
+  "version": "0.3.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.3.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {