@vibescope/mcp-server 0.0.1 → 0.2.0

package/dist/handlers/git-issues.js

@@ -1,247 +1,102 @@
 /**
  * Git Issues Handlers
  *
- * Handles git-related issue tracking:
- * - get_git_issues
- * - create_git_issue
- * - resolve_git_issue
- * - dismiss_git_issue
+ * Handles git issue management:
+ * - add_git_issue: Record a git-related issue (conflicts, push failures, etc.)
+ * - resolve_git_issue: Mark a git issue as resolved
+ * - get_git_issues: List git issues for a project
+ * - delete_git_issue: Remove a git issue
  */
 import { validateRequired, validateUUID } from '../validators.js';
-export const getGitIssues = async (args, ctx) => {
-    const { project_id, status = 'open', include_resolved = false } = args;
+import { getApiClient } from '../api-client.js';
+const VALID_GIT_ISSUE_TYPES = [
+    'merge_conflict',
+    'push_failed',
+    'rebase_needed',
+    'branch_diverged',
+    'pr_not_mergeable',
+];
+const VALID_GIT_ISSUE_STATUSES = ['open', 'resolved'];
+export const addGitIssue = async (args, ctx) => {
+    const { project_id, issue_type, branch, target_branch, pr_url, conflicting_files, error_message, task_id, } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
-    const { supabase } = ctx;
-    let query = supabase
-        .from('git_issues')
-        .select(`
-			id,
-			task_id,
-			issue_type,
-			severity,
-			branch_name,
-			pr_number,
-			pr_url,
-			target_branch,
-			conflicting_files,
-			error_message,
-			status,
-			created_at,
-			resolved_at,
-			auto_resolved,
-			resolution_note
-		`)
-        .eq('project_id', project_id)
-        .order('created_at', { ascending: false });
-    if (status !== 'all' && !include_resolved) {
-        query = query.eq('status', status);
+    validateRequired(issue_type, 'issue_type');
+    validateRequired(branch, 'branch');
+    if (!VALID_GIT_ISSUE_TYPES.includes(issue_type)) {
+        throw new Error(`Invalid issue_type. Valid types: ${VALID_GIT_ISSUE_TYPES.join(', ')}`);
     }
-    const { data: issues, error } = await query.limit(50);
-    if (error)
-        throw new Error(`Failed to fetch git issues: ${error.message}`);
-    // Group by severity for summary
-    const summary = {
-        critical: 0,
-        high: 0,
-        medium: 0,
-        low: 0,
-    };
-    const openIssues = (issues || []).filter(i => i.status === 'open');
-    openIssues.forEach(issue => {
-        const sev = issue.severity;
-        if (sev in summary)
-            summary[sev]++;
-    });
-    return {
-        result: {
-            issues: issues || [],
-            open_count: openIssues.length,
-            severity_summary: summary,
-            has_critical: summary.critical > 0,
-            has_blocking: summary.critical > 0 || summary.high > 0,
-        },
-    };
+    if (task_id) {
+        validateUUID(task_id, 'task_id');
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.addGitIssue(project_id, {
+        issue_type: issue_type,
+        branch,
+        target_branch,
+        pr_url,
+        conflicting_files,
+        error_message,
+        task_id
+    }, ctx.session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to add git issue');
+    }
+    return { result: response.data };
 };
-export const createGitIssue = async (args, ctx) => {
-    const { project_id, task_id, issue_type, severity = 'medium', branch_name, pr_number, pr_url, target_branch, conflicting_files, error_message, } = args;
+export const resolveGitIssue = async (args, ctx) => {
+    const { git_issue_id, resolution_note, auto_resolved } = args;
+    validateRequired(git_issue_id, 'git_issue_id');
+    validateUUID(git_issue_id, 'git_issue_id');
+    const apiClient = getApiClient();
+    const response = await apiClient.resolveGitIssue(git_issue_id, {
+        resolution_note,
+        auto_resolved
+    }, ctx.session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to resolve git issue');
+    }
+    return { result: response.data };
+};
+export const getGitIssues = async (args, ctx) => {
+    const { project_id, status = 'open', issue_type, branch, limit = 50, } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
-    validateRequired(issue_type, 'issue_type');
-    const { supabase, session } = ctx;
-    // Check if similar issue already exists (avoid duplicates)
-    if (branch_name || pr_number) {
-        const { data: existing } = await supabase
-            .from('git_issues')
-            .select('id')
-            .eq('project_id', project_id)
-            .eq('status', 'open')
-            .eq('issue_type', issue_type)
-            .or(`branch_name.eq.${branch_name},pr_number.eq.${pr_number}`)
-            .limit(1)
-            .maybeSingle();
-        if (existing) {
-            return {
-                result: {
-                    success: false,
-                    already_exists: true,
-                    existing_issue_id: existing.id,
-                    message: 'A similar git issue already exists for this branch/PR',
-                },
-            };
-        }
+    if (status && !VALID_GIT_ISSUE_STATUSES.includes(status)) {
+        throw new Error(`Invalid status. Valid statuses: ${VALID_GIT_ISSUE_STATUSES.join(', ')}`);
     }
-    const { data: issue, error } = await supabase
-        .from('git_issues')
-        .insert({
-        project_id,
-        task_id: task_id || null,
+    if (issue_type && !VALID_GIT_ISSUE_TYPES.includes(issue_type)) {
+        throw new Error(`Invalid issue_type. Valid types: ${VALID_GIT_ISSUE_TYPES.join(', ')}`);
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.getGitIssues(project_id, {
+        status,
         issue_type,
-        severity,
-        branch_name: branch_name || null,
-        pr_number: pr_number || null,
-        pr_url: pr_url || null,
-        target_branch: target_branch || null,
-        conflicting_files: conflicting_files || [],
-        error_message: error_message || null,
-        created_by: 'agent',
-        created_by_session_id: session.currentSessionId,
-    })
-        .select('id, issue_type, severity, branch_name, pr_number')
-        .single();
-    if (error)
-        throw new Error(`Failed to create git issue: ${error.message}`);
-    // Log progress
-    await supabase.from('progress_logs').insert({
-        project_id,
-        task_id: task_id || null,
-        summary: `Git issue created: ${issue_type} on ${branch_name || `PR #${pr_number}`}`,
-        details: error_message || null,
-        created_by: 'agent',
-        created_by_session_id: session.currentSessionId,
+        branch,
+        limit
     });
-    return {
-        result: {
-            success: true,
-            issue_id: issue.id,
-            issue_type: issue.issue_type,
-            severity: issue.severity,
-            branch: issue.branch_name,
-            pr_number: issue.pr_number,
-        },
-    };
-};
-export const resolveGitIssue = async (args, ctx) => {
-    const { issue_id, resolution_note, auto_resolved = false } = args;
-    validateRequired(issue_id, 'issue_id');
-    validateUUID(issue_id, 'issue_id');
-    const { supabase, session } = ctx;
-    // Get the issue first
-    const { data: issue, error: fetchError } = await supabase
-        .from('git_issues')
-        .select('id, project_id, task_id, issue_type, branch_name, pr_number, status')
-        .eq('id', issue_id)
-        .single();
-    if (fetchError || !issue)
-        throw new Error('Git issue not found');
-    if (issue.status !== 'open') {
-        return {
-            result: {
-                success: false,
-                error: `Issue is already ${issue.status}`,
-            },
-        };
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to fetch git issues');
     }
-    const { error: updateError } = await supabase
-        .from('git_issues')
-        .update({
-        status: 'resolved',
-        resolved_at: new Date().toISOString(),
-        resolved_by_session_id: session.currentSessionId,
-        auto_resolved,
-        resolution_note: resolution_note || null,
-    })
-        .eq('id', issue_id);
-    if (updateError)
-        throw new Error(`Failed to resolve git issue: ${updateError.message}`);
-    // Log progress
-    await supabase.from('progress_logs').insert({
-        project_id: issue.project_id,
-        task_id: issue.task_id,
-        summary: `Git issue resolved: ${issue.issue_type} on ${issue.branch_name || `PR #${issue.pr_number}`}${auto_resolved ? ' (auto)' : ''}`,
-        details: resolution_note || null,
-        created_by: 'agent',
-        created_by_session_id: session.currentSessionId,
-    });
-    return {
-        result: {
-            success: true,
-            resolved_issue_id: issue_id,
-            auto_resolved,
-        },
-    };
-};
-export const dismissGitIssue = async (args, ctx) => {
-    const { issue_id, reason } = args;
-    validateRequired(issue_id, 'issue_id');
-    validateUUID(issue_id, 'issue_id');
-    const { supabase, session } = ctx;
-    const { error } = await supabase
-        .from('git_issues')
-        .update({
-        status: 'dismissed',
-        resolved_at: new Date().toISOString(),
-        resolved_by_session_id: session.currentSessionId,
-        resolution_note: reason || 'Dismissed',
-    })
-        .eq('id', issue_id);
-    if (error)
-        throw new Error(`Failed to dismiss git issue: ${error.message}`);
-    return {
-        result: {
-            success: true,
-            dismissed_issue_id: issue_id,
-        },
-    };
+    return { result: response.data };
 };
-/**
- * Auto-resolve git issues for a branch when it becomes mergeable
- */
-export async function autoResolveGitIssuesForBranch(supabase, projectId, branchName, sessionId) {
-    const { data: issues } = await supabase
-        .from('git_issues')
-        .select('id')
-        .eq('project_id', projectId)
-        .eq('branch_name', branchName)
-        .eq('status', 'open')
-        .in('issue_type', ['merge_conflict', 'rebase_needed']);
-    if (!issues || issues.length === 0)
-        return 0;
-    const { error } = await supabase
-        .from('git_issues')
-        .update({
-        status: 'resolved',
-        resolved_at: new Date().toISOString(),
-        resolved_by_session_id: sessionId,
-        auto_resolved: true,
-        resolution_note: 'Auto-resolved: branch is now mergeable',
-    })
-        .eq('project_id', projectId)
-        .eq('branch_name', branchName)
-        .eq('status', 'open')
-        .in('issue_type', ['merge_conflict', 'rebase_needed']);
-    if (error) {
-        console.error('Failed to auto-resolve git issues:', error);
-        return 0;
+export const deleteGitIssue = async (args, ctx) => {
+    const { git_issue_id } = args;
+    validateRequired(git_issue_id, 'git_issue_id');
+    validateUUID(git_issue_id, 'git_issue_id');
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteGitIssue(git_issue_id);
+    if (!response.ok) {
+        throw new Error(response.error || 'Failed to delete git issue');
     }
-    return issues.length;
-}
+    return { result: response.data };
+};
 /**
  * Git Issues handlers registry
  */
-export const gitIssuesHandlers = {
-    get_git_issues: getGitIssues,
-    create_git_issue: createGitIssue,
+export const gitIssueHandlers = {
+    add_git_issue: addGitIssue,
     resolve_git_issue: resolveGitIssue,
-    dismiss_git_issue: dismissGitIssue,
+    get_git_issues: getGitIssues,
+    delete_git_issue: deleteGitIssue,
 };

package/dist/handlers/ideas.d.ts

@@ -6,6 +6,9 @@
  * - update_idea
  * - get_ideas
  * - delete_idea
+ * - convert_idea_to_task
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import type { Handler, HandlerRegistry } from './types.js';
 export declare const addIdea: Handler;

package/dist/handlers/ideas.js

@@ -6,94 +6,74 @@
  * - update_idea
  * - get_ideas
  * - delete_idea
+ * - convert_idea_to_task
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import { validateRequired, validateUUID, validatePriority, validateEstimatedMinutes } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 export const addIdea = async (args, ctx) => {
     const { project_id, title, description, status } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
     validateRequired(title, 'title');
-    const { supabase, session } = ctx;
-    const { data, error } = await supabase
-        .from('ideas')
-        .insert({
-        project_id,
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.addIdea(project_id, {
         title,
-        description: description || null,
-        status: status || 'raw',
-        created_by: 'agent',
-        created_by_session_id: session.currentSessionId,
-    })
-        .select('id')
-        .single();
-    if (error)
-        throw new Error(`Failed to add idea: ${error.message}`);
-    return { result: { success: true, idea_id: data.id, title } };
+        description,
+        status
+    }, session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(`Failed to add idea: ${response.error}`);
+    }
+    return { result: { success: true, idea_id: response.data?.idea_id, title } };
 };
 export const updateIdea = async (args, ctx) => {
     const { idea_id, title, description, status, doc_url } = args;
     validateRequired(idea_id, 'idea_id');
     validateUUID(idea_id, 'idea_id');
-    const { supabase } = ctx;
-    // Get current idea status
-    const { data: existingIdea } = await supabase
-        .from('ideas')
-        .select('status')
-        .eq('id', idea_id)
-        .single();
-    if (!existingIdea) {
-        throw new Error(`Idea not found: ${idea_id}`);
-    }
-    // Build update object
-    const updates = { updated_at: new Date().toISOString() };
-    if (title !== undefined)
-        updates.title = title;
-    if (description !== undefined)
-        updates.description = description;
-    if (doc_url !== undefined)
-        updates.doc_url = doc_url;
-    if (status !== undefined) {
-        updates.status = status;
-        // Set planned_at when transitioning to planned status
-        if (status === 'planned' && existingIdea.status !== 'planned') {
-            updates.planned_at = new Date().toISOString();
-        }
+    const apiClient = getApiClient();
+    const response = await apiClient.updateIdea(idea_id, {
+        title,
+        description,
+        status,
+        doc_url
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to update idea: ${response.error}`);
     }
-    const { error } = await supabase
-        .from('ideas')
-        .update(updates)
-        .eq('id', idea_id);
-    if (error)
-        throw new Error(`Failed to update idea: ${error.message}`);
     return { result: { success: true, idea_id } };
 };
 export const getIdeas = async (args, ctx) => {
-    const { project_id, status } = args;
+    const { project_id, status, limit = 50, offset = 0, search_query } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
-    const { supabase } = ctx;
-    let query = supabase
-        .from('ideas')
-        .select('id, title, description, status, doc_url')
-        .eq('project_id', project_id);
-    if (status) {
-        query = query.eq('status', status);
+    const apiClient = getApiClient();
+    const response = await apiClient.getIdeas(project_id, {
+        status,
+        limit,
+        offset,
+        search_query
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ideas: ${response.error}`);
     }
-    const { data, error } = await query.order('created_at', { ascending: false });
-    if (error)
-        throw new Error(`Failed to fetch ideas: ${error.message}`);
-    return { result: { ideas: data || [] } };
+    return {
+        result: {
+            ideas: response.data?.ideas || [],
+        },
+    };
 };
 export const deleteIdea = async (args, ctx) => {
     const { idea_id } = args;
     validateRequired(idea_id, 'idea_id');
     validateUUID(idea_id, 'idea_id');
-    const { error } = await ctx.supabase
-        .from('ideas')
-        .delete()
-        .eq('id', idea_id);
-    if (error)
-        throw new Error(`Failed to delete idea: ${error.message}`);
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteIdea(idea_id);
+    if (!response.ok) {
+        throw new Error(`Failed to delete idea: ${response.error}`);
+    }
     return { result: { success: true } };
 };
 export const convertIdeaToTask = async (args, ctx) => {
@@ -102,79 +82,18 @@ export const convertIdeaToTask = async (args, ctx) => {
     validateUUID(idea_id, 'idea_id');
     validatePriority(priority);
     validateEstimatedMinutes(estimated_minutes);
-    const { supabase, session } = ctx;
-    const currentSessionId = session.currentSessionId;
-    // Get the idea
-    const { data: idea, error: fetchError } = await supabase
-        .from('ideas')
-        .select('id, project_id, title, description, status, converted_to_task_id')
-        .eq('id', idea_id)
-        .single();
-    if (fetchError || !idea) {
-        throw new Error(`Idea not found: ${idea_id}`);
-    }
-    // Check if already converted
-    if (idea.converted_to_task_id) {
-        return {
-            result: {
-                success: false,
-                error: 'Idea has already been converted to a task',
-                existing_task_id: idea.converted_to_task_id,
-                hint: 'Use get_tasks to find the existing task',
-            },
-        };
-    }
-    // Create the task
-    const { data: task, error: taskError } = await supabase
-        .from('tasks')
-        .insert({
-        project_id: idea.project_id,
-        title: idea.title,
-        description: idea.description || `Converted from idea: ${idea.title}`,
+    const apiClient = getApiClient();
+    // Use proxy for convert_idea_to_task operation
+    const response = await apiClient.proxy('convert_idea_to_task', {
+        idea_id,
         priority,
-        estimated_minutes: estimated_minutes || null,
-        created_by: 'agent',
-        created_by_session_id: currentSessionId,
-    })
-        .select('id, title')
-        .single();
-    if (taskError || !task) {
-        throw new Error(`Failed to create task: ${taskError?.message}`);
-    }
-    // Update the idea with the task reference and optionally update status
-    const ideaUpdates = {
-        converted_to_task_id: task.id,
-        updated_at: new Date().toISOString(),
-    };
-    if (update_status && idea.status !== 'shipped') {
-        ideaUpdates.status = 'in_development';
-    }
-    const { error: updateError } = await supabase
-        .from('ideas')
-        .update(ideaUpdates)
-        .eq('id', idea_id);
-    if (updateError) {
-        // Log but don't fail - task was created successfully
-        console.error(`Failed to update idea after conversion: ${updateError.message}`);
-    }
-    // Log progress
-    await supabase.from('progress_logs').insert({
-        project_id: idea.project_id,
-        task_id: task.id,
-        summary: `Converted idea "${idea.title}" to task`,
-        created_by: 'agent',
-        created_by_session_id: currentSessionId,
+        estimated_minutes,
+        update_status
     });
-    return {
-        result: {
-            success: true,
-            task_id: task.id,
-            task_title: task.title,
-            idea_id: idea.id,
-            idea_status: update_status ? 'in_development' : idea.status,
-            message: `Created task from idea. Start with: update_task(task_id: "${task.id}", status: "in_progress")`,
-        },
-    };
+    if (!response.ok) {
+        throw new Error(`Failed to convert idea: ${response.error}`);
+    }
+    return { result: response.data };
 };
 /**
  * Ideas handlers registry

package/dist/handlers/index.d.ts

@@ -22,6 +22,8 @@ export * from './bodies-of-work.js';
 export * from './discovery.js';
 export * from './organizations.js';
 export * from './cost.js';
+export * from './git-issues.js';
+export * from './sprints.js';
 import type { HandlerRegistry } from './types.js';
 /**
  * Build the complete handler registry from all modules

package/dist/handlers/index.js

@@ -22,6 +22,8 @@ export * from './bodies-of-work.js';
 export * from './discovery.js';
 export * from './organizations.js';
 export * from './cost.js';
+export * from './git-issues.js';
+export * from './sprints.js';
 import { milestoneHandlers } from './milestones.js';
 import { sessionHandlers } from './session.js';
 import { ideaHandlers } from './ideas.js';
@@ -39,6 +41,8 @@ import { bodiesOfWorkHandlers } from './bodies-of-work.js';
 import { discoveryHandlers } from './discovery.js';
 import { organizationHandlers } from './organizations.js';
 import { costHandlers } from './cost.js';
+import { gitIssueHandlers } from './git-issues.js';
+import { sprintHandlers } from './sprints.js';
 /**
  * Build the complete handler registry from all modules
  */
@@ -61,5 +65,7 @@ export function buildHandlerRegistry() {
         ...discoveryHandlers,
         ...organizationHandlers,
         ...costHandlers,
+        ...gitIssueHandlers,
+        ...sprintHandlers,
     };
 }

package/dist/handlers/milestones.d.ts

@@ -7,6 +7,8 @@
  * - complete_milestone
  * - delete_milestone
  * - get_milestones
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import type { Handler, HandlerRegistry } from './types.js';
 export declare const addMilestone: Handler;