@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,76 +1,64 @@
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { requestContextService } from "../../../utils/index.js";
-import { GitLogInputSchema, logGitHistory, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the tool registration.
- * This should be called once during server setup.
- * @param getWdFn - Function to get the working directory for a session.
- * @param getSidFn - Function to get the session ID from context.
+ * @fileoverview Handles registration and error handling for the git_log tool.
+ * @module src/mcp-server/tools/gitLog/registration
  */
-export function initializeGitLogStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_log tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { logGitHistory, GitLogInputSchema, GitLogOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_log";
-const TOOL_DESCRIPTION = "Shows commit logs for the repository. Supports limiting count, filtering by author, date range, and specific branch/file. Returns a JSON object containing a list of commit objects (`commits` array) by default. If `showSignature: true` is used, it returns a JSON object where the `commits` array is empty and the raw signature verification output is included in the `message` field.";
+const TOOL_DESCRIPTION = "Shows commit logs for the repository. Supports limiting count, filtering by author, date range, and specific branch/file. Returns a JSON object containing a list of commit objects (`commits` array) by default. If `showSignature: true` is used, it returns a JSON object where the `commits` array is empty and the raw signature verification output is included in the `rawOutput` field.";
 /**
- * Registers the git_log tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_log tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param getWorkingDirectory Function to get the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export async function registerGitLogTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_log must be initialized before registration.");
-    }
+export const registerGitLogTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitLogTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitLogInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_log";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Log",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitLogInputSchema.shape,
+        outputSchema: GitLogOutputSchema.shape,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await logGitHistory(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function
-                const logResult = await logGitHistory(validatedArgs, logicContext);
-                // Format the result (array of commits) as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Stringify the entire GitLogResult object which includes the commits array and success flag
-                    text: JSON.stringify(logResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
-                // Success is determined by the logic function and included in the result object
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error in logic
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
-}
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
+};

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

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_merge tool.
- * Exports the registration function and state accessor initialization function.
+ * @fileoverview Barrel file for the gitMerge tool.
+ * @module src/mcp-server/tools/gitMerge/index
  */
-export { registerGitMergeTool, initializeGitMergeStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitMergeInput, GitMergeResult } from './logic.js';
+export { registerGitMergeTool } from "./registration.js";

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

@@ -1,209 +1,63 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_merge tool.
+ * @module src/mcp-server/tools/gitMerge/logic
+ */
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
-// Import utils from barrel (sanitization from ../utils/security/sanitization.js)
-import path from "path"; // Import path module
-import { sanitization } from "../../../utils/index.js";
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_merge tool
+// 1. DEFINE the Zod input schema.
 export const GitMergeInputSchema = 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."),
-    branch: z
-        .string()
-        .min(1)
-        .describe("The name of the branch to merge into the current branch."),
-    commitMessage: z
-        .string()
-        .optional()
-        .describe("Commit message to use for the merge commit (if required, e.g., not fast-forward)."),
-    noFf: z
-        .boolean()
-        .default(false)
-        .describe("Create a merge commit even when the merge resolves as a fast-forward (`--no-ff`)."),
-    squash: z
-        .boolean()
-        .default(false)
-        .describe("Combine merged changes into a single commit (`--squash`). Requires manual commit afterwards."),
-    abort: z
-        .boolean()
-        .default(false)
-        .describe("Abort the current merge process (resolves conflicts)."),
-    // 'continue' might be too complex for initial implementation due to requiring index manipulation
+    path: z.string().default(".").describe("Path to the Git repository."),
+    branch: z.string().min(1).describe("The name of the branch to merge into the current branch."),
+    commitMessage: z.string().optional().describe("Commit message for the merge commit."),
+    noFf: z.boolean().default(false).describe("Create a merge commit even if a fast-forward is possible."),
+    squash: z.boolean().default(false).describe("Combine merged changes into a single commit (requires manual commit)."),
+    abort: z.boolean().default(false).describe("Abort the current merge process."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitMergeOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    conflict: z.boolean().optional().describe("True if the merge resulted in conflicts."),
+    fastForward: z.boolean().optional().describe("True if the merge was a fast-forward."),
+    aborted: z.boolean().optional().describe("True if the merge was aborted."),
+    needsManualCommit: z.boolean().optional().describe("True if --squash was used."),
 });
 /**
- * Executes the 'git merge' command.
- *
- * @param {GitMergeInput} input - The validated input object.
- * @param {RequestContext} context - The request context.
- * @returns {Promise<GitMergeResult>} A promise that resolves with the structured merge result.
- * @throws {McpError} Throws an McpError for path issues, command failures, or unexpected errors.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitMergeLogic(input, context) {
+export async function gitMergeLogic(params, context) {
     const operation = "gitMergeLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve the target path
-        let resolvedPath;
-        if (input.path && input.path !== ".") {
-            // If a specific path is given, resolve it absolutely first
-            // Assuming input.path could be relative *to the server's CWD* if no session WD is set,
-            // but it's safer to require absolute paths or rely on session WD.
-            // For simplicity, let's assume input.path is intended relative to session WD if set, or absolute otherwise.
-            const workingDir = context.getWorkingDirectory();
-            if (workingDir) {
-                resolvedPath = path.resolve(workingDir, input.path); // Resolve relative to session WD
-            }
-            else if (path.isAbsolute(input.path)) {
-                resolvedPath = input.path; // Use absolute path directly
-            }
-            else {
-                // If relative path given without session WD, it's ambiguous. Error out.
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Relative path provided but no working directory set for the session.", { context, operation });
-            }
-            logger.debug(`Resolved provided path: ${resolvedPath}`, {
-                ...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 });
-            }
-            resolvedPath = workingDir; // Use session working directory
-            logger.debug(`Using session working directory: ${resolvedPath}`, {
-                ...context,
-                operation,
-                sessionId: context.sessionId,
-            });
-        }
-        // Sanitize the resolved path
-        // We assume the resolved path should be absolute for git commands.
-        // sanitizePath checks for traversal and normalizes.
-        targetPath = sanitization.sanitizePath(resolvedPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug(`Sanitized path: ${targetPath}`, { ...context, operation });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
-    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 });
-    }
-    // --- Construct the git merge command ---
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
     const args = ["-C", targetPath, "merge"];
-    if (input.abort) {
+    if (params.abort) {
         args.push("--abort");
     }
     else {
-        // Standard merge options
-        if (input.noFf) {
+        if (params.noFf)
             args.push("--no-ff");
-        }
-        if (input.squash) {
+        if (params.squash)
             args.push("--squash");
-        }
-        if (input.commitMessage && !input.squash) {
-            // Commit message only relevant if not squashing (squash requires separate commit)
-            args.push("-m", input.commitMessage);
-        }
-        else if (input.squash && input.commitMessage) {
-            logger.warning("Commit message provided with --squash, but it will be ignored. Squash requires a separate commit.", { ...context, operation });
-        }
-        args.push(input.branch); // Add branch to merge
-    }
-    logger.debug(`Executing command: git ${args.join(" ")}`, {
-        ...context,
-        operation,
-    });
-    // --- Execute and Parse ---
-    try {
-        const { stdout, stderr } = await execFileAsync("git", args);
-        logger.debug(`Command stdout: ${stdout}`, { ...context, operation });
-        if (stderr)
-            logger.debug(`Command stderr: ${stderr}`, { ...context, operation }); // Log stderr even on success
-        const result = {
-            success: true,
-            message: stdout.trim() || stderr.trim() || "Merge command executed.",
-        };
-        if (input.abort) {
-            result.aborted = true;
-            result.message = "Merge aborted successfully.";
-        }
-        else if (stdout.includes("Fast-forward")) {
-            result.fastForward = true;
-        }
-        else if (stdout.includes("Merge made by") || stdout.includes("merging")) {
-            const match = stdout.match(/Merge commit '([a-f0-9]+)'/);
-            result.mergedCommitHash = match ? match[1] : undefined;
-            result.fastForward = false;
-        }
-        else if (stdout.includes("Squash commit -- not updating HEAD")) {
-            result.needsManualCommit = true;
-        }
-        else if (stdout.includes("Already up to date")) {
-            result.fastForward = true;
-        }
-        logger.info("git merge executed successfully", {
-            ...context,
-            operation,
-            path: targetPath,
-            result,
-        });
-        return result;
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.stdout || error.message || ""; // Git often puts errors in stdout/stderr
-        logger.error(`Git merge command failed`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: error.message,
-            output: errorMessage,
-        });
-        if (input.abort) {
-            // If abort failed, it's likely there was no merge in progress
-            if (errorMessage.includes("fatal: There is no merge to abort")) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `No merge in progress to abort.`, { context, operation, originalError: error });
-            }
-            throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to abort merge: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        // Check for specific failure scenarios
-        if (errorMessage.includes("CONFLICT")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Merge failed due to conflicts. Please resolve conflicts and commit. Output: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("refusing to merge unrelated histories")) {
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Merge failed: Refusing to merge unrelated histories. Consider using '--allow-unrelated-histories'.`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("fatal: Not possible to fast-forward, aborting.")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Merge failed: Not possible to fast-forward. Merge required.`, { context, operation, originalError: error });
-        }
-        if (errorMessage.match(/fatal: '.*?' does not point to a commit/)) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Merge failed: Branch '${input.branch}' not found or does not point to a commit.`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("fatal: You have not concluded your merge")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Merge failed: Conflicts still exist from a previous merge. Resolve conflicts or abort. Output: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("error: Your local changes to the following files would be overwritten by merge")) {
-            throw new McpError(BaseErrorCode.CONFLICT, `Merge failed: Local changes would be overwritten. Please commit or stash them.`, { context, operation, originalError: error });
-        }
-        // Generic error
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Git merge command failed for path ${targetPath}: ${errorMessage}`, { context, operation, originalError: error });
+        if (params.commitMessage && !params.squash)
+            args.push("-m", params.commitMessage);
+        args.push(params.branch);
     }
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout } = await execFileAsync("git", args);
+    return {
+        success: true,
+        message: stdout.trim() || "Merge command executed successfully.",
+        fastForward: stdout.includes("Fast-forward"),
+        needsManualCommit: params.squash,
+        aborted: params.abort,
+    };
 }

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

@@ -1,83 +1,64 @@
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService from ../utils/internal/requestContext.js)
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { requestContextService } from "../../../utils/index.js";
-import { GitMergeInputSchema, gitMergeLogic, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the gitMerge tool registration.
- * @param getWdFn - Function to get the working directory for a session.
- * @param getSidFn - Function to get the session ID from context.
+ * @fileoverview Handles registration and error handling for the git_merge tool.
+ * @module src/mcp-server/tools/gitMerge/registration
  */
-export function initializeGitMergeStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_merge tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { gitMergeLogic, GitMergeInputSchema, GitMergeOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_merge";
 const TOOL_DESCRIPTION = "Merges the specified branch into the current branch. Supports options like --no-ff, --squash, and --abort. Returns the merge result as a JSON object.";
 /**
- * Registers the git_merge tool with the MCP server.
- *
- * @param {McpServer} server - The McpServer instance.
- * @returns {Promise<void>}
- * @throws {Error} If registration fails or state accessors are not initialized.
+ * Registers the git_merge tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param getWorkingDirectory Function to get the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export const registerGitMergeTool = async (server) => {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_merge must be initialized before registration.");
-    }
+export const registerGitMergeTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitMergeTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitMergeInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_merge";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Merge",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitMergeInputSchema.shape,
+        outputSchema: GitMergeOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // Can create merge commits and change history
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await gitMergeLogic(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function
-                const mergeResult = await gitMergeLogic(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    text: JSON.stringify(mergeResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                // Log based on the success flag in the result
-                if (mergeResult.success) {
-                    logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, logicContext);
-                }
-                else {
-                    // Log non-fatal conditions (like conflicts) differently from execution errors
-                    logger.info(`Tool ${TOOL_NAME} completed with specific condition (e.g., conflict, no merge to abort), returning JSON`, logicContext);
-                }
-                // Even if success is false (e.g., conflicts), it's not a tool execution *error* in the MCP sense,
-                // the tool ran, but the git operation failed predictably. Return the structured result.
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default for unexpected logic errors
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
 };

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

@@ -1,6 +1,5 @@
 /**
  * @fileoverview Barrel file for the gitPull tool.
+ * @module src/mcp-server/tools/gitPull/index
  */
-export { registerGitPullTool, initializeGitPullStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitPullInput, GitPullResult } from './logic.js';
+export { registerGitPullTool } from "./registration.js";