@cyanheads/git-mcp-server 1.2.4

package/build/resources/descriptors.js

@@ -0,0 +1,77 @@
+/**
+ * Resource Descriptors
+ * ===================
+ *
+ * This module defines descriptors for Git MCP resources.
+ * These descriptions help both users and LLMs understand
+ * what each resource does and what data it returns.
+ */
+/**
+ * Map of resource descriptors keyed by resource ID
+ */
+export const resourceDescriptors = {
+    // Repository resources
+    "repository-info": {
+        name: "Repository Information",
+        description: "Basic Git repository information including current branch, status, and reference details",
+        mimeType: "application/json"
+    },
+    "repository-branches": {
+        name: "Repository Branches",
+        description: "List of all branches in the repository with current branch indicator",
+        mimeType: "application/json"
+    },
+    "repository-remotes": {
+        name: "Repository Remotes",
+        description: "List of all configured remote repositories with their URLs",
+        mimeType: "application/json"
+    },
+    "repository-tags": {
+        name: "Repository Tags",
+        description: "List of all tags in the repository with their references",
+        mimeType: "application/json"
+    },
+    // File resources
+    "file-at-ref": {
+        name: "File Content",
+        description: "The content of a specific file at a given Git reference",
+        mimeType: "text/plain"
+    },
+    "directory-listing": {
+        name: "Directory Listing",
+        description: "List of files and directories at a specific path and reference",
+        mimeType: "application/json"
+    },
+    // Diff resources
+    "diff-refs": {
+        name: "Reference Diff",
+        description: "Diff between two Git references (commits, branches, tags)",
+        mimeType: "text/plain"
+    },
+    "diff-unstaged": {
+        name: "Unstaged Changes Diff",
+        description: "Diff of all unstaged changes in the working directory",
+        mimeType: "text/plain"
+    },
+    "diff-staged": {
+        name: "Staged Changes Diff",
+        description: "Diff of all staged changes in the index",
+        mimeType: "text/plain"
+    },
+    // History resources
+    "commit-log": {
+        name: "Commit History",
+        description: "Commit history log with author, date, and message details",
+        mimeType: "application/json"
+    },
+    "file-blame": {
+        name: "File Blame",
+        description: "Line-by-line attribution showing which commit last modified each line",
+        mimeType: "text/plain"
+    },
+    "commit-show": {
+        name: "Commit Details",
+        description: "Detailed information about a specific commit including diff changes",
+        mimeType: "text/plain"
+    }
+};

package/build/resources/diff.js

@@ -0,0 +1,241 @@
+/**
+ * Diff Resources
+ * =============
+ *
+ * MCP resources for exposing Git diff 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 diff resources with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param resourceDescriptors - Resource descriptors for metadata
+ */
+export function setupDiffResources(server, resourceDescriptors) {
+    // Diff between two refs
+    server.resource("diff-refs", new ResourceTemplate("git://repo/{repoPath}/diff/{fromRef}/{toRef}?path={path}", { list: undefined }), {
+        name: "Reference Diff",
+        description: "Returns a diff between two Git references (commits, branches, tags)",
+        mimeType: "application/json" // Corrected MIME type
+    }, 
+    // Returns a diff between two references (branches, tags, or commits) with optional path filter
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const fromRefStr = ensureString(variables.fromRef);
+            const toRefStr = variables.toRef ? ensureString(variables.toRef) : 'HEAD';
+            const pathStr = variables.path ? ensureString(variables.path) : undefined;
+            // 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,
+                                fromRef: fromRefStr,
+                                toRef: toRefStr,
+                                path: pathStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get diff
+            const diffResult = await gitService.getDiff(fromRefStr, toRefStr, pathStr);
+            if (!diffResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: diffResult.resultError.errorMessage,
+                                repoPath: normalizedRepoPath,
+                                fromRef: fromRefStr,
+                                toRef: toRefStr,
+                                path: pathStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: JSON.stringify({
+                            repoPath: normalizedRepoPath,
+                            fromRef: fromRefStr,
+                            toRef: toRefStr,
+                            path: pathStr,
+                            diff: diffResult.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),
+                            fromRef: ensureString(variables.fromRef),
+                            toRef: variables.toRef ? ensureString(variables.toRef) : 'HEAD',
+                            path: variables.path ? ensureString(variables.path) : undefined
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // Diff in working directory (unstaged changes)
+    server.resource("diff-unstaged", new ResourceTemplate("git://repo/{repoPath}/diff-unstaged?path={path}", { list: undefined }), {
+        name: "Unstaged Changes Diff",
+        description: "Returns a diff of all unstaged changes in the working directory",
+        mimeType: "text/plain"
+    }, 
+    // Returns a diff of all unstaged changes (between working directory and index) with optional path filter
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const pathStr = variables.path ? ensureString(variables.path) : undefined;
+            // 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,
+                                path: pathStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get unstaged diff
+            const diffResult = await gitService.getUnstagedDiff(pathStr);
+            if (!diffResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: diffResult.resultError.errorMessage,
+                                repoPath: normalizedRepoPath,
+                                path: pathStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: diffResult.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),
+                            path: variables.path ? ensureString(variables.path) : undefined
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // Diff staged changes
+    server.resource("diff-staged", new ResourceTemplate("git://repo/{repoPath}/diff-staged?path={path}", { list: undefined }), {
+        name: "Staged Changes Diff",
+        description: "Returns a diff of all staged changes in the index",
+        mimeType: "text/plain"
+    }, 
+    // Returns a diff of all staged changes (between index and HEAD) with optional path filter
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const pathStr = variables.path ? ensureString(variables.path) : undefined;
+            // 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,
+                                path: pathStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get staged diff
+            const diffResult = await gitService.getStagedDiff(pathStr);
+            if (!diffResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: diffResult.resultError.errorMessage,
+                                repoPath: normalizedRepoPath,
+                                path: pathStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: diffResult.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),
+                            path: variables.path ? ensureString(variables.path) : undefined
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+}

package/build/resources/file.js

@@ -0,0 +1,222 @@
+/**
+ * File Resources
+ * =============
+ *
+ * MCP resources for exposing Git file contents at specific references.
+ */
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { GitService } from '../services/git-service.js';
+import { PathValidation } from '../utils/validation.js';
+import path from 'path';
+/**
+ * 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 file resources with the MCP server
+ *
+ * @param server - MCP server instance
+ * @param resourceDescriptors - Resource descriptors for metadata
+ */
+export function setupFileResources(server, resourceDescriptors) {
+    // File contents at a specific reference
+    server.resource("file-at-ref", new ResourceTemplate("git://repo/{repoPath}/file/{filePath}?ref={ref}", { list: undefined }), {
+        name: "File Content",
+        description: "Returns the content of a specific file at a given Git reference",
+        mimeType: "text/plain"
+    }, 
+    // Returns the content of a specific file at a given reference (branch, tag, or commit)
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const filePathStr = ensureString(variables.filePath);
+            const refStr = variables.ref ? ensureString(variables.ref) : 'HEAD';
+            // 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,
+                                ref: refStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Get file content at reference
+            const fileResult = await gitService.getFileAtRef(normalizedFilePath, refStr);
+            if (!fileResult.resultSuccessful) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: fileResult.resultError.errorMessage,
+                                repoPath: normalizedRepoPath,
+                                filePath: normalizedFilePath,
+                                ref: refStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Detect MIME type based on file extension
+            const fileExtension = path.extname(normalizedFilePath).toLowerCase();
+            let mimeType = "text/plain";
+            // Simple MIME type detection
+            if (['.js', '.ts', '.jsx', '.tsx'].includes(fileExtension)) {
+                mimeType = "application/javascript";
+            }
+            else if (['.html', '.htm'].includes(fileExtension)) {
+                mimeType = "text/html";
+            }
+            else if (fileExtension === '.css') {
+                mimeType = "text/css";
+            }
+            else if (fileExtension === '.json') {
+                mimeType = "application/json";
+            }
+            else if (['.md', '.markdown'].includes(fileExtension)) {
+                mimeType = "text/markdown";
+            }
+            else if (['.xml', '.svg'].includes(fileExtension)) {
+                mimeType = "application/xml";
+            }
+            else if (['.yml', '.yaml'].includes(fileExtension)) {
+                mimeType = "text/yaml";
+            }
+            // Return the file content directly
+            return {
+                contents: [{
+                        uri: uri.href,
+                        text: fileResult.resultData,
+                        mimeType
+                    }]
+            };
+        }
+        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),
+                            ref: variables.ref ? ensureString(variables.ref) : 'HEAD'
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+    // List files in a directory at a specific reference
+    server.resource("directory-listing", new ResourceTemplate("git://repo/{repoPath}/ls/{dirPath}?ref={ref}", { list: undefined }), {
+        name: "Directory Listing",
+        description: "Returns a list of files and directories at a specific path and reference",
+        mimeType: "application/json"
+    }, 
+    // Returns a list of files and directories within a specific directory at a given reference
+    async (uri, variables) => {
+        try {
+            // Handle variables which might be arrays
+            const repoPathStr = ensureString(variables.repoPath);
+            const dirPathStr = ensureString(variables.dirPath || '');
+            const refStr = variables.ref ? ensureString(variables.ref) : 'HEAD';
+            // Normalize paths
+            const normalizedRepoPath = PathValidation.normalizePath(decodeURIComponent(repoPathStr));
+            const normalizedDirPath = PathValidation.normalizePath(decodeURIComponent(dirPathStr));
+            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,
+                                dirPath: normalizedDirPath,
+                                ref: refStr
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            // Use Git command to get directory listing
+            try {
+                // Use the listFilesAtRef method from GitService
+                const filesResult = await gitService.listFilesAtRef(normalizedDirPath, refStr);
+                if (!filesResult.resultSuccessful) {
+                    return {
+                        contents: [{
+                                uri: uri.href,
+                                text: JSON.stringify({
+                                    error: filesResult.resultError.errorMessage,
+                                    repoPath: normalizedRepoPath,
+                                    dirPath: normalizedDirPath,
+                                    ref: refStr
+                                }, null, 2),
+                                mimeType: "application/json"
+                            }]
+                    };
+                }
+                // The listFilesAtRef method now returns only immediate children,
+                // so no need to strip prefixes here.
+                const files = filesResult.resultData;
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                repoPath: normalizedRepoPath,
+                                dirPath: normalizedDirPath,
+                                ref: refStr,
+                                files
+                            }, null, 2),
+                            mimeType: "application/json"
+                        }]
+                };
+            }
+            catch (gitError) {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify({
+                                error: gitError instanceof Error ? gitError.message : String(gitError),
+                                repoPath: normalizedRepoPath,
+                                dirPath: normalizedDirPath,
+                                ref: refStr
+                            }, 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),
+                            dirPath: variables.dirPath ? ensureString(variables.dirPath) : '',
+                            ref: variables.ref ? ensureString(variables.ref) : 'HEAD'
+                        }, null, 2),
+                        mimeType: "application/json"
+                    }]
+            };
+        }
+    });
+}