@vibecheckai/cli 3.9.1 → 4.0.0

package/mcp-server/conductor/tools.js

@@ -1,510 +0,0 @@
-/**
- * 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);
-}