@cyanheads/git-mcp-server 1.2.4

package/build/resources/history.js

@@ -0,0 +1,242 @@
+/**
+ * History Resources
+ * ================
+ *
+ * MCP resources for exposing Git commit history and related information.
+ */
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { GitService } from '../services/git-service.js';
+import { PathValidation } from '../utils/validation.js';
+/**
+ * Helper function to ensure a variable is treated as a string
+ *
+ * @param value - The value to convert to string
+ * @returns A string representation of the value
+ */
+function ensureString(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+/**
+ * Registers history resources with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param resourceDescriptors - Resource descriptors for metadata
+ */
+export function setupHistoryResources(server, resourceDescriptors) {
+    // Commit log resource
+    server.resource("commit-log", new ResourceTemplate("git://repo/{repoPath}/log?maxCount={maxCount}&file={file}", { list: undefined }), {
+        name: "Commit History",
+        description: "Returns the commit history log with author, date, and message details",
+        mimeType: "application/json"
+    }, 
+    // Returns the commit history for a repository with optional file path filter and commit count limit
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const maxCountStr = variables.maxCount ? ensureString(variables.maxCount) : '50';
+            const fileStr = variables.file ? ensureString(variables.file) : undefined;
+            // Normalize paths
+            const normalizedRepoPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            // Parse max count
+            const maxCount = parseInt(maxCountStr, 10);
+            const gitService = new GitService(normalizedRepoPath);
+            // Check if the path is a Git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: "Not a Git repository",
+                                repoPath: normalizedRepoPath,
+                                maxCount: isNaN(maxCount) ? undefined : maxCount,
+                                file: fileStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get commit log
+            const logResult = await gitService.getLog({
+                maxCount: isNaN(maxCount) ? 50 : maxCount,
+                file: fileStr
+            });
+            if (!logResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: logResult.resultError.errorMessage,
+                                repoPath: normalizedRepoPath,
+                                maxCount: isNaN(maxCount) ? undefined : maxCount,
+                                file: fileStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            repoPath: normalizedRepoPath,
+                            maxCount: isNaN(maxCount) ? 50 : maxCount,
+                            file: fileStr,
+                            commits: logResult.resultData
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            repoPath: ensureString(variables.repoPath),
+                            maxCount: variables.maxCount ? parseInt(ensureString(variables.maxCount), 10) : 50,
+                            file: variables.file ? ensureString(variables.file) : undefined
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // File blame resource
+    server.resource("file-blame", new ResourceTemplate("git://repo/{repoPath}/blame/{filePath}", { list: undefined }), {
+        name: "File Blame",
+        description: "Returns line-by-line attribution showing which commit last modified each line",
+        mimeType: "text/plain"
+    }, 
+    // Returns the blame information showing which commit last modified each line of a file
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const filePathStr = ensureString(variables.filePath);
+            // Normalize paths
+            const normalizedRepoPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            const normalizedFilePath = PathValidation.normalizePath(decodeURIComponent(filePathStr));
+            const gitService = new GitService(normalizedRepoPath);
+            // Check if the path is a Git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: "Not a Git repository",
+                                repoPath: normalizedRepoPath,
+                                filePath: normalizedFilePath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get blame information
+            const blameResult = await gitService.getBlame(normalizedFilePath);
+            if (!blameResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: blameResult.resultError.errorMessage,
+                                repoPath: normalizedRepoPath,
+                                filePath: normalizedFilePath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: blameResult.resultData,
+                        mimeType: "text/plain"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            repoPath: ensureString(variables.repoPath),
+                            filePath: ensureString(variables.filePath)
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // Show commit details
+    server.resource("commit-show", new ResourceTemplate("git://repo/{repoPath}/commit/{commitHash}", { list: undefined }), {
+        name: "Commit Details",
+        description: "Returns detailed information about a specific commit including diff changes",
+        mimeType: "text/plain"
+    }, 
+    // Returns the detailed information for a specific commit including diff and metadata
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const commitHashStr = ensureString(variables.commitHash);
+            // Normalize paths
+            const normalizedRepoPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            const gitService = new GitService(normalizedRepoPath);
+            // Check if the path is a Git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: "Not a Git repository",
+                                repoPath: normalizedRepoPath,
+                                commitHash: commitHashStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get commit details
+            const commitResult = await gitService.showCommit(commitHashStr);
+            if (!commitResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: commitResult.resultError.errorMessage,
+                                repoPath: normalizedRepoPath,
+                                commitHash: commitHashStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: commitResult.resultData,
+                        mimeType: "text/plain"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            repoPath: ensureString(variables.repoPath),
+                            commitHash: ensureString(variables.commitHash)
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+}

package/build/resources/index.js

@@ -0,0 +1,99 @@
+/**
+ * Resource Handlers
+ * ===============
+ *
+ * Entry point for all MCP resource implementations.
+ * This module registers all resource handlers with the MCP server.
+ */
+import { setupRepositoryResources } from './repository.js';
+import { setupFileResources } from './file.js';
+import { setupDiffResources } from './diff.js';
+import { setupHistoryResources } from './history.js';
+import { resourceDescriptors } from './descriptors.js';
+/**
+ * Metadata for resource descriptions
+ */
+export const resourceMetadata = {
+    // Repository resources
+    "repository-info": {
+        name: "Repository Information",
+        description: "Returns basic Git repository information including current branch, status, and reference details",
+        mimeType: "application/json"
+    },
+    "repository-branches": {
+        name: "Repository Branches",
+        description: "Returns a list of all branches in the repository with current branch indicator",
+        mimeType: "application/json"
+    },
+    "repository-remotes": {
+        name: "Repository Remotes",
+        description: "Returns a list of all configured remote repositories with their URLs",
+        mimeType: "application/json"
+    },
+    "repository-tags": {
+        name: "Repository Tags",
+        description: "Returns a list of all tags in the repository with their references",
+        mimeType: "application/json"
+    },
+    // File resources
+    "file-at-ref": {
+        name: "File Content",
+        description: "Returns the content of a specific file at a given Git reference",
+        mimeType: "text/plain"
+    },
+    "directory-listing": {
+        name: "Directory Listing",
+        description: "Returns a list of files and directories at a specific path and reference",
+        mimeType: "application/json"
+    },
+    // Diff resources
+    "diff-refs": {
+        name: "Reference Diff",
+        description: "Returns a diff between two Git references (commits, branches, tags)",
+        mimeType: "text/plain"
+    },
+    "diff-unstaged": {
+        name: "Unstaged Changes Diff",
+        description: "Returns a diff of all unstaged changes in the working directory",
+        mimeType: "text/plain"
+    },
+    "diff-staged": {
+        name: "Staged Changes Diff",
+        description: "Returns a diff of all staged changes in the index",
+        mimeType: "text/plain"
+    },
+    // History resources
+    "commit-log": {
+        name: "Commit History",
+        description: "Returns the commit history log with author, date, and message details",
+        mimeType: "application/json"
+    },
+    "file-blame": {
+        name: "File Blame",
+        description: "Returns line-by-line attribution showing which commit last modified each line",
+        mimeType: "text/plain"
+    },
+    "commit-show": {
+        name: "Commit Details",
+        description: "Returns detailed information about a specific commit including diff changes",
+        mimeType: "text/plain"
+    }
+};
+/**
+ * Registers all Git MCP resources with the server
+ *
+ * @param server - MCP server instance
+ */
+export function registerAllResources(server) {
+    // Repository info resources (status, branches, remotes, etc.)
+    setupRepositoryResources(server, resourceDescriptors);
+    // File resources (file content, directory listings)
+    setupFileResources(server, resourceDescriptors);
+    // Diff resources (changes between refs, unstaged, staged)
+    setupDiffResources(server, resourceDescriptors);
+    // History resources (log, blame, show commit)
+    setupHistoryResources(server, resourceDescriptors);
+    // Note: Metadata for resources is defined in the resourceMetadata object,
+    // which can be used when registering resources in their respective handlers.
+    // The MCP protocol exposes this metadata through the registered resources.
+}

package/build/resources/repository.js

@@ -0,0 +1,286 @@
+/**
+ * Repository Resources
+ * ===================
+ *
+ * MCP resources for exposing Git repository information.
+ */
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { GitService } from '../services/git-service.js';
+import { PathValidation } from '../utils/validation.js';
+/**
+ * Helper function to ensure a variable is treated as a string
+ *
+ * @param value - The value to convert to string
+ * @returns A string representation of the value
+ */
+function ensureString(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+/**
+ * Registers repository resources with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param resourceDescriptors - Resource descriptors for metadata
+ */
+export function setupRepositoryResources(server, resourceDescriptors) {
+    // Repository information resource
+    // Repository information resource
+    server.resource("repository-info", new ResourceTemplate("git://repo/{repoPath}/info", { list: undefined }), {
+        name: "Repository Information",
+        description: "Basic Git repository information including current branch, status, and reference details",
+        mimeType: "application/json"
+    }, async (uri, variables) => {
+        try {
+            // Handle repoPath which might be an array
+            const repoPathStr = ensureString(variables.repoPath);
+            const normalizedPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            const gitService = new GitService(normalizedPath);
+            // Check if the path is a Git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: "Not a Git repository",
+                                path: normalizedPath,
+                                isGitRepository: false
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get repository status
+            const statusResult = await gitService.getStatus();
+            if (!statusResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: statusResult.resultError.errorMessage,
+                                path: normalizedPath,
+                                isGitRepository: true
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            path: normalizedPath,
+                            isGitRepository: true,
+                            status: statusResult.resultData
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            path: ensureString(variables.repoPath),
+                            isGitRepository: false
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // Repository branches resource
+    // Branches resource
+    server.resource("repository-branches", new ResourceTemplate("git://repo/{repoPath}/branches", { list: undefined }), {
+        name: "Repository Branches",
+        description: "List of all branches in the repository with current branch indicator",
+        mimeType: "application/json"
+    }, async (uri, variables) => {
+        try {
+            // Handle repoPath which might be an array
+            const repoPathStr = ensureString(variables.repoPath);
+            const normalizedPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            const gitService = new GitService(normalizedPath);
+            // Check if the path is a Git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: "Not a Git repository",
+                                path: normalizedPath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get branches
+            const branchesResult = await gitService.listBranches(true);
+            if (!branchesResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: branchesResult.resultError.errorMessage,
+                                path: normalizedPath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            path: normalizedPath,
+                            branches: branchesResult.resultData
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            path: ensureString(variables.repoPath)
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // Repository remotes resource
+    // Remotes resource
+    server.resource("repository-remotes", new ResourceTemplate("git://repo/{repoPath}/remotes", { list: undefined }), {
+        name: "Repository Remotes",
+        description: "List of all configured remote repositories with their URLs",
+        mimeType: "application/json"
+    }, async (uri, variables) => {
+        try {
+            // Handle repoPath which might be an array
+            const repoPathStr = ensureString(variables.repoPath);
+            const normalizedPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            const gitService = new GitService(normalizedPath);
+            // Check if the path is a Git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: "Not a Git repository",
+                                path: normalizedPath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get remotes
+            const remotesResult = await gitService.listRemotes();
+            if (!remotesResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: remotesResult.resultError.errorMessage,
+                                path: normalizedPath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            path: normalizedPath,
+                            remotes: remotesResult.resultData
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            path: ensureString(variables.repoPath)
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // Repository tags resource
+    // Tags resource
+    server.resource("repository-tags", new ResourceTemplate("git://repo/{repoPath}/tags", { list: undefined }), {
+        name: "Repository Tags",
+        description: "List of all tags in the repository with their references",
+        mimeType: "application/json"
+    }, async (uri, variables) => {
+        try {
+            // Handle repoPath which might be an array
+            const repoPathStr = ensureString(variables.repoPath);
+            const normalizedPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            const gitService = new GitService(normalizedPath);
+            // Check if the path is a Git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: "Not a Git repository",
+                                path: normalizedPath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get tags
+            const tagsResult = await gitService.listTags();
+            if (!tagsResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: tagsResult.resultError.errorMessage,
+                                path: normalizedPath
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            path: normalizedPath,
+                            tags: tagsResult.resultData
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                            path: ensureString(variables.repoPath)
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+}