@cyanheads/git-mcp-server 2.1.0 → 2.1.2

package/dist/mcp-server/tools/gitRemote/registration.js

@@ -1,6 +1,6 @@
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService (./utils/internal/requestContext.js)
-import { GitRemoteInputSchema, gitRemoteLogic } from './logic.js';
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService (./utils/internal/requestContext.js)
+import { GitRemoteInputSchema, gitRemoteLogic, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -11,10 +11,10 @@ let _getSessionId;
 export function initializeGitRemoteStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_remote tool registration.');
+    logger.info("State accessors initialized for git_remote tool registration.");
 }
-const TOOL_NAME = 'git_remote';
-const TOOL_DESCRIPTION = 'Manages remote repositories (list, add, remove, show).';
+const TOOL_NAME = "git_remote";
+const TOOL_DESCRIPTION = "Manages remote repositories (list, add, remove, show).";
 /**
  * Registers the git_remote tool with the MCP server.
  *
@@ -24,15 +24,18 @@ const TOOL_DESCRIPTION = 'Manages remote repositories (list, add, remove, show).
  */
 export const registerGitRemoteTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_remote must be initialized before registration.');
+        throw new Error("State accessors for git_remote must be initialized before registration.");
     }
-    const operation = 'registerGitRemoteTool';
+    const operation = "registerGitRemoteTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitRemoteInputSchema.shape, // Provide the Zod schema shape
         async (validatedArgs, callContext) => {
             const toolOperation = `tool:${TOOL_NAME}:${validatedArgs.mode}`; // Include mode in operation
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => {
                 return _getWorkingDirectory(sessionId);
@@ -48,9 +51,9 @@ export const registerGitRemoteTool = async (server) => {
                 const remoteResult = await gitRemoteLogic(validatedArgs, logicContext);
                 // Format the result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(remoteResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 // Log based on the success flag in the result
                 if (remoteResult.success) {

package/dist/mcp-server/tools/gitReset/index.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Barrel file for the gitReset tool.
  */
-export { registerGitResetTool, initializeGitResetStateAccessors } from './registration.js';
+export { registerGitResetTool, initializeGitResetStateAccessors, } from "./registration.js";
 // Export types if needed elsewhere, e.g.:
 // export type { GitResetInput, GitResetResult } from './logic.js';

package/dist/mcp-server/tools/gitReset/logic.js

@@ -1,16 +1,26 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { z } from 'zod';
-import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Direct import for types-global
-import { logger, sanitization } from '../../../utils/index.js'; // logger (./utils/internal/logger.js), RequestContext (./utils/internal/requestContext.js), sanitization (./utils/security/sanitization.js)
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z } from "zod";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Direct import for types-global
+import { logger, sanitization } from "../../../utils/index.js"; // logger (./utils/internal/logger.js), RequestContext (./utils/internal/requestContext.js), sanitization (./utils/security/sanitization.js)
 const execAsync = promisify(exec);
 // Define the reset modes
-const ResetModeEnum = z.enum(['soft', 'mixed', 'hard', 'merge', 'keep']);
+const ResetModeEnum = z.enum(["soft", "mixed", "hard", "merge", "keep"]);
 // Define the input schema for the git_reset tool using Zod
 export const GitResetInputSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: ResetModeEnum.optional().default('mixed').describe("Reset mode: 'soft' (reset HEAD only), 'mixed' (reset HEAD and index, default), 'hard' (reset HEAD, index, and working tree - USE WITH CAUTION), 'merge', 'keep'."),
-    commit: z.string().optional().describe("Commit, branch, or ref to reset to. Defaults to HEAD (useful for unstaging with 'mixed' mode)."),
+    path: z
+        .string()
+        .min(1)
+        .optional()
+        .default(".")
+        .describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
+    mode: ResetModeEnum.optional()
+        .default("mixed")
+        .describe("Reset mode: 'soft' (reset HEAD only), 'mixed' (reset HEAD and index, default), 'hard' (reset HEAD, index, and working tree - USE WITH CAUTION), 'merge', 'keep'."),
+    commit: z
+        .string()
+        .optional()
+        .describe("Commit, branch, or ref to reset to. Defaults to HEAD (useful for unstaging with 'mixed' mode)."),
     // file: z.string().optional().describe("If specified, reset only this file in the index (unstaging). Mode must be 'mixed' or omitted."), // Git reset [<mode>] [<tree-ish>] [--] <paths>… is complex, handle separately if needed
 });
 /**
@@ -22,7 +32,7 @@ export const GitResetInputSchema = z.object({
  * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
  */
 export async function resetGitState(input, context) {
-    const operation = 'resetGitState';
+    const operation = "resetGitState";
     logger.debug(`Executing ${operation}`, { ...context, input });
     // Validate input combinations (e.g., file path usage) if refinement wasn't used
     // if (input.file && input.mode && input.mode !== 'mixed') {
@@ -34,7 +44,7 @@ export async function resetGitState(input, context) {
     let targetPath;
     try {
         // Resolve and sanitize the target path
-        if (input.path && input.path !== '.') {
+        if (input.path && input.path !== ".") {
             targetPath = input.path;
         }
         else {
@@ -44,17 +54,27 @@ export async function resetGitState(input, context) {
             }
             targetPath = workingDir;
         }
-        targetPath = sanitization.sanitizePath(targetPath, { allowAbsolute: true }).sanitizedPath;
-        logger.debug('Sanitized path', { ...context, operation, sanitizedPath: targetPath });
+        targetPath = sanitization.sanitizePath(targetPath, {
+            allowAbsolute: true,
+        }).sanitizedPath;
+        logger.debug("Sanitized path", {
+            ...context,
+            operation,
+            sanitizedPath: targetPath,
+        });
     }
     catch (error) {
-        logger.error('Path resolution or sanitization failed', { ...context, operation, 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 });
     }
     // Basic sanitization for commit ref
-    const safeCommit = input.commit?.replace(/[`$&;*()|<>]/g, '');
+    const safeCommit = input.commit?.replace(/[`$&;*()|<>]/g, "");
     try {
         // Construct the git reset command
         let command = `git -C "${targetPath}" reset`;
@@ -71,42 +91,50 @@ export async function resetGitState(input, context) {
         logger.debug(`Executing command: ${command}`, { ...context, operation });
         // Execute command. Reset output is often minimal on success, but stderr might indicate issues.
         const { stdout, stderr } = await execAsync(command);
-        logger.info(`Git reset stdout: ${stdout}`, { ...context, operation });
+        logger.debug(`Git reset stdout: ${stdout}`, { ...context, operation });
         if (stderr) {
             // Log stderr as info, as it often contains the primary status message
-            logger.info(`Git reset stderr: ${stderr}`, { ...context, operation });
+            logger.debug(`Git reset stderr: ${stderr}`, { ...context, operation });
         }
         // Analyze output (primarily stderr for reset)
-        let message = stderr.trim() || stdout.trim() || `Reset successful (mode: ${input.mode || 'mixed'}).`; // Default success message
-        let changesSummary = undefined;
-        if (stderr.includes('Unstaged changes after reset')) {
-            message = `Reset successful (mode: ${input.mode || 'mixed'}).`;
-            changesSummary = stderr; // Include the list of unstaged changes
-        }
-        else if (stderr.match(/HEAD is now at [a-f0-9]+ /)) {
-            message = stderr.trim(); // Use the direct message from git
-        }
-        else if (!stderr && !stdout) {
-            // If no output, assume success but provide context
-            message = `Reset successful (mode: ${input.mode || 'mixed'}, commit: ${input.commit || 'HEAD'}). No specific output.`;
-        }
-        logger.info(`${operation} completed successfully. ${message}`, { ...context, operation, path: targetPath });
+        const message = stderr.trim() ||
+            stdout.trim() ||
+            `Reset successful (mode: ${input.mode || "mixed"}).`; // Default success message
+        const changesSummary = stderr.includes("Unstaged changes after reset")
+            ? stderr
+            : undefined;
+        logger.info("git reset executed successfully", {
+            ...context,
+            operation,
+            path: targetPath,
+            message,
+            changesSummary,
+        });
         return { success: true, message, changesSummary };
     }
     catch (error) {
-        logger.error(`Failed to execute git reset command`, { ...context, operation, path: targetPath, error: error.message, stderr: error.stderr, stdout: error.stdout });
-        const errorMessage = error.stderr || error.stdout || error.message || '';
+        logger.error(`Failed to execute git reset command`, {
+            ...context,
+            operation,
+            path: targetPath,
+            error: error.message,
+            stderr: error.stderr,
+            stdout: error.stdout,
+        });
+        const errorMessage = error.stderr || error.stdout || error.message || "";
         // Handle specific error cases
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
+        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('fatal: bad revision') || errorMessage.includes('unknown revision')) {
+        if (errorMessage.includes("fatal: bad revision") ||
+            errorMessage.includes("unknown revision")) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Invalid commit reference specified: '${input.commit}'. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('Cannot reset paths') && errorMessage.includes('mode')) {
+        if (errorMessage.includes("Cannot reset paths") &&
+            errorMessage.includes("mode")) {
             throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode ('${input.mode}') used with file paths. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.includes('unmerged paths')) {
+        if (errorMessage.includes("unmerged paths")) {
             throw new McpError(BaseErrorCode.CONFLICT, `Cannot reset due to unmerged files. Please resolve conflicts first. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         // Generic internal error for other failures

package/dist/mcp-server/tools/gitReset/registration.js

@@ -1,6 +1,6 @@
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
-import { GitResetInputSchema, resetGitState } from './logic.js';
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
+import { GitResetInputSchema, resetGitState, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -12,9 +12,9 @@ let _getSessionId;
 export function initializeGitResetStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_reset tool registration.');
+    logger.info("State accessors initialized for git_reset tool registration.");
 }
-const TOOL_NAME = 'git_reset';
+const TOOL_NAME = "git_reset";
 const TOOL_DESCRIPTION = "Resets the current HEAD to a specified state. Supports different modes ('soft', 'mixed', 'hard', 'merge', 'keep') to control how the index and working tree are affected. Can reset to a specific commit. USE 'hard' MODE WITH EXTREME CAUTION as it discards local changes.";
 /**
  * Registers the git_reset tool with the MCP server.
@@ -24,15 +24,18 @@ const TOOL_DESCRIPTION = "Resets the current HEAD to a specified state. Supports
  */
 export async function registerGitResetTool(server) {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_reset must be initialized before registration.');
+        throw new Error("State accessors for git_reset must be initialized before registration.");
     }
-    const operation = 'registerGitResetTool';
+    const operation = "registerGitResetTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitResetInputSchema.shape, // Provide the Zod schema shape
         async (validatedArgs, callContext) => {
-            const toolOperation = 'tool:git_reset';
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const toolOperation = "tool:git_reset";
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => {
                 return _getWorkingDirectory(sessionId);
@@ -48,10 +51,10 @@ export async function registerGitResetTool(server) {
                 const resetResult = await resetGitState(validatedArgs, logicContext);
                 // Format the result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     // Stringify the entire GitResetResult object
                     text: JSON.stringify(resetResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 logger.info(`Tool ${TOOL_NAME} executed successfully: ${resetResult.message}`, logicContext);
                 // Success is determined by the logic function and included in the result object
@@ -66,4 +69,3 @@ export async function registerGitResetTool(server) {
         logger.info(`Tool registered: ${TOOL_NAME}`, context);
     }, { operation, context, critical: true });
 }
-;

package/dist/mcp-server/tools/gitSetWorkingDir/index.js

@@ -2,6 +2,6 @@
  * @fileoverview Barrel file for the git_set_working_dir tool.
  * Exports the registration function and potentially other related components.
  */
-export { registerGitSetWorkingDirTool, initializeGitSetWorkingDirStateAccessors } from './registration.js';
+export { registerGitSetWorkingDirTool, initializeGitSetWorkingDirStateAccessors, } from "./registration.js";
 // Export types if needed elsewhere, e.g.:
 // export type { GitSetWorkingDirInput, GitSetWorkingDirResult } from './logic.js';

package/dist/mcp-server/tools/gitSetWorkingDir/logic.js

@@ -1,15 +1,25 @@
-import { exec } from 'child_process';
-import fs from 'fs/promises';
-import { promisify } from 'util';
-import { z } from 'zod';
-import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Direct import for types-global
-import { logger, sanitization } from '../../../utils/index.js'; // RequestContext (./utils/internal/requestContext.js), logger (./utils/internal/logger.js), sanitization (./utils/security/sanitization.js)
+import { exec } from "child_process";
+import fs from "fs/promises";
+import { promisify } from "util";
+import { z } from "zod";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Direct import for types-global
+import { logger, sanitization } from "../../../utils/index.js"; // RequestContext (./utils/internal/requestContext.js), logger (./utils/internal/logger.js), sanitization (./utils/security/sanitization.js)
 const execAsync = promisify(exec);
 // Define the Zod schema for input validation
 export const GitSetWorkingDirInputSchema = z.object({
-    path: z.string().min(1, "Path cannot be empty.").describe("The absolute path to set as the default working directory for the current session. Set this before using other git_* tools."),
-    validateGitRepo: z.boolean().default(true).describe("Whether to validate that the path is a Git repository"),
-    initializeIfNotPresent: z.boolean().optional().default(false).describe("If true and the directory is not a Git repository, attempt to initialize it with 'git init'.")
+    path: z
+        .string()
+        .min(1, "Path cannot be empty.")
+        .describe("The absolute path to set as the default working directory for the current session. Set this before using other git_* tools."),
+    validateGitRepo: z
+        .boolean()
+        .default(true)
+        .describe("Whether to validate that the path is a Git repository"),
+    initializeIfNotPresent: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("If true and the directory is not a Git repository, attempt to initialize it with 'git init'."),
 });
 /**
  * Logic for the git_set_working_dir tool.
@@ -21,19 +31,20 @@ export const GitSetWorkingDirInputSchema = z.object({
  * @returns {Promise<GitSetWorkingDirResult>} The result of the operation.
  * @throws {McpError} Throws McpError for validation failures or operational errors.
  */
-export async function gitSetWorkingDirLogic(input, context // Assuming context provides session info and setter
-) {
-    const operation = 'gitSetWorkingDirLogic';
-    logger.info('Executing git_set_working_dir logic', { ...context, operation, inputPath: input.path });
+export async function gitSetWorkingDirLogic(input, context) {
+    const operation = "gitSetWorkingDirLogic";
+    logger.debug(`Executing ${operation}`, { ...context, input });
     let sanitizedPath;
     try {
         // Sanitize the path. Must explicitly allow absolute paths for this tool.
         // It normalizes and checks for traversal issues.
-        sanitizedPath = sanitization.sanitizePath(input.path, { allowAbsolute: true }).sanitizedPath;
+        sanitizedPath = sanitization.sanitizePath(input.path, {
+            allowAbsolute: true,
+        }).sanitizedPath;
         logger.debug(`Sanitized path: ${sanitizedPath}`, { ...context, operation });
     }
     catch (error) {
-        logger.error('Path sanitization failed', error, { ...context, operation });
+        logger.error("Path sanitization failed", error, { ...context, operation });
         if (error instanceof McpError)
             throw error;
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path provided: ${error.message}`, { context, operation });
@@ -46,41 +57,60 @@ export async function gitSetWorkingDirLogic(input, context // Assuming context p
         }
     }
     catch (error) {
-        if (error.code === 'ENOENT') {
+        if (error.code === "ENOENT") {
             throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Directory does not exist: ${sanitizedPath}`, { context, operation });
         }
-        logger.error('Failed to stat directory', error, { ...context, operation, path: sanitizedPath });
+        logger.error("Failed to stat directory", error, {
+            ...context,
+            operation,
+            path: sanitizedPath,
+        });
         throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to access path: ${error.message}`, { context, operation });
     }
     let isGitRepo = false;
     let initializedRepo = false;
     try {
-        const { stdout } = await execAsync('git rev-parse --is-inside-work-tree', { cwd: sanitizedPath });
-        if (stdout.trim() === 'true') {
+        const { stdout } = await execAsync("git rev-parse --is-inside-work-tree", {
+            cwd: sanitizedPath,
+        });
+        if (stdout.trim() === "true") {
             isGitRepo = true;
-            logger.debug('Path is already a Git repository', { ...context, operation, path: sanitizedPath });
+            logger.debug("Path is already a Git repository", {
+                ...context,
+                operation,
+                path: sanitizedPath,
+            });
         }
     }
     catch (error) {
-        logger.debug('Path is not a Git repository (rev-parse failed or returned non-true)', { ...context, operation, path: sanitizedPath, error: error.message });
+        logger.debug("Path is not a Git repository (rev-parse failed or returned non-true)", {
+            ...context,
+            operation,
+            path: sanitizedPath,
+            error: error.message,
+        });
         isGitRepo = false;
     }
     if (!isGitRepo && input.initializeIfNotPresent) {
         logger.info(`Path is not a Git repository. Attempting to initialize (initializeIfNotPresent=true) with initial branch 'main'.`, { ...context, operation, path: sanitizedPath });
         try {
-            await execAsync('git init --initial-branch=main', { cwd: sanitizedPath });
+            await execAsync("git init --initial-branch=main", { cwd: sanitizedPath });
             initializedRepo = true;
             isGitRepo = true; // Now it is a git repo
             logger.info('Successfully initialized Git repository with initial branch "main".', { ...context, operation, path: sanitizedPath });
         }
         catch (initError) {
-            logger.error('Failed to initialize Git repository', initError, { ...context, operation, path: sanitizedPath });
+            logger.error("Failed to initialize Git repository", initError, {
+                ...context,
+                operation,
+                path: sanitizedPath,
+            });
             throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize Git repository at ${sanitizedPath}: ${initError.message}`, { context, operation });
         }
     }
     // After potential initialization, if validateGitRepo is true, it must now be a Git repo.
     if (input.validateGitRepo && !isGitRepo) {
-        logger.warning('Path is not a valid Git repository and initialization was not performed or failed.', { ...context, operation, path: sanitizedPath });
+        logger.warning("Path is not a valid Git repository and initialization was not performed or failed.", { ...context, operation, path: sanitizedPath });
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Path is not a valid Git repository: ${sanitizedPath}.`, { context, operation });
     }
     // --- Update Session State ---
@@ -88,25 +118,35 @@ export async function gitSetWorkingDirLogic(input, context // Assuming context p
     // We assume the context provides a way to set the working directory for the current session.
     try {
         context.setWorkingDirectory(sanitizedPath);
-        logger.info(`Working directory set for session ${context.sessionId || 'stdio'} to: ${sanitizedPath}`, { ...context, operation });
+        const message = `Working directory set for session ${context.sessionId || "stdio"} to: ${sanitizedPath}`;
+        logger.info(message, { ...context, operation });
     }
     catch (error) {
-        logger.error('Failed to set working directory in session state', error, { ...context, operation });
+        logger.error("Failed to set working directory in session state", error, {
+            ...context,
+            operation,
+        });
         // This indicates an internal logic error in how state is passed/managed.
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, 'Failed to update session state.', { context, operation });
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, "Failed to update session state.", { context, operation });
     }
     let message = `Working directory set to: ${sanitizedPath}`;
     if (initializedRepo) {
-        message += ' (New Git repository initialized).';
+        message += " (New Git repository initialized).";
     }
-    else if (isGitRepo && input.validateGitRepo) { // Only state "Existing" if validation was on and it passed
-        message += ' (Existing Git repository).';
+    else if (isGitRepo && input.validateGitRepo) {
+        // Only state "Existing" if validation was on and it passed
+        message += " (Existing Git repository).";
     }
-    else if (isGitRepo && !input.validateGitRepo) { // It is a git repo, but we weren't asked to validate it
-        message += ' (Is a Git repository, validation skipped).';
+    else if (isGitRepo && !input.validateGitRepo) {
+        // It is a git repo, but we weren't asked to validate it
+        message += " (Is a Git repository, validation skipped).";
     }
-    else if (!isGitRepo && !input.validateGitRepo && !input.initializeIfNotPresent) { // Not a git repo, validation off, no init request
-        message += ' (Not a Git repository, validation skipped, no initialization requested).';
+    else if (!isGitRepo &&
+        !input.validateGitRepo &&
+        !input.initializeIfNotPresent) {
+        // Not a git repo, validation off, no init request
+        message +=
+            " (Not a Git repository, validation skipped, no initialization requested).";
     }
     return {
         success: true,

package/dist/mcp-server/tools/gitSetWorkingDir/registration.js

@@ -1,6 +1,6 @@
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Direct import for types-global
-import { ErrorHandler, logger, requestContextService } from '../../../utils/index.js'; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
-import { GitSetWorkingDirInputSchema, gitSetWorkingDirLogic } from './logic.js';
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Direct import for types-global
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js"; // ErrorHandler (./utils/internal/errorHandler.js), logger (./utils/internal/logger.js), requestContextService & RequestContext (./utils/internal/requestContext.js)
+import { GitSetWorkingDirInputSchema, gitSetWorkingDirLogic, } from "./logic.js";
 let _getWorkingDirectory; // Added getter
 let _setWorkingDirectory;
 let _getSessionId;
@@ -16,9 +16,9 @@ setWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn; // Store getter
     _setWorkingDirectory = setWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_set_working_dir tool registration.');
+    logger.info("State accessors initialized for git_set_working_dir tool registration.");
 }
-const TOOL_NAME = 'git_set_working_dir';
+const TOOL_NAME = "git_set_working_dir";
 const TOOL_DESCRIPTION = "Sets the default working directory for the current session. Subsequent Git tool calls within this session can use '.' for the `path` parameter, which will resolve to this directory. Optionally validates if the path is a Git repository (`validateGitRepo: true`). Can optionally initialize a Git repository with 'git init' if it's not already one and `initializeIfNotPresent: true` is set. Returns the result as a JSON object. IMPORTANT: The provided path must be absolute.";
 /**
  * Registers the git_set_working_dir tool with the MCP server.
@@ -29,14 +29,18 @@ const TOOL_DESCRIPTION = "Sets the default working directory for the current ses
 export async function registerGitSetWorkingDirTool(server) {
     // Check all required accessors
     if (!_getWorkingDirectory || !_setWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors (getWD, setWD, getSID) for git_set_working_dir must be initialized before registration.');
+        throw new Error("State accessors (getWD, setWD, getSID) for git_set_working_dir must be initialized before registration.");
     }
     try {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitSetWorkingDirInputSchema.shape, // Pass the shape for SDK validation
         async (validatedArgs, callContext) => {
-            const operation = 'tool:git_set_working_dir';
+            // Use callContext provided by SDK
+            const operation = "tool:git_set_working_dir";
             // Create a request context, potentially inheriting from callContext if it provides relevant info
-            const requestContext = requestContextService.createRequestContext({ operation, parentContext: callContext });
+            const requestContext = requestContextService.createRequestContext({
+                operation,
+                parentContext: callContext,
+            });
             // Get session ID using the accessor function
             const sessionId = _getSessionId(requestContext); // Non-null assertion as we checked initialization
             // Define the session-specific setter function
@@ -60,11 +64,14 @@ export async function registerGitSetWorkingDirTool(server) {
                 const result = await gitSetWorkingDirLogic(validatedArgs, logicContext);
                 // Format the successful result for the MCP client
                 const responseContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(result, null, 2), // Pretty-print JSON result
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
-                logger.info(`Tool ${TOOL_NAME} executed successfully`, { ...logicContext, result });
+                logger.info(`Tool ${TOOL_NAME} executed successfully`, {
+                    ...logicContext,
+                    result,
+                });
                 return { content: [responseContent] };
             }, {
                 operation,

package/dist/mcp-server/tools/gitShow/index.js

@@ -2,6 +2,6 @@
  * @fileoverview Barrel file for the git_show tool.
  * Exports the registration function and state accessor initialization function.
  */
-export { registerGitShowTool, initializeGitShowStateAccessors } from './registration.js';
+export { registerGitShowTool, initializeGitShowStateAccessors, } from "./registration.js";
 // Export types if needed elsewhere, e.g.:
 // export type { GitShowInput, GitShowResult } from './logic.js';