@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,8 +1,8 @@
-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 { 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 the final schema and types for handler logic
 // Import the BASE schema separately for registration shape
-import { GitTagBaseSchema, gitTagLogic } from './logic.js';
+import { GitTagBaseSchema, gitTagLogic, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -13,10 +13,10 @@ let _getSessionId;
 export function initializeGitTagStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_tag tool registration.');
+    logger.info("State accessors initialized for git_tag tool registration.");
 }
-const TOOL_NAME = 'git_tag';
-const TOOL_DESCRIPTION = 'Manages Git tags. Supports listing existing tags, creating new lightweight or annotated tags against specific commits, and deleting local tags. Returns results as a JSON object.';
+const TOOL_NAME = "git_tag";
+const TOOL_DESCRIPTION = "Manages Git tags. Supports listing existing tags, creating new lightweight or annotated tags against specific commits, and deleting local tags. Returns results as a JSON object.";
 /**
  * Registers the git_tag tool with the MCP server.
  *
@@ -26,9 +26,9 @@ const TOOL_DESCRIPTION = 'Manages Git tags. Supports listing existing tags, crea
  */
 export const registerGitTagTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_tag must be initialized before registration.');
+        throw new Error("State accessors for git_tag must be initialized before registration.");
     }
-    const operation = 'registerGitTagTool';
+    const operation = "registerGitTagTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         // Register the tool using the *base* schema's shape for definition
@@ -40,7 +40,10 @@ export const registerGitTagTool = async (server) => {
             // Cast validatedArgs to the specific input type for use within the handler
             const toolInput = validatedArgs;
             const toolOperation = `tool:${TOOL_NAME}:${toolInput.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);
@@ -56,9 +59,9 @@ export const registerGitTagTool = async (server) => {
                 const tagResult = await gitTagLogic(toolInput, logicContext);
                 // Format the result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(tagResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 // Log based on the success flag in the result
                 if (tagResult.success) {

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

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

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

@@ -1,71 +1,115 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { z } from 'zod';
-import { logger, sanitization } from '../../../utils/index.js';
-import { BaseErrorCode, McpError } from '../../../types-global/errors.js';
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z } from "zod";
+import { logger, sanitization } from "../../../utils/index.js";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 const execAsync = promisify(exec);
 // Define the BASE input schema for the git_worktree tool using Zod
 export const GitWorktreeBaseSchema = z.object({
-    path: z.string().min(1).optional().default('.').describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    mode: z.enum(['list', 'add', 'remove', 'move', 'prune']).describe("The worktree operation to perform: 'list', 'add', 'remove', 'move', 'prune'."),
+    path: z
+        .string()
+        .min(1)
+        .optional()
+        .default(".")
+        .describe("Path to the local Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
+    mode: z
+        .enum(["list", "add", "remove", "move", "prune"])
+        .describe("The worktree operation to perform: 'list', 'add', 'remove', 'move', 'prune'."),
     // Common optional path for operations
-    worktreePath: z.string().min(1).optional().describe("Path of the worktree. Required for 'add', 'remove', 'move' modes."),
+    worktreePath: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Path of the worktree. Required for 'add', 'remove', 'move' modes."),
     // 'add' mode specific
-    commitish: z.string().min(1).optional().describe("Branch or commit to checkout in the new worktree. Used only in 'add' mode. Defaults to HEAD."),
-    newBranch: z.string().min(1).optional().describe("Create a new branch in the worktree. Used only in 'add' mode."),
-    force: z.boolean().default(false).describe("Force the operation (e.g., for 'add' if branch exists, or 'remove' if uncommitted changes)."),
-    detach: z.boolean().default(false).describe("Detach HEAD in the new worktree. Used only in 'add' mode."),
+    commitish: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Branch or commit to checkout in the new worktree. Used only in 'add' mode. Defaults to HEAD."),
+    newBranch: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Create a new branch in the worktree. Used only in 'add' mode."),
+    force: z
+        .boolean()
+        .default(false)
+        .describe("Force the operation (e.g., for 'add' if branch exists, or 'remove' if uncommitted changes)."),
+    detach: z
+        .boolean()
+        .default(false)
+        .describe("Detach HEAD in the new worktree. Used only in 'add' mode."),
     // 'move' mode specific
-    newPath: z.string().min(1).optional().describe("The new path for the worktree. Required for 'move' mode."),
+    newPath: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("The new path for the worktree. Required for 'move' mode."),
     // 'prune' mode specific
-    verbose: z.boolean().default(false).describe("Provide more detailed output. Used in 'list' and 'prune' modes."),
-    dryRun: z.boolean().default(false).describe("Show what would be done without actually doing it. Used in 'prune' mode."),
-    expire: z.string().min(1).optional().describe("Prune entries older than this time (e.g., '1.month.ago'). Used in 'prune' mode."),
+    verbose: z
+        .boolean()
+        .default(false)
+        .describe("Provide more detailed output. Used in 'list' and 'prune' modes."),
+    dryRun: z
+        .boolean()
+        .default(false)
+        .describe("Show what would be done without actually doing it. Used in 'prune' mode."),
+    expire: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Prune entries older than this time (e.g., '1.month.ago'). Used in 'prune' mode."),
 });
 // Apply refinements and export the FINAL schema
-export const GitWorktreeInputSchema = GitWorktreeBaseSchema.refine(data => !(data.mode === 'add' && !data.worktreePath), {
-    message: "A 'worktreePath' is required for 'add' mode.", path: ["worktreePath"],
-}).refine(data => !(data.mode === 'remove' && !data.worktreePath), {
-    message: "A 'worktreePath' is required for 'remove' mode.", path: ["worktreePath"],
-}).refine(data => !(data.mode === 'move' && (!data.worktreePath || !data.newPath)), {
-    message: "Both 'worktreePath' (old path) and 'newPath' are required for 'move' mode.", path: ["worktreePath", "newPath"],
+export const GitWorktreeInputSchema = GitWorktreeBaseSchema.refine((data) => !(data.mode === "add" && !data.worktreePath), {
+    message: "A 'worktreePath' is required for 'add' mode.",
+    path: ["worktreePath"],
+})
+    .refine((data) => !(data.mode === "remove" && !data.worktreePath), {
+    message: "A 'worktreePath' is required for 'remove' mode.",
+    path: ["worktreePath"],
+})
+    .refine((data) => !(data.mode === "move" && (!data.worktreePath || !data.newPath)), {
+    message: "Both 'worktreePath' (old path) and 'newPath' are required for 'move' mode.",
+    path: ["worktreePath", "newPath"],
 });
 /**
  * Parses the output of `git worktree list --porcelain`.
  */
 function parsePorcelainWorktreeList(stdout) {
     const worktrees = [];
-    const entries = stdout.trim().split('\n\n'); // Entries are separated by double newlines
+    const entries = stdout.trim().split("\n\n"); // Entries are separated by double newlines
     for (const entry of entries) {
-        const lines = entry.trim().split('\n');
-        let path = '';
-        let head = '';
+        const lines = entry.trim().split("\n");
+        let path = "";
+        let head = "";
         let branch;
         let isBare = false;
         let isLocked = false;
         let isPrunable = false;
         let prunableReason;
         for (const line of lines) {
-            if (line.startsWith('worktree ')) {
-                path = line.substring('worktree '.length);
+            if (line.startsWith("worktree ")) {
+                path = line.substring("worktree ".length);
             }
-            else if (line.startsWith('HEAD ')) {
-                head = line.substring('HEAD '.length);
+            else if (line.startsWith("HEAD ")) {
+                head = line.substring("HEAD ".length);
             }
-            else if (line.startsWith('branch ')) {
-                branch = line.substring('branch '.length);
+            else if (line.startsWith("branch ")) {
+                branch = line.substring("branch ".length);
             }
-            else if (line.startsWith('bare')) {
+            else if (line.startsWith("bare")) {
                 isBare = true;
             }
-            else if (line.startsWith('locked')) {
+            else if (line.startsWith("locked")) {
                 isLocked = true;
                 const reasonMatch = line.match(/locked(?: (.+))?/);
                 if (reasonMatch && reasonMatch[1]) {
                     prunableReason = reasonMatch[1]; // Using prunableReason for lock reason too
                 }
             }
-            else if (line.startsWith('prunable')) {
+            else if (line.startsWith("prunable")) {
                 isPrunable = true;
                 const reasonMatch = line.match(/prunable(?: (.+))?/);
                 if (reasonMatch && reasonMatch[1]) {
@@ -73,8 +117,17 @@ function parsePorcelainWorktreeList(stdout) {
                 }
             }
         }
-        if (path) { // Only add if a path was found
-            worktrees.push({ path, head, branch, isBare, isLocked, isPrunable, prunableReason });
+        if (path) {
+            // Only add if a path was found
+            worktrees.push({
+                path,
+                head,
+                branch,
+                isBare,
+                isLocked,
+                isPrunable,
+                prunableReason,
+            });
         }
     }
     return worktrees;
@@ -88,24 +141,36 @@ export async function gitWorktreeLogic(input, context) {
     let targetPath;
     try {
         const workingDir = context.getWorkingDirectory();
-        targetPath = (input.path && input.path !== '.')
-            ? input.path
-            : workingDir ?? '.';
-        if (targetPath === '.' && !workingDir) {
+        targetPath =
+            input.path && input.path !== "." ? input.path : (workingDir ?? ".");
+        if (targetPath === "." && !workingDir) {
             logger.warning("Executing git worktree in server's CWD as no path provided and no session WD set.", { ...context, operation });
             targetPath = process.cwd();
         }
-        else if (targetPath === '.' && workingDir) {
+        else if (targetPath === "." && workingDir) {
             targetPath = workingDir;
-            logger.debug(`Using session working directory: ${targetPath}`, { ...context, operation, sessionId: context.sessionId });
+            logger.debug(`Using session working directory: ${targetPath}`, {
+                ...context,
+                operation,
+                sessionId: context.sessionId,
+            });
         }
         else {
-            logger.debug(`Using provided path: ${targetPath}`, { ...context, operation });
+            logger.debug(`Using provided path: ${targetPath}`, {
+                ...context,
+                operation,
+            });
         }
-        targetPath = sanitization.sanitizePath(targetPath, { allowAbsolute: true }).sanitizedPath;
+        targetPath = sanitization.sanitizePath(targetPath, {
+            allowAbsolute: true,
+        }).sanitizedPath;
     }
     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 });
@@ -114,91 +179,126 @@ export async function gitWorktreeLogic(input, context) {
         let command = `git -C "${targetPath}" worktree `;
         let result;
         switch (input.mode) {
-            case 'list':
-                command += 'list';
+            case "list":
+                command += "list";
                 if (input.verbose)
-                    command += ' --porcelain'; // Use porcelain for structured output
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                    command += " --porcelain"; // Use porcelain for structured output
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: listStdout } = await execAsync(command);
                 if (input.verbose) {
                     const worktrees = parsePorcelainWorktreeList(listStdout);
-                    result = { success: true, mode: 'list', worktrees };
+                    result = { success: true, mode: "list", worktrees };
                 }
                 else {
                     // Simple list output parsing (less structured)
-                    const worktrees = listStdout.trim().split('\n').map(line => {
+                    const worktrees = listStdout
+                        .trim()
+                        .split("\n")
+                        .map((line) => {
                         const parts = line.split(/\s+/);
                         return {
                             path: parts[0],
                             head: parts[1],
-                            branch: parts[2]?.replace(/[\[\]]/g, ''), // Remove brackets from branch name
+                            branch: parts[2]?.replace(/[\[\]]/g, ""), // Remove brackets from branch name
                             isBare: false, // Cannot determine from simple list
                             isLocked: false, // Cannot determine
-                            isPrunable: false // Cannot determine
+                            isPrunable: false, // Cannot determine
                         };
                     });
-                    result = { success: true, mode: 'list', worktrees };
+                    result = { success: true, mode: "list", worktrees };
                 }
                 break;
-            case 'add':
+            case "add":
                 // worktreePath is guaranteed by refine
                 const sanitizedWorktreePathAdd = sanitization.sanitizePath(input.worktreePath, { allowAbsolute: true, rootDir: targetPath }).sanitizedPath;
                 command += `add `;
                 if (input.force)
-                    command += '--force ';
+                    command += "--force ";
                 if (input.detach)
-                    command += '--detach ';
+                    command += "--detach ";
                 if (input.newBranch)
                     command += `-b "${input.newBranch}" `;
                 command += `"${sanitizedWorktreePathAdd}"`;
                 if (input.commitish)
                     command += ` "${input.commitish}"`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 await execAsync(command);
                 // To get the HEAD of the new worktree, we might need another command or parse output if available
                 // For simplicity, we'll report success. A more robust solution might `git -C new_worktree_path rev-parse HEAD`
                 result = {
                     success: true,
-                    mode: 'add',
+                    mode: "add",
                     worktreePath: sanitizedWorktreePathAdd,
                     branch: input.newBranch,
-                    head: 'HEAD', // Placeholder, actual SHA would require another call
-                    message: `Worktree '${sanitizedWorktreePathAdd}' added successfully.`
+                    head: "HEAD", // Placeholder, actual SHA would require another call
+                    message: `Worktree '${sanitizedWorktreePathAdd}' added successfully.`,
                 };
                 break;
-            case 'remove':
+            case "remove":
                 // worktreePath is guaranteed by refine
                 const sanitizedWorktreePathRemove = sanitization.sanitizePath(input.worktreePath, { allowAbsolute: true, rootDir: targetPath }).sanitizedPath;
                 command += `remove `;
                 if (input.force)
-                    command += '--force ';
+                    command += "--force ";
                 command += `"${sanitizedWorktreePathRemove}"`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: removeStdout } = await execAsync(command);
-                result = { success: true, mode: 'remove', worktreePath: sanitizedWorktreePathRemove, message: removeStdout.trim() || `Worktree '${sanitizedWorktreePathRemove}' removed successfully.` };
+                result = {
+                    success: true,
+                    mode: "remove",
+                    worktreePath: sanitizedWorktreePathRemove,
+                    message: removeStdout.trim() ||
+                        `Worktree '${sanitizedWorktreePathRemove}' removed successfully.`,
+                };
                 break;
-            case 'move':
+            case "move":
                 // worktreePath and newPath are guaranteed by refine
                 const sanitizedOldPathMove = sanitization.sanitizePath(input.worktreePath, { allowAbsolute: true, rootDir: targetPath }).sanitizedPath;
-                const sanitizedNewPathMove = sanitization.sanitizePath(input.newPath, { allowAbsolute: true, rootDir: targetPath }).sanitizedPath;
+                const sanitizedNewPathMove = sanitization.sanitizePath(input.newPath, {
+                    allowAbsolute: true,
+                    rootDir: targetPath,
+                }).sanitizedPath;
                 command += `move "${sanitizedOldPathMove}" "${sanitizedNewPathMove}"`;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 await execAsync(command);
-                result = { success: true, mode: 'move', oldPath: sanitizedOldPathMove, newPath: sanitizedNewPathMove, message: `Worktree moved from '${sanitizedOldPathMove}' to '${sanitizedNewPathMove}' successfully.` };
+                result = {
+                    success: true,
+                    mode: "move",
+                    oldPath: sanitizedOldPathMove,
+                    newPath: sanitizedNewPathMove,
+                    message: `Worktree moved from '${sanitizedOldPathMove}' to '${sanitizedNewPathMove}' successfully.`,
+                };
                 break;
-            case 'prune':
-                command += 'prune ';
+            case "prune":
+                command += "prune ";
                 if (input.dryRun)
-                    command += '--dry-run ';
+                    command += "--dry-run ";
                 if (input.verbose)
-                    command += '--verbose ';
+                    command += "--verbose ";
                 if (input.expire)
                     command += `--expire "${input.expire}" `;
-                logger.debug(`Executing command: ${command}`, { ...context, operation });
+                logger.debug(`Executing command: ${command}`, {
+                    ...context,
+                    operation,
+                });
                 const { stdout: pruneStdout, stderr: pruneStderr } = await execAsync(command);
                 // Prune often outputs to stderr even on success for verbose/dry-run
-                const pruneMessage = (pruneStdout.trim() || pruneStderr.trim()) || 'Worktree prune operation completed.';
-                result = { success: true, mode: 'prune', message: pruneMessage };
+                const pruneMessage = pruneStdout.trim() ||
+                    pruneStderr.trim() ||
+                    "Worktree prune operation completed.";
+                result = { success: true, mode: "prune", message: pruneMessage };
                 if (input.verbose && pruneStdout.trim()) {
                     // Attempt to parse verbose output if needed, for now just return raw message
                     // result.prunedItems = ...
@@ -207,33 +307,42 @@ export async function gitWorktreeLogic(input, context) {
             default:
                 throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
         }
-        logger.info(`${operation} executed successfully`, { ...context, path: targetPath });
+        logger.info(`git worktree ${input.mode} executed successfully`, {
+            ...context,
+            operation,
+            path: targetPath,
+            result,
+        });
         return result;
     }
     catch (error) {
-        const errorMessage = error.stderr || error.stdout || (error.message || '');
-        logger.error(`Failed to execute git worktree command`, { ...context, path: targetPath, error: errorMessage, stderr: error.stderr, stdout: error.stdout });
-        if (errorMessage.toLowerCase().includes('not a git repository')) {
+        const errorMessage = error.stderr || error.stdout || error.message || "";
+        logger.error(`Failed to execute git worktree command`, {
+            ...context,
+            path: targetPath,
+            error: errorMessage,
+            stderr: error.stderr,
+            stdout: error.stdout,
+        });
+        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 });
         }
         // Add more specific error handling based on `git worktree` messages
-        if (input.mode === 'add' && errorMessage.includes('already exists')) {
-            return { success: false, mode: 'add', message: `Failed to add worktree: Path '${input.worktreePath}' already exists or is a worktree.`, error: errorMessage };
+        if (input.mode === "add" && errorMessage.includes("already exists")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to add worktree: Path '${input.worktreePath}' already exists or is a worktree. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (input.mode === 'add' && errorMessage.includes('is a submodule')) {
-            return { success: false, mode: 'add', message: `Failed to add worktree: Path '${input.worktreePath}' is a submodule.`, error: errorMessage };
+        if (input.mode === "add" && errorMessage.includes("is a submodule")) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to add worktree: Path '${input.worktreePath}' is a submodule. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (input.mode === 'remove' && errorMessage.includes('cannot remove the current worktree')) {
-            return { success: false, mode: 'remove', message: `Failed to remove worktree: Cannot remove the current worktree.`, error: errorMessage };
+        if (input.mode === "remove" &&
+            errorMessage.includes("cannot remove the current worktree")) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Failed to remove worktree: Cannot remove the current worktree. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (input.mode === 'remove' && errorMessage.includes('has unclean changes')) {
-            return { success: false, mode: 'remove', message: `Failed to remove worktree: '${input.worktreePath}' has uncommitted changes. Use force=true to remove.`, error: errorMessage };
+        if (input.mode === "remove" &&
+            errorMessage.includes("has unclean changes")) {
+            throw new McpError(BaseErrorCode.CONFLICT, `Failed to remove worktree: '${input.worktreePath}' has uncommitted changes. Use force=true to remove. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        return {
-            success: false,
-            mode: input.mode,
-            message: `Git worktree ${input.mode} failed for path: ${targetPath}.`,
-            error: errorMessage
-        };
+        // Throw a generic McpError for other failures
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git worktree ${input.mode} failed for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
     }
 }

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

@@ -1,6 +1,6 @@
-import { logger, ErrorHandler, requestContextService } from '../../../utils/index.js';
-import { BaseErrorCode } from '../../../types-global/errors.js';
-import { GitWorktreeBaseSchema, gitWorktreeLogic } from './logic.js';
+import { logger, ErrorHandler, requestContextService, } from "../../../utils/index.js";
+import { BaseErrorCode } from "../../../types-global/errors.js";
+import { GitWorktreeBaseSchema, gitWorktreeLogic, } from "./logic.js";
 let _getWorkingDirectory;
 let _getSessionId;
 /**
@@ -11,10 +11,10 @@ let _getSessionId;
 export function initializeGitWorktreeStateAccessors(getWdFn, getSidFn) {
     _getWorkingDirectory = getWdFn;
     _getSessionId = getSidFn;
-    logger.info('State accessors initialized for git_worktree tool registration.');
+    logger.info("State accessors initialized for git_worktree tool registration.");
 }
-const TOOL_NAME = 'git_worktree';
-const TOOL_DESCRIPTION = 'Manages Git worktrees. Supports listing, adding, removing, moving, and pruning worktrees. Returns results as a JSON object.';
+const TOOL_NAME = "git_worktree";
+const TOOL_DESCRIPTION = "Manages Git worktrees. Supports listing, adding, removing, moving, and pruning worktrees. Returns results as a JSON object.";
 /**
  * Registers the git_worktree tool with the MCP server.
  *
@@ -24,15 +24,18 @@ const TOOL_DESCRIPTION = 'Manages Git worktrees. Supports listing, adding, remov
  */
 export const registerGitWorktreeTool = async (server) => {
     if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error('State accessors for git_worktree must be initialized before registration.');
+        throw new Error("State accessors for git_worktree must be initialized before registration.");
     }
-    const operation = 'registerGitWorktreeTool';
+    const operation = "registerGitWorktreeTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitWorktreeBaseSchema.shape, async (validatedArgs, callContext) => {
             const toolInput = validatedArgs; // Cast for use
             const toolOperation = `tool:${TOOL_NAME}:${toolInput.mode}`;
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             const sessionId = _getSessionId(requestContext);
             const getWorkingDirectoryForSession = () => _getWorkingDirectory(sessionId);
             const logicContext = {
@@ -44,9 +47,9 @@ export const registerGitWorktreeTool = async (server) => {
             return await ErrorHandler.tryCatch(async () => {
                 const worktreeResult = await gitWorktreeLogic(toolInput, logicContext);
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(worktreeResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 if (worktreeResult.success) {
                     logger.info(`Tool ${TOOL_NAME} (mode: ${toolInput.mode}) executed successfully, returning JSON`, logicContext);

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

@@ -1,3 +1,3 @@
-export { registerGitWrapupInstructionsTool, initializeGitWrapupInstructionsStateAccessors } from './registration.js';
+export { registerGitWrapupInstructionsTool, initializeGitWrapupInstructionsStateAccessors, } from "./registration.js";
 // This tool now requires session-specific state accessors (getWorkingDirectory, getSessionId)
 // to fetch git status, so initializeGitWrapupInstructionsStateAccessors is exported for server setup.