@vibecheckai/cli 3.2.5 → 3.3.0

package/mcp-server/conductor/tools.js

@@ -0,0 +1,510 @@
+/**
+ * Conductor MCP Tools
+ * 
+ * MCP tool definitions for multi-agent coordination.
+ * 
+ * Codename: Conductor
+ */
+
+"use strict";
+
+import conductor from "./index.js";
+
+/**
+ * Tool definitions for the Conductor module
+ */
+export const CONDUCTOR_TOOLS = {
+  // Register an agent session
+  vibecheck_conductor_register: {
+    name: "vibecheck_conductor_register",
+    description: "Register an AI agent session for multi-agent coordination. Call this at the start of any multi-agent workflow.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agentId: {
+          type: "string",
+          description: "Unique identifier for the agent (e.g., 'cursor', 'copilot', 'custom-agent')",
+        },
+        tier: {
+          type: "string",
+          enum: ["FREE", "STARTER", "PRO", "ENTERPRISE"],
+          default: "FREE",
+          description: "User's subscription tier",
+        },
+        projectRoot: {
+          type: "string",
+          description: "Project root directory path",
+        },
+        workingFiles: {
+          type: "array",
+          items: { type: "string" },
+          description: "Initial list of files this agent plans to work on",
+        },
+      },
+      required: ["agentId", "projectRoot"],
+    },
+  },
+  
+  // Acquire a lock on a file or folder
+  vibecheck_conductor_acquire_lock: {
+    name: "vibecheck_conductor_acquire_lock",
+    description: "Acquire a lock on a file or folder to prevent concurrent modifications by other agents.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID from vibecheck_conductor_register",
+        },
+        path: {
+          type: "string",
+          description: "File or folder path to lock",
+        },
+        type: {
+          type: "string",
+          enum: ["exclusive", "shared"],
+          default: "exclusive",
+          description: "Lock type: 'exclusive' for write access, 'shared' for read access",
+        },
+        reason: {
+          type: "string",
+          description: "Reason for acquiring the lock",
+        },
+      },
+      required: ["sessionId", "path"],
+    },
+  },
+  
+  // Release a lock
+  vibecheck_conductor_release_lock: {
+    name: "vibecheck_conductor_release_lock",
+    description: "Release a previously acquired lock.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        lockId: {
+          type: "string",
+          description: "Lock ID to release",
+        },
+        sessionId: {
+          type: "string",
+          description: "Session ID that owns the lock",
+        },
+      },
+      required: ["lockId", "sessionId"],
+    },
+  },
+  
+  // Submit a coordinated proposal
+  vibecheck_conductor_propose: {
+    name: "vibecheck_conductor_propose",
+    description: "Submit a change proposal for multi-agent coordination. Checks for conflicts with other agents.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID from vibecheck_conductor_register",
+        },
+        proposalId: {
+          type: "string",
+          description: "Unique proposal ID",
+        },
+        intent: {
+          type: "string",
+          description: "What you intend to accomplish with this change",
+        },
+        operations: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              type: { type: "string", enum: ["create", "modify", "delete", "move"] },
+              path: { type: "string" },
+              content: { type: "string" },
+            },
+          },
+          description: "List of file operations in this proposal",
+        },
+        assumptions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              type: { type: "string" },
+              target: { type: "string" },
+              expectedValue: {},
+            },
+          },
+          description: "Assumptions this proposal makes about the codebase",
+        },
+        projectRoot: {
+          type: "string",
+          description: "Project root directory",
+        },
+      },
+      required: ["sessionId", "proposalId", "intent", "operations", "projectRoot"],
+    },
+  },
+  
+  // Get coordination status
+  vibecheck_conductor_status: {
+    name: "vibecheck_conductor_status",
+    description: "Get the current status of multi-agent coordination including active sessions, locks, and conflicts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectRoot: {
+          type: "string",
+          description: "Project root directory",
+        },
+        includeDetails: {
+          type: "boolean",
+          default: false,
+          description: "Include detailed information about each session and lock",
+        },
+      },
+      required: ["projectRoot"],
+    },
+  },
+  
+  // Terminate a session
+  vibecheck_conductor_terminate: {
+    name: "vibecheck_conductor_terminate",
+    description: "Terminate an agent session and release all its locks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to terminate",
+        },
+      },
+      required: ["sessionId"],
+    },
+  },
+};
+
+/**
+ * Handle conductor register tool call
+ */
+export async function handleConductorRegister(args, projectRoot) {
+  try {
+    // Input validation
+    if (!args || typeof args !== 'object') {
+      return { success: false, error: "Invalid arguments" };
+    }
+    if (!args.agentId || typeof args.agentId !== 'string') {
+      return { success: false, error: "agentId is required and must be a string" };
+    }
+    
+    const resolvedRoot = args.projectRoot || projectRoot;
+    if (!resolvedRoot) {
+      return { success: false, error: "projectRoot is required" };
+    }
+    
+    conductor.init(resolvedRoot);
+    
+    const session = conductor.registerAgent({
+      agentId: args.agentId,
+      tier: args.tier || "FREE",
+      projectRoot: resolvedRoot,
+      workingFiles: Array.isArray(args.workingFiles) ? args.workingFiles : [],
+    });
+    
+    return {
+      success: true,
+      sessionId: session.sessionId,
+      agentId: session.agentId,
+      tier: session.tier,
+      trust: session.trust,
+      message: `Agent '${args.agentId}' registered successfully`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: getErrorMessage(error),
+    };
+  }
+}
+
+/**
+ * Handle conductor acquire lock tool call
+ */
+export async function handleConductorAcquireLock(args, projectRoot) {
+  try {
+    // Input validation
+    if (!args?.sessionId || !args?.path) {
+      return { success: false, error: "sessionId and path are required" };
+    }
+    if (!projectRoot) {
+      return { success: false, error: "projectRoot context is required" };
+    }
+    
+    conductor.init(projectRoot);
+    
+    const result = conductor.acquireLock({
+      sessionId: args.sessionId,
+      path: args.path,
+      type: args.type || "exclusive",
+      reason: args.reason || "",
+    });
+    
+    if (result.acquired) {
+      return {
+        success: true,
+        lockId: result.lock.lockId,
+        path: result.lock.path,
+        type: result.lock.type,
+        expiresAt: result.lock.expiresAt,
+        upgraded: result.upgraded || false,
+        refreshed: result.refreshed || false,
+        message: result.upgraded 
+          ? "Lock upgraded to exclusive"
+          : result.refreshed 
+            ? "Lock refreshed"
+            : "Lock acquired",
+      };
+    } else {
+      return {
+        success: false,
+        conflict: true,
+        blockedBy: result.conflictingLocks.map(l => ({
+          lockId: l.lockId,
+          agentId: l.agentId,
+          sessionId: l.sessionId,
+          path: l.path,
+          reason: l.reason,
+        })),
+        message: result.message,
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: getErrorMessage(error),
+    };
+  }
+}
+
+/**
+ * Handle conductor release lock tool call
+ */
+export async function handleConductorReleaseLock(args, projectRoot) {
+  try {
+    // Input validation
+    if (!args?.lockId || !args?.sessionId) {
+      return { success: false, error: "lockId and sessionId are required" };
+    }
+    if (!projectRoot) {
+      return { success: false, error: "projectRoot context is required" };
+    }
+    
+    conductor.init(projectRoot);
+    
+    const success = conductor.releaseLock(args.lockId, args.sessionId);
+    
+    return {
+      success,
+      message: success ? "Lock released" : "Lock not found or not owned by session",
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: getErrorMessage(error),
+    };
+  }
+}
+
+/**
+ * Handle conductor propose tool call
+ */
+export async function handleConductorPropose(args, projectRoot) {
+  try {
+    conductor.init(args.projectRoot || projectRoot);
+    
+    const session = conductor.sessionManager.getSession(args.sessionId);
+    if (!session) {
+      return {
+        success: false,
+        error: "Invalid or expired session. Please register first.",
+      };
+    }
+    
+    const proposal = {
+      proposalId: args.proposalId,
+      sessionId: args.sessionId,
+      agentId: session.agentId,
+      tier: session.tier,
+      intent: args.intent,
+      operations: args.operations || [],
+      assumptions: args.assumptions || [],
+      createdAt: new Date(),
+    };
+    
+    const result = conductor.submitProposal(proposal);
+    
+    if (result.accepted) {
+      // Update session with working files
+      const files = proposal.operations.map(op => op.path).filter(Boolean);
+      for (const file of files) {
+        conductor.sessionManager.addWorkingFile(args.sessionId, file);
+      }
+      
+      return {
+        success: true,
+        accepted: true,
+        requestId: result.requestId,
+        queuePosition: result.position,
+        warnings: result.warnings.map(w => ({
+          type: w.type,
+          severity: w.severity,
+          description: w.description,
+        })),
+        message: `Proposal accepted and queued at position ${result.position}`,
+      };
+    } else {
+      return {
+        success: false,
+        accepted: false,
+        conflicts: result.conflicts.map(c => ({
+          type: c.type,
+          severity: c.severity,
+          description: c.description,
+          conflictsWith: c.proposalA === args.proposalId ? c.proposalB : c.proposalA,
+        })),
+        message: "Proposal blocked by conflicts. Resolve conflicts before proceeding.",
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: getErrorMessage(error),
+    };
+  }
+}
+
+/**
+ * Handle conductor status tool call
+ */
+export async function handleConductorStatus(args, projectRoot) {
+  try {
+    const resolvedRoot = args?.projectRoot || projectRoot;
+    if (!resolvedRoot) {
+      return { success: false, error: "projectRoot is required" };
+    }
+    
+    conductor.init(resolvedRoot);
+    
+    const status = conductor.getStatus(resolvedRoot);
+    
+    const response = {
+      success: true,
+      status: {
+        totalSessions: status.sessions.totalSessions,
+        activeAgents: status.sessions.activeAgents,
+        totalLocks: status.locks.totalLocks,
+        queueLength: status.queue.queueLength,
+        processing: status.queue.processing,
+        unresolvedConflicts: status.conflicts,
+        deadlocks: status.deadlocks.length,
+      },
+    };
+    
+    if (args.includeDetails) {
+      response.details = {
+        agents: status.activeAgents,
+        sessionsByTier: status.sessions.byTier,
+        lockStats: status.locks,
+        queueByTier: status.queue.byTier,
+      };
+      
+      if (status.deadlocks.length > 0) {
+        response.details.deadlocks = status.deadlocks;
+      }
+    }
+    
+    return response;
+  } catch (error) {
+    return {
+      success: false,
+      error: getErrorMessage(error),
+    };
+  }
+}
+
+/**
+ * Handle conductor terminate tool call
+ */
+export async function handleConductorTerminate(args, projectRoot) {
+  try {
+    // Input validation
+    if (!args?.sessionId) {
+      return { success: false, error: "sessionId is required" };
+    }
+    if (!projectRoot) {
+      return { success: false, error: "projectRoot context is required" };
+    }
+    
+    conductor.init(projectRoot);
+    
+    const result = conductor.terminateSession(args.sessionId);
+    
+    return {
+      success: result.sessionTerminated,
+      locksReleased: result.locksReleased,
+      message: result.sessionTerminated
+        ? `Session terminated, ${result.locksReleased} locks released`
+        : "Session not found",
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: getErrorMessage(error),
+    };
+  }
+}
+
+/**
+ * Router for conductor tool calls
+ */
+export async function handleConductorToolCall(toolName, args, projectRoot) {
+  // Top-level safety guard
+  try {
+    if (!toolName || typeof toolName !== 'string') {
+      return { success: false, error: "Invalid tool name" };
+    }
+    
+    switch (toolName) {
+      case "vibecheck_conductor_register":
+        return handleConductorRegister(args, projectRoot);
+      case "vibecheck_conductor_acquire_lock":
+        return handleConductorAcquireLock(args, projectRoot);
+      case "vibecheck_conductor_release_lock":
+        return handleConductorReleaseLock(args, projectRoot);
+      case "vibecheck_conductor_propose":
+        return handleConductorPropose(args, projectRoot);
+      case "vibecheck_conductor_status":
+        return handleConductorStatus(args, projectRoot);
+      case "vibecheck_conductor_terminate":
+        return handleConductorTerminate(args, projectRoot);
+      default:
+        return {
+          success: false,
+          error: `Unknown conductor tool: ${toolName}`,
+        };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Conductor error: ${getErrorMessage(error)}`,
+    };
+  }
+}
+
+/**
+ * Get all conductor tool definitions
+ */
+export function getConductorTools() {
+  return Object.values(CONDUCTOR_TOOLS);
+}