@cyanheads/git-mcp-server 2.0.1 → 2.0.3

package/build/mcp-server/tools/gitCommit/logic.js

@@ -1,129 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { z } from 'zod';
-import { BaseErrorCode, McpError } from '../../../types-global/errors.js';
-import { logger } from '../../../utils/logger.js';
-import { sanitization } from '../../../utils/sanitization.js';
-const execAsync = promisify(exec);
-// Define the input schema for the git_commit tool using Zod
-export const GitCommitInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the Git repository. Defaults to the session's working directory if set via `git_set_working_dir`, otherwise defaults to the server's current working directory (`.`)."),
-    message: z.string().min(1).describe('Commit message. Follow Conventional Commits format: `type(scope): subject`. Example: `feat(api): add user signup endpoint`'),
-    author: z.object({
-        name: z.string().describe('Author name for the commit'),
-        email: z.string().email().describe('Author email for the commit'),
-    }).optional().describe('Overrides the commit author information (name and email). Use only when necessary (e.g., applying external patches).'),
-    allowEmpty: z.boolean().default(false).describe('Allow creating empty commits'),
-    amend: z.boolean().default(false).describe('Amend the previous commit instead of creating a new one'),
-});
-/**
- * Executes the 'git commit' command and returns structured JSON output.
- *
- * @param {GitCommitInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitCommitResult>} A promise that resolves with the structured commit result.
- * @throws {McpError} Throws an McpError if path resolution or validation fails, or if the git command fails unexpectedly.
- */
-export async function commitGitChanges(input, context // Add getter to context
-) {
-    const operation = 'commitGitChanges';
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve the target path
-        if (input.path && input.path !== '.') {
-            targetPath = input.path;
-            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
-        }
-        else {
-            const workingDir = context.getWorkingDirectory();
-            if (!workingDir) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
-            }
-            targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
-        }
-        // Sanitize the resolved path
-        const sanitizedPath = sanitization.sanitizePath(targetPath);
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath });
-        targetPath = sanitizedPath; // Use the sanitized path going forward
-    }
-    catch (error) {
-        logger.error('Path resolution or sanitization failed', { ...context, operation, error });
-        if (error instanceof McpError) {
-            throw error;
-        }
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
-    }
-    try {
-        // Construct the git commit command using the resolved targetPath
-        let command = `git -C "${targetPath}" commit -m "${input.message.replace(/"/g, '\\"')}"`; // Escape double quotes
-        if (input.allowEmpty) {
-            command += ' --allow-empty';
-        }
-        if (input.amend) {
-            command += ' --amend --no-edit';
-        }
-        if (input.author) {
-            // Ensure author details are properly escaped if needed, though exec usually handles this
-            command = `git -C "${targetPath}" -c user.name="${input.author.name.replace(/"/g, '\\"')}" -c user.email="${input.author.email.replace(/"/g, '\\"')}" commit -m "${input.message.replace(/"/g, '\\"')}"`;
-            if (input.allowEmpty)
-                command += ' --allow-empty';
-            if (input.amend)
-                command += ' --amend --no-edit';
-        }
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
-        const { stdout, stderr } = await execAsync(command);
-        // Check stderr first for common non-error messages
-        if (stderr) {
-            if (stderr.includes('nothing to commit, working tree clean') || stderr.includes('no changes added to commit')) {
-                const msg = stderr.includes('nothing to commit') ? 'Nothing to commit, working tree clean.' : 'No changes added to commit.';
-                logger.info(msg, { ...context, operation, path: targetPath });
-                // Use statusMessage
-                return { success: true, statusMessage: msg, nothingToCommit: true };
-            }
-            // Log other stderr as warning but continue, as commit might still succeed
-            logger.warning(`Git commit command produced stderr`, { ...context, operation, stderr });
-        }
-        // Extract commit hash (more robustly)
-        let commitHash = undefined;
-        const hashMatch = stdout.match(/([a-f0-9]{7,40})/); // Look for typical short or long hash
-        if (hashMatch) {
-            commitHash = hashMatch[1];
-        }
-        else {
-            // Fallback parsing if needed, or rely on success message
-            logger.warning('Could not parse commit hash from stdout', { ...context, operation, stdout });
-        }
-        // Use statusMessage
-        const statusMsg = commitHash
-            ? `Commit successful: ${commitHash}`
-            : `Commit successful (stdout: ${stdout.trim()})`;
-        logger.info(`${operation} executed successfully`, { ...context, operation, path: targetPath, commitHash });
-        return {
-            success: true,
-            statusMessage: statusMsg,
-            commitHash: commitHash
-        };
-    }
-    catch (error) {
-        logger.error(`Failed to execute git commit command`, { ...context, operation, path: targetPath, error: error.message, stderr: error.stderr });
-        const errorMessage = error.stderr || error.message || '';
-        // Handle specific error cases first
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes('nothing to commit') || errorMessage.includes('no changes added to commit')) {
-            // This might happen if git exits with error despite these messages
-            const msg = errorMessage.includes('nothing to commit') ? 'Nothing to commit, working tree clean.' : 'No changes added to commit.';
-            logger.info(msg + ' (caught as error)', { ...context, operation, path: targetPath, errorMessage });
-            // Return success=false but indicate the reason using statusMessage
-            return { success: false, statusMessage: msg, nothingToCommit: true };
-        }
-        if (errorMessage.includes('conflicts')) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Commit failed due to unresolved conflicts in ${targetPath}`, { context, operation, originalError: error });
-        }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to commit changes for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
-    }
-}

package/build/mcp-server/tools/gitInit/registration.js

@@ -1,44 +0,0 @@
-import { ErrorHandler } from '../../../utils/errorHandler.js';
-import { logger } from '../../../utils/logger.js';
-import { requestContextService } from '../../../utils/requestContext.js';
-import { GitInitInputSchema, gitInitLogic } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
-const TOOL_NAME = 'git_init';
-const TOOL_DESCRIPTION = 'Initializes a new Git repository at the specified absolute path. Can optionally set the initial branch name and create a bare repository.';
-/**
- * Registers the git_init tool with the MCP server.
- *
- * @param {McpServer} server - The McpServer instance to register the tool with.
- * @returns {Promise<void>}
- * @throws {Error} If registration fails.
- */
-export const registerGitInitTool = async (server) => {
-    const operation = 'registerGitInitTool';
-    const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitInitInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = 'tool:git_init';
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
-            logger.info(`Executing tool: ${TOOL_NAME}`, requestContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function
-                const initResult = await gitInitLogic(validatedArgs, requestContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: 'text',
-                    text: JSON.stringify(initResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, requestContext);
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: requestContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error occurs
-            });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true }); // Mark registration as critical
-};

package/build/types-global/mcp.js

@@ -1,59 +0,0 @@
-// Type definitions for the MCP (Message Control Protocol) protocol
-// and standard JSON-RPC 2.0 structures
-// Standard JSON-RPC 2.0 Error Codes
-export var JsonRpcErrorCode;
-(function (JsonRpcErrorCode) {
-    JsonRpcErrorCode[JsonRpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-    JsonRpcErrorCode[JsonRpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-    JsonRpcErrorCode[JsonRpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-    JsonRpcErrorCode[JsonRpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-    JsonRpcErrorCode[JsonRpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-    // -32000 to -32099 are reserved for implementation-defined server-errors.
-    JsonRpcErrorCode[JsonRpcErrorCode["SERVER_ERROR_START"] = -32000] = "SERVER_ERROR_START";
-    JsonRpcErrorCode[JsonRpcErrorCode["SERVER_ERROR_END"] = -32099] = "SERVER_ERROR_END";
-})(JsonRpcErrorCode || (JsonRpcErrorCode = {}));
-// ==================================
-// Helper Functions (Updated for JSON-RPC context)
-// ==================================
-/**
- * Creates a JSON-RPC 2.0 Success Response containing an McpToolResult.
- */
-export const createJsonRpcToolSuccessResponse = (id, text) => ({
-    jsonrpc: "2.0",
-    result: {
-        content: [{ type: "text", text }]
-    },
-    id
-});
-/**
- * Creates a JSON-RPC 2.0 Error Response.
- */
-export const createJsonRpcErrorResponse = (id, code, message, data) => ({
-    jsonrpc: "2.0",
-    error: {
-        code,
-        message,
-        ...(data !== undefined && { data }) // Include data only if provided
-    },
-    id
-});
-/**
- * Creates a JSON-RPC 2.0 Success Response containing an McpResourceResult.
- */
-export const createJsonRpcResourceSuccessResponse = (id, uri, text, mimeType) => ({
-    jsonrpc: "2.0",
-    result: {
-        contents: [{ uri, text, mimeType }]
-    },
-    id
-});
-// Note: PromptResponse helper might need adjustment depending on how prompts fit into JSON-RPC
-export const createPromptResponse = (text, role = "assistant") => ({
-    messages: [{
-            role,
-            content: {
-                type: "text",
-                text
-            }
-        }]
-});

package/build/types-global/tool.js

@@ -1 +0,0 @@
-export {};

package/build/utils/index.js

@@ -1,11 +0,0 @@
-// Re-export all utilities using wildcard exports for simplicity
-export * from './requestContext.js';
-export * from './errorHandler.js';
-export * from './idGenerator.js';
-export * from './logger.js';
-export * from './rateLimiter.js';
-export * from './sanitization.js';
-export * from './tokenCounter.js';
-export * from './jsonParser.js';
-// No need for explicit named imports/exports or default export
-// when using wildcard exports for a simple barrel file.

package/build/utils/logger.js

@@ -1,266 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import winston from 'winston';
-import { config } from '../config/index.js'; // Import config for logger name
-// Define the numeric severity for comparison (lower is more severe)
-const mcpLevelSeverity = {
-    emerg: 0, alert: 1, crit: 2, error: 3, warning: 4, notice: 5, info: 6, debug: 7
-};
-// Map MCP levels to Winston's core levels for file logging
-const mcpToWinstonLevel = {
-    debug: 'debug',
-    info: 'info',
-    notice: 'info', // Map notice to info for file logging
-    warning: 'warn',
-    error: 'error',
-    crit: 'error', // Map critical levels to error for file logging
-    alert: 'error',
-    emerg: 'error',
-};
-// Resolve __dirname for ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Project root assumed two levels above utils/
-const projectRoot = path.resolve(__dirname, '..', '..');
-const logsDir = path.join(projectRoot, 'logs');
-// Security: ensure logsDir is within projectRoot
-const resolvedLogsDir = path.resolve(logsDir);
-const isLogsDirSafe = resolvedLogsDir === projectRoot || resolvedLogsDir.startsWith(projectRoot + path.sep);
-if (!isLogsDirSafe) {
-    // Use console.error here as logger might not be initialized or safe
-    console.error(`FATAL: logs directory "${resolvedLogsDir}" is outside project root "${projectRoot}". File logging disabled.`);
-}
-/**
- * Singleton Logger wrapping Winston, adapted for MCP.
- * Logs to files and optionally sends MCP notifications/message.
- */
-class Logger {
-    static instance;
-    winstonLogger;
-    initialized = false;
-    mcpNotificationSender;
-    currentMcpLevel = 'info'; // Default MCP level
-    currentWinstonLevel = 'info'; // Default Winston level
-    constructor() { }
-    /**
-     * Initialize Winston logger for file transport. Must be called once at app start.
-     * Console transport is removed.
-     * @param level Initial minimum level to log ('info' default).
-     */
-    initialize(level = 'info') {
-        if (this.initialized) {
-            // Use console.warn as logger might be re-initializing
-            console.warn('Logger already initialized.');
-            return;
-        }
-        this.currentMcpLevel = level;
-        this.currentWinstonLevel = mcpToWinstonLevel[level];
-        // Ensure logs directory exists
-        if (isLogsDirSafe) {
-            try {
-                if (!fs.existsSync(resolvedLogsDir)) {
-                    fs.mkdirSync(resolvedLogsDir, { recursive: true });
-                    // Use console.log as logger isn't fully ready
-                    console.log(`Created logs directory: ${resolvedLogsDir}`);
-                }
-            }
-            catch (err) {
-                // Use console.error as logger isn't fully ready
-                console.error(`Error creating logs directory at ${resolvedLogsDir}: ${err.message}. File logging disabled.`);
-            }
-        }
-        // Common format for files
-        const fileFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), 
-        // Use JSON format for file logs for easier parsing
-        winston.format.json());
-        const transports = [];
-        // Add file transports only if the directory is safe
-        if (isLogsDirSafe) {
-            transports.push(
-            // Log levels equal to or more severe than the specified level
-            new winston.transports.File({ filename: path.join(resolvedLogsDir, 'error.log'), level: 'error', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'warn.log'), level: 'warn', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'info.log'), level: 'info', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'debug.log'), level: 'debug', format: fileFormat }), 
-            // Combined log captures everything based on the main logger level
-            new winston.transports.File({ filename: path.join(resolvedLogsDir, 'combined.log'), format: fileFormat }));
-        }
-        else {
-            // Use console.warn as logger isn't fully ready
-            console.warn("File logging disabled due to unsafe logs directory path.");
-        }
-        // Create logger with the initial Winston level and file transports
-        this.winstonLogger = winston.createLogger({
-            level: this.currentWinstonLevel, // Set Winston level for file logging
-            transports,
-            exitOnError: false
-        });
-        this.initialized = true;
-        // Log initialization message using the logger itself (will go to file)
-        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}`);
-    }
-    /**
-     * Sets the function used to send MCP 'notifications/message'.
-     * This should be called by the server logic once an MCP connection
-     * supporting logging is established.
-     * @param sender The function to call for sending notifications.
-     */
-    setMcpNotificationSender(sender) {
-        this.mcpNotificationSender = sender;
-        const status = sender ? 'enabled' : 'disabled';
-        this.info(`MCP notification sending ${status}.`);
-    }
-    /**
-     * Dynamically sets the minimum logging level for both file logging and MCP notifications.
-     * @param newLevel The new minimum MCP log level.
-     */
-    setLevel(newLevel) {
-        if (!this.ensureInitialized()) {
-            // Use console.error as logger state is uncertain
-            console.error("Cannot set level: Logger not initialized.");
-            return;
-        }
-        // Validate the level
-        if (!(newLevel in mcpLevelSeverity)) {
-            this.warning(`Invalid MCP log level provided: ${newLevel}. Level not changed.`);
-            return;
-        }
-        this.currentMcpLevel = newLevel;
-        this.currentWinstonLevel = mcpToWinstonLevel[newLevel];
-        this.winstonLogger.level = this.currentWinstonLevel; // Update Winston level for files
-        this.info(`Log level set. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}`);
-    }
-    /** Get singleton instance. */
-    static getInstance() {
-        if (!Logger.instance) {
-            Logger.instance = new Logger();
-        }
-        return Logger.instance;
-    }
-    /** Ensures the logger has been initialized. */
-    ensureInitialized() {
-        if (!this.initialized || !this.winstonLogger) {
-            // Use console.warn as this indicates a programming error (calling log before init)
-            console.warn('Logger not initialized; message dropped.');
-            return false;
-        }
-        return true;
-    }
-    /** Centralized log processing */
-    log(level, msg, context, error) {
-        if (!this.ensureInitialized())
-            return;
-        // Check if message level is severe enough for current setting
-        if (mcpLevelSeverity[level] > mcpLevelSeverity[this.currentMcpLevel]) {
-            return; // Skip logging if level is less severe than current setting
-        }
-        const logData = { ...context }; // Copy context
-        const winstonLevel = mcpToWinstonLevel[level];
-        // Log to Winston (files)
-        if (error) {
-            // Include error details for Winston file log
-            logData.error = { message: error.message, stack: error.stack };
-            this.winstonLogger.log(winstonLevel, msg, logData);
-        }
-        else {
-            this.winstonLogger.log(winstonLevel, msg, logData);
-        }
-        // Send MCP notification if sender is configured
-        if (this.mcpNotificationSender) {
-            // Prepare data for MCP: combine message and context/error info
-            const mcpDataPayload = { message: msg };
-            if (context) {
-                mcpDataPayload.context = context;
-            }
-            if (error) {
-                // Include simplified error info for MCP notification
-                mcpDataPayload.error = { message: error.message };
-                // Optionally include stack in debug mode? Be cautious about size.
-                if (this.currentMcpLevel === 'debug' && error.stack) {
-                    mcpDataPayload.error.stack = error.stack.substring(0, 500); // Limit stack trace size
-                }
-            }
-            try {
-                this.mcpNotificationSender(level, mcpDataPayload, config.mcpServerName);
-            }
-            catch (sendError) {
-                // Log failure to send MCP notification to file log
-                this.winstonLogger.error("Failed to send MCP log notification", {
-                    originalLevel: level,
-                    originalMessage: msg,
-                    sendError: sendError instanceof Error ? sendError.message : String(sendError),
-                    mcpPayload: mcpDataPayload // Log what we tried to send
-                });
-            }
-        }
-    }
-    // --- Public Logging Methods ---
-    /** Log debug message (level 7) */
-    debug(msg, context) {
-        this.log('debug', msg, context);
-    }
-    /** Log info message (level 6) */
-    info(msg, context) {
-        this.log('info', msg, context);
-    }
-    /** Log notice message (level 5) */
-    notice(msg, context) {
-        this.log('notice', msg, context);
-    }
-    /** Log warning message (level 4) */
-    warning(msg, context) {
-        this.log('warning', msg, context);
-    }
-    /** Log error message (level 3) */
-    error(msg, err, context) {
-        if (err instanceof Error) {
-            this.log('error', msg, context, err);
-        }
-        else {
-            // If err is not an Error object, treat it as additional context
-            const combinedContext = { ...(err || {}), ...(context || {}) };
-            this.log('error', msg, combinedContext);
-        }
-    }
-    /** Log critical message (level 2) */
-    crit(msg, err, context) {
-        if (err instanceof Error) {
-            this.log('crit', msg, context, err);
-        }
-        else {
-            const combinedContext = { ...(err || {}), ...(context || {}) };
-            this.log('crit', msg, combinedContext);
-        }
-    }
-    /** Log alert message (level 1) */
-    alert(msg, err, context) {
-        if (err instanceof Error) {
-            this.log('alert', msg, context, err);
-        }
-        else {
-            const combinedContext = { ...(err || {}), ...(context || {}) };
-            this.log('alert', msg, combinedContext);
-        }
-    }
-    /** Log emergency message (level 0) */
-    emerg(msg, err, context) {
-        if (err instanceof Error) {
-            this.log('emerg', msg, context, err);
-        }
-        else {
-            const combinedContext = { ...(err || {}), ...(context || {}) };
-            this.log('emerg', msg, combinedContext);
-        }
-    }
-    /** Log fatal message (alias for emergency, ensures process exit) */
-    fatal(msg, context, error) {
-        this.log('emerg', msg, context, error);
-        // Optionally add logic here to ensure process termination after logging fatal error
-        // Be careful with async operations here if you intend immediate exit.
-        // process.exit(1); // Consider if this is appropriate for your application's shutdown logic
-    }
-}
-// Export singleton instance
-export const logger = Logger.getInstance();
-// Initialize logger on import (can be configured later via setLevel/setMcpNotificationSender)
-// Read initial level from env var or default to 'info'
-const initialLogLevel = process.env.MCP_LOG_LEVEL || 'info';
-logger.initialize(initialLogLevel);