Git Conflict MCP

Instructions

Implementation Reference

• src/tools/resolveConflict.ts:22-85 (handler)

  The handler function that implements the core logic of the 'resolve_conflict' tool. It identifies the conflicted file, adds a pending resolution to the WebUI, and returns a status message.

  async ({ id, path: filePath, type, reason, force }) => {
      try {
          const projectPath = state.getProjectPath();
          if (!projectPath) {
              return { content: [{ type: "text", text: "Project not initialized. Run init_project first." }], isError: true };
          }
  
          const files = await getConflictedFiles();
          let fileToResolve: string | undefined;
  
          if (id) {
              fileToResolve = files.find(f => generateId(f) === id);
              if (!fileToResolve) {
                  return { content: [{ type: "text", text: "Invalid ID." }], isError: true };
              }
          } else if (filePath) {
              let normalizedPath = filePath;
              if (path.isAbsolute(filePath)) {
                  normalizedPath = path.relative(projectPath, filePath);
              }
              if (files.includes(normalizedPath)) {
                  fileToResolve = normalizedPath;
              } else {
                  return { content: [{ type: "text", text: `File not found in conflicted files. Searched for: ${normalizedPath}` }], isError: true };
              }
          }
  
          if (!fileToResolve) {
              return { content: [{ type: "text", text: "Could not determine file to resolve. Please provide id or path." }], isError: true };
          }
  
          const absolutePath = path.join(projectPath, fileToResolve);
          const resolutionType = type || "resolve";
  
          const result = await addPendingResolve({
              filePath: fileToResolve,
              absolutePath,
              projectPath,
              type: resolutionType,
              reason,
          });
  
          if (!result.success) {
              return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
          }
  
          // Check for status if returned by addPendingResolve (need to cast until typed)
          const status = (result as any).status;
          let msg = `Request sent!\n\nFile: ${fileToResolve}`;
          if (status === 'draft') {
              msg += `\n\nWARNING: The resolution reason was too generic. This item has been marked as 'Draft' and will NOT appear in the review list until the reason is updated.`;
          }
  
          return {
              content: [{
                  type: "text",
                  text: msg
              }]
          };
  
      } catch (e: any) {
          return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
      }
  }

• src/tools/resolveConflict.ts:14-20 (schema)

  Zod input schema defining parameters for the 'resolve_conflict' tool: id, path, type, reason, force.

  inputSchema: z.object({
      id: z.string().optional().describe("The ID of the file to resolve (from list_conflicts)."),
      path: z.string().optional().describe("The file path to resolve."),
      type: z.enum(["resolve", "delete", "add"]).optional().default("resolve").describe("Resolution type. Default is 'resolve'."),
      reason: z.string().optional().describe("The reason why this resolution is valid."),
      force: z.boolean().optional().describe("Force resolution, bypassing the safety check."),
  }),

• src/tools/resolveConflict.ts:9-87 (registration)

  The registration function that sets up the 'resolve_conflict' tool on the MCP server, including name, description, schema, and handler.

  export function registerResolveConflict(server: McpServer) {
      server.registerTool(
          "resolve_conflict",
          {
              description: "Request conflict resolution by its ID or file path. The actual resolution will be performed by a human through the WebUI. Supports different resolution types for various conflict scenarios (content conflicts, delete/modify conflicts, etc.). You must run post_resolve before running this tool.",
              inputSchema: z.object({
                  id: z.string().optional().describe("The ID of the file to resolve (from list_conflicts)."),
                  path: z.string().optional().describe("The file path to resolve."),
                  type: z.enum(["resolve", "delete", "add"]).optional().default("resolve").describe("Resolution type. Default is 'resolve'."),
                  reason: z.string().optional().describe("The reason why this resolution is valid."),
                  force: z.boolean().optional().describe("Force resolution, bypassing the safety check."),
              }),
          },
          async ({ id, path: filePath, type, reason, force }) => {
              try {
                  const projectPath = state.getProjectPath();
                  if (!projectPath) {
                      return { content: [{ type: "text", text: "Project not initialized. Run init_project first." }], isError: true };
                  }
  
                  const files = await getConflictedFiles();
                  let fileToResolve: string | undefined;
  
                  if (id) {
                      fileToResolve = files.find(f => generateId(f) === id);
                      if (!fileToResolve) {
                          return { content: [{ type: "text", text: "Invalid ID." }], isError: true };
                      }
                  } else if (filePath) {
                      let normalizedPath = filePath;
                      if (path.isAbsolute(filePath)) {
                          normalizedPath = path.relative(projectPath, filePath);
                      }
                      if (files.includes(normalizedPath)) {
                          fileToResolve = normalizedPath;
                      } else {
                          return { content: [{ type: "text", text: `File not found in conflicted files. Searched for: ${normalizedPath}` }], isError: true };
                      }
                  }
  
                  if (!fileToResolve) {
                      return { content: [{ type: "text", text: "Could not determine file to resolve. Please provide id or path." }], isError: true };
                  }
  
                  const absolutePath = path.join(projectPath, fileToResolve);
                  const resolutionType = type || "resolve";
  
                  const result = await addPendingResolve({
                      filePath: fileToResolve,
                      absolutePath,
                      projectPath,
                      type: resolutionType,
                      reason,
                  });
  
                  if (!result.success) {
                      return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
                  }
  
                  // Check for status if returned by addPendingResolve (need to cast until typed)
                  const status = (result as any).status;
                  let msg = `Request sent!\n\nFile: ${fileToResolve}`;
                  if (status === 'draft') {
                      msg += `\n\nWARNING: The resolution reason was too generic. This item has been marked as 'Draft' and will NOT appear in the review list until the reason is updated.`;
                  }
  
                  return {
                      content: [{
                          type: "text",
                          text: msg
                      }]
                  };
  
              } catch (e: any) {
                  return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
              }
          }
      );
  }

• src/tools/index.ts:21-21 (registration)

  Invocation of the registerResolveConflict function within the main tools registration module.

  registerResolveConflict(server);