gitx.do 0.1.1 → 0.1.2

package/dist/mcp/tools.js

@@ -1,3170 +0,0 @@
-/**
- * @fileoverview MCP (Model Context Protocol) Git Tool Definitions
- *
- * This module provides tool definitions for git operations that can be
- * exposed via the Model Context Protocol for AI assistants. It defines
- * a comprehensive set of git tools including status, log, diff, commit,
- * branch, checkout, push, pull, clone, init, add, reset, merge, rebase,
- * stash, tag, remote, and fetch operations.
- *
- * The module uses a registry pattern for tool management, allowing dynamic
- * registration, validation, and invocation of tools. Each tool follows the
- * MCP specification with JSON Schema input validation and standardized
- * result formatting.
- *
- * @module mcp/tools
- *
- * @example
- * // Setting up repository context and invoking a tool
- * import { setRepositoryContext, invokeTool } from './tools'
- *
- * // Set up the repository context first
- * setRepositoryContext({
- *   objectStore: myObjectStore,
- *   refStore: myRefStore,
- *   index: myIndex
- * })
- *
- * // Invoke a tool
- * const result = await invokeTool('git_status', { short: true })
- * console.log(result.content[0].text)
- *
- * @example
- * // Registering a custom tool
- * import { registerTool } from './tools'
- *
- * registerTool({
- *   name: 'my_custom_tool',
- *   description: 'A custom tool',
- *   inputSchema: { type: 'object', properties: {} },
- *   handler: async (params) => ({
- *     content: [{ type: 'text', text: 'Hello!' }]
- *   })
- * })
- */
-import { execSync } from 'child_process';
-import { walkCommits } from '../ops/commit-traversal';
-import { DiffStatus, diffTrees } from '../ops/tree-diff';
-import { listBranches, createBranch, deleteBranch, getCurrentBranch } from '../ops/branch';
-import { createCommit } from '../ops/commit';
-/**
- * Execute a git command and return the output.
- *
- * @description Helper function to execute git CLI commands synchronously.
- * Used by bash CLI-based MCP tools.
- *
- * @param args - Array of arguments to pass to git
- * @param cwd - Working directory for the command
- * @returns Object with stdout, stderr, and exitCode
- */
-function execGit(args, cwd) {
-    try {
-        const stdout = execSync(['git', ...args].join(' '), {
-            cwd: cwd || process.cwd(),
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            maxBuffer: 10 * 1024 * 1024 // 10MB buffer for large outputs
-        });
-        return { stdout: stdout.toString(), stderr: '', exitCode: 0 };
-    }
-    catch (error) {
-        const execError = error;
-        return {
-            stdout: execError.stdout?.toString() || '',
-            stderr: execError.stderr?.toString() || '',
-            exitCode: execError.status || 1
-        };
-    }
-}
-/**
- * Recursively flatten a tree object into a map of path -> entry.
- * @param objectStore - Object store for fetching trees
- * @param treeSha - SHA of the tree to flatten
- * @param prefix - Path prefix for entries
- * @returns Map of full paths to tree entries
- */
-async function flattenTree(objectStore, treeSha, prefix = '') {
-    const result = new Map();
-    const tree = await objectStore.getTree(treeSha);
-    if (!tree)
-        return result;
-    for (const entry of tree.entries) {
-        const fullPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.mode === '040000') {
-            // Recursively process subdirectory
-            const subEntries = await flattenTree(objectStore, entry.sha, fullPath);
-            for (const [path, subEntry] of subEntries) {
-                result.set(path, subEntry);
-            }
-        }
-        else {
-            // File entry
-            result.set(fullPath, { sha: entry.sha, mode: entry.mode });
-        }
-    }
-    return result;
-}
-/**
- * Compare index entries to HEAD tree entries to detect staged changes.
- * @param headEntries - Flattened HEAD tree entries
- * @param indexEntries - Index entries with stage=0 (non-conflict)
- * @returns Array of changes with status and path
- */
-function compareIndexToHead(headEntries, indexEntries) {
-    const changes = [];
-    const indexMap = new Map();
-    // Build index map (only stage 0 entries, which are normal entries)
-    for (const entry of indexEntries) {
-        if (entry.stage === 0) {
-            indexMap.set(entry.path, { sha: entry.sha, mode: entry.mode, stage: entry.stage });
-        }
-    }
-    // Check for conflict entries (stage > 0)
-    const conflictPaths = new Set();
-    for (const entry of indexEntries) {
-        if (entry.stage > 0) {
-            conflictPaths.add(entry.path);
-        }
-    }
-    // Add conflict entries as unmerged
-    for (const path of conflictPaths) {
-        changes.push({ status: DiffStatus.UNMERGED, path });
-    }
-    // Track added and deleted files for rename detection
-    const addedFiles = [];
-    const deletedFiles = [];
-    // Files in index but not in HEAD = Added (potential rename target)
-    for (const [path, indexEntry] of indexMap) {
-        if (conflictPaths.has(path))
-            continue; // Skip conflicts
-        const headEntry = headEntries.get(path);
-        if (!headEntry) {
-            addedFiles.push({ path, sha: indexEntry.sha, mode: indexEntry.mode });
-        }
-        else if (headEntry.sha !== indexEntry.sha) {
-            // Modified
-            changes.push({
-                status: DiffStatus.MODIFIED,
-                path,
-                oldMode: headEntry.mode,
-                newMode: indexEntry.mode,
-                oldSha: headEntry.sha,
-                newSha: indexEntry.sha
-            });
-        }
-        else if (headEntry.mode !== indexEntry.mode) {
-            // Mode changed (e.g., chmod +x)
-            changes.push({
-                status: DiffStatus.TYPE_CHANGED,
-                path,
-                oldMode: headEntry.mode,
-                newMode: indexEntry.mode,
-                oldSha: headEntry.sha,
-                newSha: indexEntry.sha
-            });
-        }
-    }
-    // Files in HEAD but not in index = Deleted (potential rename source)
-    for (const [path, headEntry] of headEntries) {
-        if (conflictPaths.has(path))
-            continue; // Skip conflicts
-        if (!indexMap.has(path)) {
-            deletedFiles.push({ path, sha: headEntry.sha, mode: headEntry.mode });
-        }
-    }
-    // Detect renames: deleted file with same SHA as added file
-    const renamedSourcePaths = new Set();
-    const renamedTargetPaths = new Set();
-    for (const deleted of deletedFiles) {
-        // Find an added file with the same SHA (exact content match = rename)
-        const matchingAdded = addedFiles.find(added => added.sha === deleted.sha && !renamedTargetPaths.has(added.path));
-        if (matchingAdded) {
-            // This is a rename
-            changes.push({
-                status: DiffStatus.RENAMED,
-                path: matchingAdded.path,
-                oldPath: deleted.path,
-                oldMode: deleted.mode,
-                newMode: matchingAdded.mode,
-                oldSha: deleted.sha,
-                newSha: matchingAdded.sha
-            });
-            renamedSourcePaths.add(deleted.path);
-            renamedTargetPaths.add(matchingAdded.path);
-        }
-    }
-    // Add remaining deleted files (not part of rename)
-    for (const deleted of deletedFiles) {
-        if (!renamedSourcePaths.has(deleted.path)) {
-            changes.push({
-                status: DiffStatus.DELETED,
-                path: deleted.path,
-                oldMode: deleted.mode,
-                oldSha: deleted.sha
-            });
-        }
-    }
-    // Add remaining added files (not part of rename)
-    for (const added of addedFiles) {
-        if (!renamedTargetPaths.has(added.path)) {
-            changes.push({
-                status: DiffStatus.ADDED,
-                path: added.path,
-                newMode: added.mode,
-                newSha: added.sha
-            });
-        }
-    }
-    return changes;
-}
-/** Global repository context - set by the application before invoking tools */
-let globalRepositoryContext = null;
-/**
- * Set the global repository context for MCP tools.
- *
- * @description
- * This function sets the global repository context that will be used by all
- * MCP git tools. The context provides access to the object store, ref store,
- * index, and working directory. This must be called before invoking any tools
- * that require repository access.
- *
- * @param ctx - The repository context to set, or null to clear it
- * @returns void
- *
- * @example
- * // Set up context before using tools
- * setRepositoryContext({
- *   objectStore: myObjectStore,
- *   refStore: myRefStore
- * })
- *
- * // Clear context when done
- * setRepositoryContext(null)
- */
-export function setRepositoryContext(ctx) {
-    globalRepositoryContext = ctx;
-}
-/**
- * Get the global repository context.
- *
- * @description
- * Returns the currently set repository context, or null if no context has
- * been set. Tools use this internally to access repository data.
- *
- * @returns The current repository context, or null if not set
- *
- * @example
- * const ctx = getRepositoryContext()
- * if (ctx) {
- *   const commit = await ctx.objectStore.getCommit(sha)
- * }
- */
-export function getRepositoryContext() {
-    return globalRepositoryContext;
-}
-/**
- * Validate a path parameter to prevent command injection.
- *
- * @description
- * Security function that validates file paths to prevent path traversal
- * attacks and command injection. Rejects paths containing '..' (parent
- * directory traversal), absolute paths starting with '/', and shell
- * metacharacters.
- *
- * @param path - The path to validate
- * @returns The validated path (defaults to '.' if undefined)
- * @throws {Error} If path contains forbidden characters or traversal patterns
- *
- * @example
- * validatePath('src/file.ts')    // Returns 'src/file.ts'
- * validatePath(undefined)        // Returns '.'
- * validatePath('../etc/passwd')  // Throws Error
- * validatePath('/etc/passwd')    // Throws Error
- */
-function validatePath(path) {
-    if (!path)
-        return '.';
-    // Reject path traversal attempts
-    if (path.includes('..') || path.startsWith('/') || /[<>|&;$`]/.test(path)) {
-        throw new Error('Invalid path: contains forbidden characters');
-    }
-    return path;
-}
-/**
- * Validate a branch or ref name according to git rules.
- *
- * @description
- * Validates that a branch name conforms to git's naming rules. Branch names
- * can contain alphanumeric characters, dots, underscores, forward slashes,
- * and hyphens. The '..' sequence is forbidden as it's used for range notation.
- *
- * @param name - The branch/ref name to validate
- * @returns The validated name
- * @throws {Error} If name contains invalid characters
- *
- * @example
- * validateBranchName('feature/my-branch')  // Returns 'feature/my-branch'
- * validateBranchName('v1.0.0')             // Returns 'v1.0.0'
- * validateBranchName('main..develop')      // Throws Error
- */
-function validateBranchName(name) {
-    // Git branch name rules
-    if (!/^[a-zA-Z0-9._\/-]+$/.test(name) || name.includes('..')) {
-        throw new Error('Invalid branch name');
-    }
-    return name;
-}
-/**
- * Validate a commit reference (hash, branch, tag, HEAD, etc.).
- *
- * @description
- * Validates commit references which can be SHA hashes, branch names, tag names,
- * HEAD, or relative references like HEAD~3 or HEAD^2. The '..' sequence is
- * forbidden to prevent range injection.
- *
- * @param ref - The commit reference to validate
- * @returns The validated reference
- * @throws {Error} If reference contains invalid characters
- *
- * @example
- * validateCommitRef('abc123def456')  // Returns the SHA
- * validateCommitRef('HEAD~3')        // Returns 'HEAD~3'
- * validateCommitRef('main^2')        // Returns 'main^2'
- * validateCommitRef('a..b')          // Throws Error
- */
-function validateCommitRef(ref) {
-    // Allow hex hashes, branch names, tags, HEAD, HEAD~n, HEAD^n, etc.
-    if (!/^[a-zA-Z0-9._\/-~^]+$/.test(ref) || ref.includes('..')) {
-        throw new Error('Invalid commit reference');
-    }
-    return ref;
-}
-/**
- * Validate a URL for git clone operations.
- *
- * @description
- * Security function that validates URLs to prevent shell injection.
- * Rejects URLs containing shell metacharacters that could be used
- * for command injection.
- *
- * @param url - The URL to validate
- * @returns The validated URL
- * @throws {Error} If URL contains shell injection characters
- *
- * @example
- * validateUrl('https://github.com/user/repo.git')  // Returns the URL
- * validateUrl('git@github.com:user/repo.git')     // Returns the URL
- * validateUrl('https://evil.com; rm -rf /')       // Throws Error
- */
-function validateUrl(url) {
-    // Reject shell injection characters in URLs
-    if (/[<>|&;$`]/.test(url)) {
-        throw new Error('Invalid URL: contains forbidden characters');
-    }
-    return url;
-}
-/**
- * Validate a remote name.
- *
- * @description
- * Validates that a remote name contains only safe characters.
- * Remote names can contain alphanumeric characters, dots, underscores,
- * and hyphens.
- *
- * @param name - The remote name to validate
- * @returns The validated name
- * @throws {Error} If name contains invalid characters
- *
- * @example
- * validateRemoteName('origin')      // Returns 'origin'
- * validateRemoteName('my-remote')   // Returns 'my-remote'
- * validateRemoteName('remote/bad')  // Throws Error
- */
-function validateRemoteName(name) {
-    if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
-        throw new Error('Invalid remote name');
-    }
-    return name;
-}
-/**
- * Convert DiffStatus enum to human-readable text.
- *
- * @description
- * Maps diff status enum values to their git-style display text
- * for use in status and diff output formatting.
- *
- * @param status - The DiffStatus enum value
- * @returns Human-readable status string
- *
- * @example
- * getStatusText(DiffStatus.ADDED)    // Returns 'new file'
- * getStatusText(DiffStatus.DELETED)  // Returns 'deleted'
- */
-function getStatusText(status) {
-    switch (status) {
-        case DiffStatus.ADDED:
-            return 'new file';
-        case DiffStatus.DELETED:
-            return 'deleted';
-        case DiffStatus.MODIFIED:
-            return 'modified';
-        case DiffStatus.RENAMED:
-            return 'renamed';
-        case DiffStatus.COPIED:
-            return 'copied';
-        case DiffStatus.TYPE_CHANGED:
-            return 'typechange';
-        case DiffStatus.UNMERGED:
-            return 'unmerged';
-        default:
-            return 'unknown';
-    }
-}
-/**
- * Format a commit for log output.
- *
- * @description
- * Formats a commit object into a display string, supporting both
- * one-line format (abbreviated SHA + subject) and full format
- * (complete commit information with author and date).
- *
- * @param sha - The full 40-character commit SHA
- * @param commit - The parsed commit object
- * @param oneline - If true, returns abbreviated single-line format
- * @returns Formatted commit string
- *
- * @example
- * // One-line format
- * formatCommit('abc123...', commit, true)
- * // Returns: 'abc123d Fix bug in parser'
- *
- * // Full format
- * formatCommit('abc123...', commit, false)
- * // Returns multi-line commit display
- */
-function formatCommit(sha, commit, oneline) {
-    if (oneline) {
-        const subject = commit.message.split('\n')[0];
-        return `${sha.slice(0, 7)} ${subject}`;
-    }
-    const lines = [];
-    lines.push(`commit ${sha}`);
-    lines.push(`Author: ${commit.author.name} <${commit.author.email}>`);
-    const date = new Date(commit.author.timestamp * 1000);
-    lines.push(`Date:   ${date.toUTCString()}`);
-    lines.push('');
-    // Indent the commit message
-    const messageLines = commit.message.split('\n');
-    for (const line of messageLines) {
-        lines.push(`    ${line}`);
-    }
-    lines.push('');
-    return lines.join('\n');
-}
-/**
- * Internal registry for custom-registered tools.
- * @internal
- */
-const toolRegistry = new Map();
-/**
- * Registry of available git tools.
- *
- * @description
- * Array containing all built-in git tool definitions. These tools are
- * automatically registered in the tool registry on module load. Each
- * tool implements a specific git operation following the MCP specification.
- *
- * Available tools:
- * - git_status: Show repository status
- * - git_log: Show commit history
- * - git_diff: Show differences between commits
- * - git_commit: Create a new commit
- * - git_branch: List, create, or delete branches
- * - git_checkout: Switch branches or restore files
- * - git_push: Upload commits to remote
- * - git_pull: Fetch and integrate from remote
- * - git_clone: Clone a repository
- * - git_init: Initialize a new repository
- * - git_add: Stage files for commit
- * - git_reset: Reset HEAD to a state
- * - git_merge: Merge branches
- * - git_rebase: Rebase commits
- * - git_stash: Stash changes
- * - git_tag: Manage tags
- * - git_remote: Manage remotes
- * - git_fetch: Fetch from remotes
- *
- * @example
- * // Access git tools array
- * import { gitTools } from './tools'
- *
- * for (const tool of gitTools) {
- *   console.log(`Tool: ${tool.name} - ${tool.description}`)
- * }
- */
-export const gitTools = [
-    // git_status tool
-    {
-        name: 'git_status',
-        description: 'Get the current status of a git repository, showing staged, unstaged, and untracked files',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                short: {
-                    type: 'boolean',
-                    description: 'Show short-format output',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { short } = params;
-            const ctx = globalRepositoryContext;
-            // If no repository context, return mock response for backward compatibility
-            if (!ctx) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'No repository context available. Set repository context with setRepositoryContext().',
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            try {
-                // Get current branch
-                const currentBranch = await getCurrentBranch(ctx.refStore);
-                // Get HEAD commit SHA
-                const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                let headSha = null;
-                if (headRef) {
-                    headSha = await ctx.refStore.getRef(headRef);
-                }
-                else {
-                    headSha = await ctx.refStore.getHead();
-                }
-                // Build status output
-                const lines = [];
-                if (!short) {
-                    if (currentBranch) {
-                        lines.push(`On branch ${currentBranch}`);
-                    }
-                    else {
-                        lines.push(`HEAD detached at ${headSha?.slice(0, 7) || 'unknown'}`);
-                    }
-                    lines.push('');
-                }
-                // Get staged changes (index vs HEAD) using direct comparison
-                let stagedChanges = [];
-                let untrackedFiles = [];
-                let workdirChanges = [];
-                if (ctx.index) {
-                    const indexEntries = await ctx.index.getEntries();
-                    // Get HEAD tree entries for comparison
-                    let headEntries = new Map();
-                    if (headSha) {
-                        const headCommit = await ctx.objectStore.getCommit(headSha);
-                        if (headCommit) {
-                            headEntries = await flattenTree(ctx.objectStore, headCommit.tree);
-                        }
-                    }
-                    // Compare index to HEAD to find staged changes
-                    stagedChanges = compareIndexToHead(headEntries, indexEntries);
-                    // Check for untracked, modified, and deleted files in workdir
-                    if (ctx.workdir) {
-                        const workdirFiles = await ctx.workdir.getFiles();
-                        const indexMap = new Map(indexEntries.filter(e => e.stage === 0).map(e => [e.path, e]));
-                        const workdirMap = new Map(workdirFiles.map(f => [f.path, f]));
-                        // Check files in workdir
-                        for (const file of workdirFiles) {
-                            const indexEntry = indexMap.get(file.path);
-                            if (!indexEntry) {
-                                // File in workdir but not in index = untracked
-                                untrackedFiles.push(file.path);
-                            }
-                            else if (indexEntry.sha !== file.sha) {
-                                // File content differs from index = unstaged content modification
-                                workdirChanges.push({ status: DiffStatus.MODIFIED, path: file.path });
-                            }
-                            else if (indexEntry.mode !== file.mode) {
-                                // Same content but different mode = unstaged mode change
-                                workdirChanges.push({ status: DiffStatus.TYPE_CHANGED, path: file.path });
-                            }
-                        }
-                        // Check for deleted files (in index but not in workdir)
-                        for (const [path, _indexEntry] of indexMap) {
-                            if (!workdirMap.has(path)) {
-                                // File in index but not in workdir = unstaged deletion
-                                workdirChanges.push({ status: DiffStatus.DELETED, path });
-                            }
-                        }
-                    }
-                }
-                // Separate unmerged (conflict) entries
-                const unmergedChanges = stagedChanges.filter(c => c.status === DiffStatus.UNMERGED);
-                const normalStagedChanges = stagedChanges.filter(c => c.status !== DiffStatus.UNMERGED);
-                // Format unmerged (conflict) files
-                if (unmergedChanges.length > 0) {
-                    if (!short) {
-                        lines.push('Unmerged paths:');
-                        lines.push('  (use "git add <file>..." to mark resolution)');
-                        lines.push('');
-                    }
-                    for (const entry of unmergedChanges) {
-                        if (short) {
-                            lines.push(`UU ${entry.path}`);
-                        }
-                        else {
-                            lines.push(`        both modified:   ${entry.path}`);
-                        }
-                    }
-                    if (!short)
-                        lines.push('');
-                }
-                // Format staged changes
-                if (normalStagedChanges.length > 0) {
-                    if (!short) {
-                        lines.push('Changes to be committed:');
-                        lines.push('  (use "git restore --staged <file>..." to unstage)');
-                        lines.push('');
-                    }
-                    for (const entry of normalStagedChanges) {
-                        if (short) {
-                            // XY format: X = index status, Y = workdir status (space = no change)
-                            const workdirStatus = workdirChanges.find(w => w.path === entry.path) ? 'M' : ' ';
-                            if (entry.status === DiffStatus.RENAMED && entry.oldPath) {
-                                lines.push(`${entry.status}${workdirStatus} ${entry.oldPath} -> ${entry.path}`);
-                            }
-                            else {
-                                lines.push(`${entry.status}${workdirStatus} ${entry.path}`);
-                            }
-                        }
-                        else {
-                            const statusText = getStatusText(entry.status);
-                            if (entry.status === DiffStatus.RENAMED && entry.oldPath) {
-                                lines.push(`        ${statusText}:   ${entry.oldPath} -> ${entry.path}`);
-                            }
-                            else {
-                                lines.push(`        ${statusText}:   ${entry.path}`);
-                            }
-                        }
-                    }
-                    if (!short)
-                        lines.push('');
-                }
-                // Format unstaged workdir changes (not already counted as staged)
-                const pureWorkdirChanges = workdirChanges.filter(w => !normalStagedChanges.find(s => s.path === w.path));
-                if (pureWorkdirChanges.length > 0) {
-                    if (!short) {
-                        lines.push('Changes not staged for commit:');
-                        lines.push('  (use "git add <file>..." to update what will be committed)');
-                        lines.push('');
-                    }
-                    for (const entry of pureWorkdirChanges) {
-                        if (short) {
-                            lines.push(` ${entry.status} ${entry.path}`);
-                        }
-                        else {
-                            const statusText = getStatusText(entry.status);
-                            lines.push(`        ${statusText}:   ${entry.path}`);
-                        }
-                    }
-                    if (!short)
-                        lines.push('');
-                }
-                // Format untracked files
-                if (untrackedFiles.length > 0) {
-                    if (!short) {
-                        lines.push('Untracked files:');
-                        lines.push('  (use "git add <file>..." to include in what will be committed)');
-                        lines.push('');
-                    }
-                    for (const file of untrackedFiles) {
-                        if (short) {
-                            lines.push(`?? ${file}`);
-                        }
-                        else {
-                            lines.push(`        ${file}`);
-                        }
-                    }
-                    if (!short)
-                        lines.push('');
-                }
-                // If no changes at all
-                if (normalStagedChanges.length === 0 && workdirChanges.length === 0 &&
-                    untrackedFiles.length === 0 && unmergedChanges.length === 0) {
-                    if (!short) {
-                        lines.push('nothing to commit, working tree clean');
-                    }
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: lines.join('\n'),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error getting status: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        },
-    },
-    // git_log tool
-    {
-        name: 'git_log',
-        description: 'Show the commit log history for a git repository',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                maxCount: {
-                    type: 'number',
-                    description: 'Maximum number of commits to show',
-                    minimum: 1,
-                },
-                oneline: {
-                    type: 'boolean',
-                    description: 'Show each commit on a single line',
-                },
-                ref: {
-                    type: 'string',
-                    description: 'Branch, tag, or commit reference to show log for',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { maxCount, oneline, ref } = params;
-            const ctx = globalRepositoryContext;
-            // If no repository context, return error
-            if (!ctx) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'No repository context available. Set repository context with setRepositoryContext().',
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            try {
-                // Resolve starting commit
-                let startSha = null;
-                if (ref) {
-                    // Validate and resolve ref
-                    const validatedRef = validateCommitRef(ref);
-                    // Try as branch first
-                    startSha = await ctx.refStore.getRef(`refs/heads/${validatedRef}`);
-                    // Try as direct SHA if not found
-                    if (!startSha && /^[a-f0-9]{40}$/i.test(validatedRef)) {
-                        startSha = validatedRef;
-                    }
-                    // Try as tag
-                    if (!startSha) {
-                        startSha = await ctx.refStore.getRef(`refs/tags/${validatedRef}`);
-                    }
-                }
-                else {
-                    // Use HEAD
-                    const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                    if (headRef) {
-                        startSha = await ctx.refStore.getRef(headRef);
-                    }
-                    else {
-                        startSha = await ctx.refStore.getHead();
-                    }
-                }
-                if (!startSha) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: ref ? `fatal: bad revision '${ref}'` : 'fatal: HEAD not found',
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Create commit provider adapter
-                const commitProvider = {
-                    getCommit: async (sha) => ctx.objectStore.getCommit(sha)
-                };
-                // Walk commits
-                const traversalOptions = {
-                    maxCount: maxCount,
-                    sort: 'date'
-                };
-                const commits = [];
-                for await (const traversalCommit of walkCommits(commitProvider, startSha, traversalOptions)) {
-                    commits.push(formatCommit(traversalCommit.sha, traversalCommit.commit, oneline || false));
-                }
-                const output = commits.join(oneline ? '\n' : '');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: output || 'No commits found',
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error getting log: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        },
-    },
-    // git_diff tool
-    {
-        name: 'git_diff',
-        description: 'Show differences between commits, commit and working tree',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                staged: {
-                    type: 'boolean',
-                    description: 'Show staged changes (--cached)',
-                },
-                commit1: {
-                    type: 'string',
-                    description: 'First commit to compare',
-                },
-                commit2: {
-                    type: 'string',
-                    description: 'Second commit to compare',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { staged, commit1, commit2 } = params;
-            const ctx = globalRepositoryContext;
-            // If no repository context, return error
-            if (!ctx) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'No repository context available. Set repository context with setRepositoryContext().',
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            try {
-                // Create diff store adapter
-                const diffStore = {
-                    getTree: (sha) => ctx.objectStore.getTree(sha),
-                    getBlob: (sha) => ctx.objectStore.getBlob(sha),
-                    exists: (sha) => ctx.objectStore.hasObject(sha)
-                };
-                let oldTreeSha = null;
-                let newTreeSha = null;
-                // Resolve commits to tree SHAs
-                const resolveCommitToTree = async (commitRef) => {
-                    // Validate ref
-                    const validatedRef = validateCommitRef(commitRef);
-                    // Try as direct SHA
-                    if (/^[a-f0-9]{40}$/i.test(validatedRef)) {
-                        const commit = await ctx.objectStore.getCommit(validatedRef);
-                        return commit?.tree || null;
-                    }
-                    // Try as branch
-                    let sha = await ctx.refStore.getRef(`refs/heads/${validatedRef}`);
-                    if (!sha) {
-                        sha = await ctx.refStore.getRef(`refs/tags/${validatedRef}`);
-                    }
-                    if (sha) {
-                        const commit = await ctx.objectStore.getCommit(sha);
-                        return commit?.tree || null;
-                    }
-                    return null;
-                };
-                if (commit1 && commit2) {
-                    // Compare two commits
-                    oldTreeSha = await resolveCommitToTree(commit1);
-                    newTreeSha = await resolveCommitToTree(commit2);
-                }
-                else if (commit1) {
-                    // Compare commit to HEAD
-                    oldTreeSha = await resolveCommitToTree(commit1);
-                    // Get HEAD tree
-                    const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                    let headSha = null;
-                    if (headRef) {
-                        headSha = await ctx.refStore.getRef(headRef);
-                    }
-                    else {
-                        headSha = await ctx.refStore.getHead();
-                    }
-                    if (headSha) {
-                        const headCommit = await ctx.objectStore.getCommit(headSha);
-                        newTreeSha = headCommit?.tree || null;
-                    }
-                }
-                else if (staged) {
-                    // Compare HEAD to index (staged changes)
-                    const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                    let headSha = null;
-                    if (headRef) {
-                        headSha = await ctx.refStore.getRef(headRef);
-                    }
-                    else {
-                        headSha = await ctx.refStore.getHead();
-                    }
-                    if (headSha) {
-                        const headCommit = await ctx.objectStore.getCommit(headSha);
-                        oldTreeSha = headCommit?.tree || null;
-                    }
-                    // For staged diff, we would compare against index
-                    // newTreeSha would be built from index entries
-                    newTreeSha = null; // Index comparison not fully implemented
-                }
-                else {
-                    // Default: compare working tree to index (unstaged changes)
-                    // This requires working directory support
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: 'Working tree diff requires workdir context (not yet implemented)',
-                            },
-                        ],
-                    };
-                }
-                if (oldTreeSha === null && newTreeSha === null) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: 'No changes to display',
-                            },
-                        ],
-                    };
-                }
-                // Perform the diff
-                const diffResult = await diffTrees(diffStore, oldTreeSha, newTreeSha, {
-                    recursive: true,
-                    detectRenames: true
-                });
-                // Format diff output
-                const lines = [];
-                for (const entry of diffResult.entries) {
-                    lines.push(`diff --git a/${entry.oldPath || entry.path} b/${entry.path}`);
-                    if (entry.status === DiffStatus.ADDED) {
-                        lines.push('new file mode ' + entry.newMode);
-                    }
-                    else if (entry.status === DiffStatus.DELETED) {
-                        lines.push('deleted file mode ' + entry.oldMode);
-                    }
-                    else if (entry.status === DiffStatus.RENAMED) {
-                        lines.push(`rename from ${entry.oldPath}`);
-                        lines.push(`rename to ${entry.path}`);
-                        if (entry.similarity !== undefined) {
-                            lines.push(`similarity index ${entry.similarity}%`);
-                        }
-                    }
-                    lines.push(`index ${entry.oldSha?.slice(0, 7) || '0000000'}..${entry.newSha?.slice(0, 7) || '0000000'}`);
-                    lines.push(`--- ${entry.status === DiffStatus.ADDED ? '/dev/null' : 'a/' + (entry.oldPath || entry.path)}`);
-                    lines.push(`+++ ${entry.status === DiffStatus.DELETED ? '/dev/null' : 'b/' + entry.path}`);
-                    lines.push(''); // Placeholder for actual content diff
-                }
-                // Add stats summary
-                lines.push('');
-                lines.push(`${diffResult.entries.length} file(s) changed`);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: lines.join('\n') || 'No changes',
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error getting diff: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        },
-    },
-    // git_commit tool
-    {
-        name: 'git_commit',
-        description: 'Create a new commit with the staged changes in the repository',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                message: {
-                    type: 'string',
-                    description: 'Commit message',
-                },
-                author: {
-                    type: 'string',
-                    description: 'Author name for the commit',
-                },
-                email: {
-                    type: 'string',
-                    description: 'Author email for the commit',
-                },
-                amend: {
-                    type: 'boolean',
-                    description: 'Amend the previous commit',
-                },
-            },
-            required: ['message'],
-        },
-        handler: async (params) => {
-            const { message, author, email, amend } = params;
-            const ctx = globalRepositoryContext;
-            // If no repository context, return error
-            if (!ctx) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'No repository context available. Set repository context with setRepositoryContext().',
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            // Sanitize message - reject shell injection characters (for backward compat)
-            if (/[`$]/.test(message)) {
-                throw new Error('Invalid commit message: contains forbidden characters');
-            }
-            // Validate author and email if provided
-            if (author && email) {
-                if (/[<>"`$\\]/.test(author) || /[<>"`$\\]/.test(email)) {
-                    throw new Error('Invalid author/email: contains forbidden characters');
-                }
-            }
-            try {
-                // Get current HEAD
-                const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                let parentSha = null;
-                if (headRef) {
-                    parentSha = await ctx.refStore.getRef(headRef);
-                }
-                else {
-                    parentSha = await ctx.refStore.getHead();
-                }
-                // For a real commit, we need:
-                // 1. A tree SHA from the index
-                // 2. Parent commit(s)
-                // 3. Author/committer info
-                // If we don't have an index, we can't create a real commit
-                if (!ctx.index) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: 'Cannot create commit: no index/staging area available',
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Get index entries and build tree
-                // For now, we need a tree SHA - in a full implementation we'd build it from index
-                // This is a simplified version that requires the tree to already exist
-                const now = Math.floor(Date.now() / 1000);
-                const timezone = '+0000'; // UTC for simplicity
-                const commitAuthor = {
-                    name: author || 'Unknown',
-                    email: email || 'unknown@example.com',
-                    timestamp: now,
-                    timezone
-                };
-                // For amend, get the parent's tree (simplified)
-                let treeSha = null;
-                const parents = [];
-                if (amend && parentSha) {
-                    // Get parent commit for amend
-                    const parentCommit = await ctx.objectStore.getCommit(parentSha);
-                    if (parentCommit) {
-                        treeSha = parentCommit.tree;
-                        parents.push(...parentCommit.parents);
-                    }
-                }
-                else if (parentSha) {
-                    // Regular commit - parent is current HEAD
-                    const parentCommit = await ctx.objectStore.getCommit(parentSha);
-                    if (parentCommit) {
-                        treeSha = parentCommit.tree; // Use parent's tree for now (no changes)
-                    }
-                    parents.push(parentSha);
-                }
-                if (!treeSha) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: 'Cannot create commit: unable to determine tree SHA',
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Create the commit using gitdo's commit creation
-                const commitOptions = {
-                    message,
-                    tree: treeSha,
-                    parents,
-                    author: commitAuthor,
-                    committer: commitAuthor,
-                    allowEmpty: true
-                };
-                // Create object store adapter for createCommit
-                const commitStore = {
-                    getObject: ctx.objectStore.getObject,
-                    storeObject: ctx.objectStore.storeObject,
-                    hasObject: ctx.objectStore.hasObject
-                };
-                const result = await createCommit(commitStore, commitOptions);
-                // Update the ref to point to the new commit
-                if (headRef) {
-                    await ctx.refStore.setRef(headRef, result.sha);
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `[${headRef ? headRef.replace('refs/heads/', '') : 'detached HEAD'} ${result.sha.slice(0, 7)}] ${message.split('\n')[0]}`,
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error creating commit: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        },
-    },
-    // git_branch tool
-    {
-        name: 'git_branch',
-        description: 'List, create, or delete branches in the repository',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                list: {
-                    type: 'boolean',
-                    description: 'List branches',
-                },
-                name: {
-                    type: 'string',
-                    description: 'Name of the branch to create or delete',
-                },
-                delete: {
-                    type: 'boolean',
-                    description: 'Delete the specified branch',
-                },
-                all: {
-                    type: 'boolean',
-                    description: 'List all branches including remote branches',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { list, name, delete: del, all } = params;
-            const ctx = globalRepositoryContext;
-            // If no repository context, return error
-            if (!ctx) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'No repository context available. Set repository context with setRepositoryContext().',
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            try {
-                // List branches
-                if (list || (!name && !del)) {
-                    const branches = await listBranches(ctx.refStore, {
-                        all: all || false,
-                        remote: false
-                    });
-                    if (branches.length === 0) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: 'No branches found',
-                                },
-                            ],
-                        };
-                    }
-                    const lines = [];
-                    for (const branch of branches) {
-                        const prefix = branch.current ? '* ' : '  ';
-                        lines.push(`${prefix}${branch.name}`);
-                    }
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: lines.join('\n'),
-                            },
-                        ],
-                    };
-                }
-                // Delete branch
-                if (del && name) {
-                    const validatedName = validateBranchName(name);
-                    const result = await deleteBranch(ctx.refStore, { name: validatedName });
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Deleted branch ${validatedName} (was ${result.sha.slice(0, 7)}).`,
-                            },
-                        ],
-                    };
-                }
-                // Create branch
-                if (name) {
-                    const validatedName = validateBranchName(name);
-                    const result = await createBranch(ctx.refStore, { name: validatedName });
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: result.created
-                                    ? `Created branch '${validatedName}' at ${result.sha.slice(0, 7)}`
-                                    : `Branch '${validatedName}' already exists at ${result.sha.slice(0, 7)}`,
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'No branch operation specified',
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        },
-    },
-    // git_checkout tool
-    {
-        name: 'git_checkout',
-        description: 'Switch branches or restore working tree files using git checkout',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                ref: {
-                    type: 'string',
-                    description: 'Branch, tag, or commit to checkout',
-                },
-                createBranch: {
-                    type: 'boolean',
-                    description: 'Create a new branch with the given ref name',
-                },
-            },
-            required: ['ref'],
-        },
-        handler: async (params) => {
-            const { path, ref, createBranch } = params;
-            const validatedPath = validatePath(path);
-            const validatedRef = validateBranchName(ref);
-            const args = ['checkout'];
-            if (createBranch)
-                args.push('-b');
-            args.push(validatedRef);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_push tool
-    {
-        name: 'git_push',
-        description: 'Upload local commits to a remote repository using git push',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                remote: {
-                    type: 'string',
-                    description: 'Name of the remote (e.g., origin)',
-                },
-                branch: {
-                    type: 'string',
-                    description: 'Branch to push',
-                },
-                force: {
-                    type: 'boolean',
-                    description: 'Force push (use with caution)',
-                },
-                setUpstream: {
-                    type: 'boolean',
-                    description: 'Set upstream for the current branch',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, remote, branch, force, setUpstream } = params;
-            const validatedPath = validatePath(path);
-            const args = ['push'];
-            if (force)
-                args.push('--force');
-            if (setUpstream)
-                args.push('-u');
-            if (remote)
-                args.push(validateRemoteName(remote));
-            if (branch)
-                args.push(validateBranchName(branch));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_pull tool
-    {
-        name: 'git_pull',
-        description: 'Fetch and integrate changes from a remote repository using git pull',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                remote: {
-                    type: 'string',
-                    description: 'Name of the remote (e.g., origin)',
-                },
-                branch: {
-                    type: 'string',
-                    description: 'Branch to pull',
-                },
-                rebase: {
-                    type: 'boolean',
-                    description: 'Rebase instead of merge',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, remote, branch, rebase } = params;
-            const validatedPath = validatePath(path);
-            const args = ['pull'];
-            if (rebase)
-                args.push('--rebase');
-            if (remote)
-                args.push(validateRemoteName(remote));
-            if (branch)
-                args.push(validateBranchName(branch));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_clone tool
-    {
-        name: 'git_clone',
-        description: 'Copy a repository from a remote URL to a local directory using git clone',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: {
-                    type: 'string',
-                    description: 'URL of the repository to clone',
-                },
-                destination: {
-                    type: 'string',
-                    description: 'Local path to clone into',
-                },
-                depth: {
-                    type: 'number',
-                    description: 'Create a shallow clone with specified depth',
-                },
-                branch: {
-                    type: 'string',
-                    description: 'Branch to clone',
-                },
-                bare: {
-                    type: 'boolean',
-                    description: 'Create a bare repository',
-                },
-            },
-            required: ['url'],
-        },
-        handler: async (params) => {
-            const { url, destination, depth, branch, bare } = params;
-            const validatedUrl = validateUrl(url);
-            const args = ['clone'];
-            if (depth)
-                args.push(`--depth=${depth}`);
-            if (branch)
-                args.push(`--branch=${validateBranchName(branch)}`);
-            if (bare)
-                args.push('--bare');
-            args.push(validatedUrl);
-            if (destination)
-                args.push(validatePath(destination));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_init tool
-    {
-        name: 'git_init',
-        description: 'Create an empty git repository or reinitialize an existing one',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path where the repository should be initialized',
-                },
-                bare: {
-                    type: 'boolean',
-                    description: 'Create a bare repository',
-                },
-                initialBranch: {
-                    type: 'string',
-                    description: 'Name for the initial branch',
-                },
-            },
-            required: ['path'],
-        },
-        handler: async (params) => {
-            const { path, bare, initialBranch } = params;
-            const validatedPath = validatePath(path);
-            const args = ['init'];
-            if (bare)
-                args.push('--bare');
-            if (initialBranch)
-                args.push(`--initial-branch=${validateBranchName(initialBranch)}`);
-            args.push(validatedPath);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_add tool
-    {
-        name: 'git_add',
-        description: 'Add file contents to the staging area for the next commit',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                files: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'List of files to add',
-                },
-                all: {
-                    type: 'boolean',
-                    description: 'Add all changes in the working tree',
-                },
-                force: {
-                    type: 'boolean',
-                    description: 'Allow adding otherwise ignored files',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, files, all, force } = params;
-            const validatedPath = validatePath(path);
-            const args = ['add'];
-            if (all)
-                args.push('--all');
-            if (force)
-                args.push('--force');
-            if (files) {
-                // Validate each file path
-                const validatedFiles = files.map((f) => {
-                    if (/[<>|&;$`]/.test(f)) {
-                        throw new Error('Invalid file path: contains forbidden characters');
-                    }
-                    return f;
-                });
-                args.push(...validatedFiles);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_reset tool
-    {
-        name: 'git_reset',
-        description: 'Reset current HEAD to a specified state',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                mode: {
-                    type: 'string',
-                    enum: ['soft', 'mixed', 'hard'],
-                    description: 'Reset mode: soft, mixed, or hard',
-                },
-                commit: {
-                    type: 'string',
-                    description: 'Commit to reset to',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, mode, commit } = params;
-            const validatedPath = validatePath(path);
-            const args = ['reset'];
-            if (mode)
-                args.push(`--${mode}`);
-            if (commit)
-                args.push(validateCommitRef(commit));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_merge tool
-    {
-        name: 'git_merge',
-        description: 'Merge one or more branches into the current branch',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                branch: {
-                    type: 'string',
-                    description: 'Branch to merge into current branch',
-                },
-                noFf: {
-                    type: 'boolean',
-                    description: 'Create a merge commit even when fast-forward is possible',
-                },
-                squash: {
-                    type: 'boolean',
-                    description: 'Squash commits into a single commit',
-                },
-            },
-            required: ['branch'],
-        },
-        handler: async (params) => {
-            const { path, branch, noFf, squash } = params;
-            const validatedPath = validatePath(path);
-            const args = ['merge'];
-            if (noFf)
-                args.push('--no-ff');
-            if (squash)
-                args.push('--squash');
-            args.push(validateBranchName(branch));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_rebase tool
-    {
-        name: 'git_rebase',
-        description: 'Reapply commits on top of another base tip',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                onto: {
-                    type: 'string',
-                    description: 'Branch or commit to rebase onto',
-                },
-                abort: {
-                    type: 'boolean',
-                    description: 'Abort an in-progress rebase',
-                },
-                continue: {
-                    type: 'boolean',
-                    description: 'Continue an in-progress rebase',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, onto, abort, continue: cont } = params;
-            const validatedPath = validatePath(path);
-            const args = ['rebase'];
-            if (abort)
-                args.push('--abort');
-            else if (cont)
-                args.push('--continue');
-            else if (onto)
-                args.push(validateCommitRef(onto));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_stash tool
-    {
-        name: 'git_stash',
-        description: 'Stash the changes in a dirty working directory away',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                action: {
-                    type: 'string',
-                    enum: ['push', 'pop', 'list', 'drop', 'apply', 'clear'],
-                    description: 'Stash action to perform',
-                },
-                message: {
-                    type: 'string',
-                    description: 'Message for the stash entry',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, action, message } = params;
-            const validatedPath = validatePath(path);
-            const args = ['stash'];
-            if (action)
-                args.push(action);
-            if (message && action === 'push') {
-                // Validate stash message for shell injection
-                if (/[`$]/.test(message)) {
-                    throw new Error('Invalid stash message: contains forbidden characters');
-                }
-                args.push('-m', message);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_tag tool
-    {
-        name: 'git_tag',
-        description: 'Create, list, delete, or verify tags in the repository',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                name: {
-                    type: 'string',
-                    description: 'Name of the tag',
-                },
-                message: {
-                    type: 'string',
-                    description: 'Message for annotated tag',
-                },
-                delete: {
-                    type: 'boolean',
-                    description: 'Delete the specified tag',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, name, message, delete: del } = params;
-            const validatedPath = validatePath(path);
-            const args = ['tag'];
-            if (del && name)
-                args.push('-d', validateBranchName(name));
-            else if (message && name) {
-                // Validate tag message for shell injection
-                if (/[`$]/.test(message)) {
-                    throw new Error('Invalid tag message: contains forbidden characters');
-                }
-                args.push('-a', validateBranchName(name), '-m', message);
-            }
-            else if (name)
-                args.push(validateBranchName(name));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_remote tool
-    {
-        name: 'git_remote',
-        description: 'Manage set of tracked repositories (list, add, remove, update remotes)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                action: {
-                    type: 'string',
-                    enum: ['list', 'add', 'remove', 'rename', 'set-url'],
-                    description: 'Remote action to perform',
-                },
-                name: {
-                    type: 'string',
-                    description: 'Name of the remote',
-                },
-                url: {
-                    type: 'string',
-                    description: 'URL of the remote repository',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, action, name, url } = params;
-            const validatedPath = validatePath(path);
-            const args = ['remote'];
-            if (action === 'list' || !action)
-                args.push('-v');
-            else if (action === 'add' && name && url)
-                args.push('add', validateRemoteName(name), validateUrl(url));
-            else if (action === 'remove' && name)
-                args.push('remove', validateRemoteName(name));
-            else if (action === 'set-url' && name && url)
-                args.push('set-url', validateRemoteName(name), validateUrl(url));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_fetch tool
-    {
-        name: 'git_fetch',
-        description: 'Fetch branches and tags from one or more remote repositories',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to the git repository',
-                },
-                remote: {
-                    type: 'string',
-                    description: 'Name of the remote to fetch from',
-                },
-                all: {
-                    type: 'boolean',
-                    description: 'Fetch all remotes',
-                },
-                prune: {
-                    type: 'boolean',
-                    description: 'Prune remote-tracking branches no longer on remote',
-                },
-            },
-        },
-        handler: async (params) => {
-            const { path, remote, all, prune } = params;
-            const validatedPath = validatePath(path);
-            const args = ['fetch'];
-            if (all)
-                args.push('--all');
-            if (prune)
-                args.push('--prune');
-            if (remote && !all)
-                args.push(validateRemoteName(remote));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Executed: git ${args.join(' ')} in ${validatedPath === '.' ? 'current directory' : validatedPath}`,
-                    },
-                ],
-            };
-        },
-    },
-    // git_show tool - uses bash CLI
-    {
-        name: 'git_show',
-        description: 'Show various types of objects (commits, trees, blobs, tags) with their content and metadata',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                revision: {
-                    type: 'string',
-                    description: 'The revision to show (commit SHA, branch name, tag, HEAD, or revision:path syntax)',
-                },
-                path: {
-                    type: 'string',
-                    description: 'Optional file path to show at the revision',
-                },
-                format: {
-                    type: 'string',
-                    enum: ['commit', 'raw', 'diff'],
-                    description: 'Output format: commit (default with diff), raw (file content only), diff (diff only)',
-                },
-                context_lines: {
-                    type: 'number',
-                    description: 'Number of context lines for diff output',
-                    minimum: 0,
-                },
-            },
-            required: ['revision'],
-        },
-        handler: async (params) => {
-            const { revision, path: filePath, format, context_lines } = params;
-            const ctx = globalRepositoryContext;
-            // Security validation
-            if (/[;|&$`<>]/.test(revision)) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid revision: contains forbidden characters' }],
-                    isError: true,
-                };
-            }
-            if (filePath && (filePath.includes('..') || filePath.startsWith('/') || /[<>|&;$`]/.test(filePath))) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid path: contains forbidden characters' }],
-                    isError: true,
-                };
-            }
-            if (context_lines !== undefined && context_lines < 0) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid context_lines: must be at least 0' }],
-                    isError: true,
-                };
-            }
-            // If repository context is set, use it (for testing with mocks)
-            if (ctx) {
-                try {
-                    // Parse revision:path syntax
-                    let targetRevision = revision;
-                    let targetPath = filePath;
-                    if (revision.includes(':') && !filePath) {
-                        const colonIdx = revision.indexOf(':');
-                        targetRevision = revision.substring(0, colonIdx);
-                        targetPath = revision.substring(colonIdx + 1);
-                    }
-                    // Resolve revision to SHA
-                    let commitSha = null;
-                    // Handle HEAD
-                    if (targetRevision === 'HEAD' || targetRevision.startsWith('HEAD~') || targetRevision.startsWith('HEAD^')) {
-                        const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                        if (headRef) {
-                            commitSha = await ctx.refStore.getRef(headRef);
-                        }
-                        else {
-                            commitSha = await ctx.refStore.getHead();
-                        }
-                        // Handle HEAD~n or HEAD^n (simplified - just get parent for now)
-                        if (commitSha && (targetRevision.includes('~') || targetRevision.includes('^'))) {
-                            const commit = await ctx.objectStore.getCommit(commitSha);
-                            if (commit && commit.parents.length > 0) {
-                                commitSha = commit.parents[0];
-                            }
-                            else {
-                                return {
-                                    content: [{ type: 'text', text: `fatal: bad revision '${targetRevision}'` }],
-                                    isError: true,
-                                };
-                            }
-                        }
-                    }
-                    else if (/^[a-f0-9]{7,40}$/i.test(targetRevision)) {
-                        // Direct SHA (full or abbreviated)
-                        if (targetRevision.length === 40) {
-                            commitSha = targetRevision;
-                        }
-                        else {
-                            // Abbreviated SHA - for mock context, try to match
-                            commitSha = targetRevision; // Mock will handle this
-                        }
-                    }
-                    else {
-                        // Try as branch
-                        commitSha = await ctx.refStore.getRef(`refs/heads/${targetRevision}`);
-                        // Try as tag
-                        if (!commitSha) {
-                            commitSha = await ctx.refStore.getRef(`refs/tags/${targetRevision}`);
-                        }
-                    }
-                    if (!commitSha) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: bad revision '${targetRevision}'` }],
-                            isError: true,
-                        };
-                    }
-                    // If path is specified, show file content
-                    if (targetPath) {
-                        const commit = await ctx.objectStore.getCommit(commitSha);
-                        if (!commit) {
-                            return {
-                                content: [{ type: 'text', text: `fatal: not a valid object name ${commitSha}` }],
-                                isError: true,
-                            };
-                        }
-                        const tree = await ctx.objectStore.getTree(commit.tree);
-                        if (!tree) {
-                            return {
-                                content: [{ type: 'text', text: `fatal: tree not found` }],
-                                isError: true,
-                            };
-                        }
-                        // Find file in tree (simplified - assumes file is at root level)
-                        const entry = tree.entries.find(e => e.name === targetPath);
-                        if (!entry) {
-                            return {
-                                content: [{ type: 'text', text: `fatal: path '${targetPath}' does not exist in '${targetRevision}'` }],
-                                isError: true,
-                            };
-                        }
-                        const blob = await ctx.objectStore.getBlob(entry.sha);
-                        if (!blob) {
-                            return {
-                                content: [{ type: 'text', text: `fatal: blob not found` }],
-                                isError: true,
-                            };
-                        }
-                        // Check for binary content
-                        const isBinary = blob.some((b, i) => i < 8000 && b === 0);
-                        if (isBinary) {
-                            // Return base64 encoded binary content
-                            const base64 = btoa(String.fromCharCode(...blob));
-                            return {
-                                content: [{ type: 'text', text: `Binary file content (base64):\n${base64}` }],
-                                isError: false,
-                            };
-                        }
-                        const content = new TextDecoder().decode(blob);
-                        return {
-                            content: [{ type: 'text', text: format === 'raw' ? content : content }],
-                            isError: false,
-                        };
-                    }
-                    // Show commit information
-                    const commit = await ctx.objectStore.getCommit(commitSha);
-                    if (!commit) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: not a valid object name ${commitSha}` }],
-                            isError: true,
-                        };
-                    }
-                    const lines = [];
-                    lines.push(`commit ${commitSha}`);
-                    if (commit.parents.length > 1) {
-                        lines.push(`Merge: ${commit.parents.join(' ')}`);
-                    }
-                    else if (commit.parents.length === 1) {
-                        lines.push(`parent ${commit.parents[0]}`);
-                    }
-                    lines.push(`Author: ${commit.author.name} <${commit.author.email}>`);
-                    if (commit.committer && commit.committer.name !== commit.author.name) {
-                        lines.push(`Committer: ${commit.committer.name} <${commit.committer.email}>`);
-                    }
-                    else {
-                        lines.push(`Committer: ${commit.committer?.name || commit.author.name} <${commit.committer?.email || commit.author.email}>`);
-                    }
-                    const authorDate = new Date(commit.author.timestamp * 1000);
-                    // Include timezone in date output
-                    const timezone = commit.author.timezone || '+0000';
-                    lines.push(`Date:   ${authorDate.toUTCString()} ${timezone}`);
-                    if (commit.gpgsig) {
-                        lines.push('');
-                        lines.push('gpgsig ' + commit.gpgsig);
-                    }
-                    lines.push('');
-                    const messageLines = commit.message.split('\n');
-                    for (const line of messageLines) {
-                        lines.push(`    ${line}`);
-                    }
-                    // Add diff output (simplified)
-                    if (format !== 'raw') {
-                        lines.push('');
-                        const tree = await ctx.objectStore.getTree(commit.tree);
-                        if (tree) {
-                            for (const entry of tree.entries) {
-                                if (entry.mode !== '040000') { // Skip directories
-                                    lines.push(`diff --git a/${entry.name} b/${entry.name}`);
-                                    lines.push(`index 0000000..${entry.sha.substring(0, 7)}`);
-                                    lines.push(`--- /dev/null`);
-                                    lines.push(`+++ b/${entry.name}`);
-                                    const blob = await ctx.objectStore.getBlob(entry.sha);
-                                    if (blob) {
-                                        const content = new TextDecoder().decode(blob);
-                                        const contentLines = content.split('\n');
-                                        lines.push(`@@ -0,0 +1,${contentLines.length} @@`);
-                                        for (const contentLine of contentLines) {
-                                            lines.push(`+${contentLine}`);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    return {
-                        content: [{ type: 'text', text: lines.join('\n') }],
-                        isError: false,
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-                        isError: true,
-                    };
-                }
-            }
-            // Use bash CLI
-            const args = ['show'];
-            if (format === 'diff') {
-                args.push('--format=');
-            }
-            if (context_lines !== undefined) {
-                args.push(`-U${context_lines}`);
-            }
-            // Handle revision:path syntax
-            if (filePath) {
-                args.push(`${revision}:${filePath}`);
-            }
-            else {
-                args.push(revision);
-            }
-            const result = execGit(args);
-            if (result.exitCode !== 0) {
-                return {
-                    content: [{ type: 'text', text: result.stderr || `git show failed with exit code ${result.exitCode}` }],
-                    isError: true,
-                };
-            }
-            return {
-                content: [{ type: 'text', text: result.stdout }],
-                isError: false,
-            };
-        },
-    },
-    // git_blame tool - uses bash CLI
-    {
-        name: 'git_blame',
-        description: 'Git blame - show what revision and author last modified each line of a file',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'File path to blame',
-                },
-                revision: {
-                    type: 'string',
-                    description: 'Show blame at specific revision (commit SHA, branch, tag)',
-                },
-                start_line: {
-                    type: 'number',
-                    description: 'Start line number (1-indexed)',
-                    minimum: 1,
-                },
-                end_line: {
-                    type: 'number',
-                    description: 'End line number (1-indexed, inclusive)',
-                    minimum: 1,
-                },
-                show_email: {
-                    type: 'boolean',
-                    description: 'Show author email instead of name',
-                },
-                show_stats: {
-                    type: 'boolean',
-                    description: 'Show statistics summary',
-                },
-            },
-            required: ['path'],
-        },
-        handler: async (params) => {
-            const { path: filePath, revision, start_line, end_line, show_email } = params;
-            const ctx = globalRepositoryContext;
-            // Security validation
-            if (filePath.includes('..') || filePath.startsWith('/') || /[<>|&;$`]/.test(filePath)) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid path: contains forbidden characters' }],
-                    isError: true,
-                };
-            }
-            if (revision && /[;|&$`<>]/.test(revision)) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid revision: contains forbidden characters' }],
-                    isError: true,
-                };
-            }
-            if (start_line !== undefined && start_line < 1) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid start_line: must be at least 1' }],
-                    isError: true,
-                };
-            }
-            if (end_line !== undefined && end_line < 1) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid end_line: must be at least 1' }],
-                    isError: true,
-                };
-            }
-            if (start_line !== undefined && end_line !== undefined && start_line > end_line) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid line range: start_line cannot be greater than end_line' }],
-                    isError: true,
-                };
-            }
-            // If repository context is set, use it (for testing with mocks)
-            if (ctx) {
-                try {
-                    // Resolve revision to SHA
-                    let commitSha = null;
-                    if (revision) {
-                        if (revision === 'HEAD' || revision.startsWith('HEAD~') || revision.startsWith('HEAD^')) {
-                            const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                            if (headRef) {
-                                commitSha = await ctx.refStore.getRef(headRef);
-                            }
-                            else {
-                                commitSha = await ctx.refStore.getHead();
-                            }
-                        }
-                        else if (/^[a-f0-9]{7,40}$/i.test(revision)) {
-                            commitSha = revision.length === 40 ? revision : revision;
-                        }
-                        else {
-                            commitSha = await ctx.refStore.getRef(`refs/heads/${revision}`);
-                            if (!commitSha) {
-                                commitSha = await ctx.refStore.getRef(`refs/tags/${revision}`);
-                            }
-                        }
-                    }
-                    else {
-                        const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                        if (headRef) {
-                            commitSha = await ctx.refStore.getRef(headRef);
-                        }
-                        else {
-                            commitSha = await ctx.refStore.getHead();
-                        }
-                    }
-                    if (!commitSha) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: bad revision '${revision || 'HEAD'}'` }],
-                            isError: true,
-                        };
-                    }
-                    // Get commit and find file
-                    const commit = await ctx.objectStore.getCommit(commitSha);
-                    if (!commit) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: not a valid object name ${commitSha}` }],
-                            isError: true,
-                        };
-                    }
-                    const tree = await ctx.objectStore.getTree(commit.tree);
-                    if (!tree) {
-                        return {
-                            content: [{ type: 'text', text: 'fatal: tree not found' }],
-                            isError: true,
-                        };
-                    }
-                    // Find file in tree (handles nested paths)
-                    // First, try finding the exact path as a flat entry (for mocks with flat structure)
-                    let blobSha = null;
-                    const flatEntry = tree.entries.find(e => e.name === filePath);
-                    if (flatEntry && flatEntry.mode !== '040000') {
-                        blobSha = flatEntry.sha;
-                    }
-                    // If not found as flat, try navigating nested structure
-                    if (!blobSha) {
-                        const pathParts = filePath.split('/');
-                        let currentTree = tree;
-                        for (let i = 0; i < pathParts.length; i++) {
-                            const part = pathParts[i];
-                            const entry = currentTree.entries.find(e => e.name === part);
-                            if (!entry) {
-                                return {
-                                    content: [{ type: 'text', text: `fatal: no such path '${filePath}' in HEAD` }],
-                                    isError: true,
-                                };
-                            }
-                            if (i === pathParts.length - 1) {
-                                // Last part - should be a file
-                                if (entry.mode === '040000') {
-                                    return {
-                                        content: [{ type: 'text', text: `fatal: '${filePath}' is a directory` }],
-                                        isError: true,
-                                    };
-                                }
-                                blobSha = entry.sha;
-                            }
-                            else {
-                                // Intermediate part - should be a directory
-                                if (entry.mode !== '040000') {
-                                    return {
-                                        content: [{ type: 'text', text: `fatal: '${pathParts.slice(0, i + 1).join('/')}' is not a directory` }],
-                                        isError: true,
-                                    };
-                                }
-                                const nextTree = await ctx.objectStore.getTree(entry.sha);
-                                if (!nextTree) {
-                                    return {
-                                        content: [{ type: 'text', text: 'fatal: tree not found' }],
-                                        isError: true,
-                                    };
-                                }
-                                currentTree = nextTree;
-                            }
-                        }
-                    }
-                    if (!blobSha) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: no such path '${filePath}' in HEAD` }],
-                            isError: true,
-                        };
-                    }
-                    const blob = await ctx.objectStore.getBlob(blobSha);
-                    if (!blob) {
-                        return {
-                            content: [{ type: 'text', text: 'fatal: blob not found' }],
-                            isError: true,
-                        };
-                    }
-                    // Check for binary content (null bytes or binary file signatures)
-                    const hasNullBytes = blob.some((b, i) => i < 8000 && b === 0);
-                    // Check for common binary file signatures
-                    const isPNG = blob[0] === 0x89 && blob[1] === 0x50 && blob[2] === 0x4e && blob[3] === 0x47;
-                    const isJPEG = blob[0] === 0xff && blob[1] === 0xd8 && blob[2] === 0xff;
-                    const isGIF = blob[0] === 0x47 && blob[1] === 0x49 && blob[2] === 0x46;
-                    const isPDF = blob[0] === 0x25 && blob[1] === 0x50 && blob[2] === 0x44 && blob[3] === 0x46;
-                    const isBinary = hasNullBytes || isPNG || isJPEG || isGIF || isPDF;
-                    if (isBinary) {
-                        return {
-                            content: [{ type: 'text', text: 'fatal: binary file cannot be blamed' }],
-                            isError: true,
-                        };
-                    }
-                    const content = new TextDecoder().decode(blob);
-                    const lines = content.split('\n');
-                    if (lines.length > 0 && lines[lines.length - 1] === '') {
-                        lines.pop();
-                    }
-                    // Apply line range filter
-                    let startIdx = 0;
-                    let endIdx = lines.length;
-                    if (start_line !== undefined) {
-                        startIdx = start_line - 1;
-                    }
-                    if (end_line !== undefined) {
-                        endIdx = Math.min(end_line, lines.length);
-                    }
-                    const filteredLines = lines.slice(startIdx, endIdx);
-                    // Format blame output
-                    const date = new Date(commit.author.timestamp * 1000);
-                    const dateStr = date.toISOString().substring(0, 10);
-                    const authorName = commit.author.name.padEnd(15).substring(0, 15);
-                    const shortSha = commitSha.substring(0, 8);
-                    const outputLines = filteredLines.map((line, idx) => {
-                        const lineNum = startIdx + idx + 1;
-                        if (show_email) {
-                            return `${shortSha} (${commit.author.email.padEnd(20).substring(0, 20)} ${dateStr} ${lineNum.toString().padStart(4)}) ${line}`;
-                        }
-                        return `${shortSha} (${authorName} ${dateStr} ${lineNum.toString().padStart(4)}) ${line}`;
-                    });
-                    return {
-                        content: [{ type: 'text', text: outputLines.join('\n') }],
-                        isError: false,
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-                        isError: true,
-                    };
-                }
-            }
-            // Use bash CLI
-            const args = ['blame'];
-            if (show_email) {
-                args.push('-e');
-            }
-            if (start_line !== undefined || end_line !== undefined) {
-                const start = start_line || 1;
-                const end = end_line || '';
-                args.push(`-L${start},${end}`);
-            }
-            if (revision) {
-                args.push(revision);
-            }
-            args.push('--', filePath);
-            const result = execGit(args);
-            if (result.exitCode !== 0) {
-                return {
-                    content: [{ type: 'text', text: result.stderr || `git blame failed with exit code ${result.exitCode}` }],
-                    isError: true,
-                };
-            }
-            return {
-                content: [{ type: 'text', text: result.stdout }],
-                isError: false,
-            };
-        },
-    },
-    // git_ls_tree tool - uses bash CLI
-    {
-        name: 'git_ls_tree',
-        description: 'List the contents of a tree object, showing file names, modes, types, and SHA hashes',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                tree_ish: {
-                    type: 'string',
-                    description: 'Tree-ish to list (commit SHA, branch, tag, tree SHA)',
-                },
-                path: {
-                    type: 'string',
-                    description: 'Optional path filter within the tree',
-                },
-                recursive: {
-                    type: 'boolean',
-                    description: 'Recurse into subdirectories',
-                },
-                show_trees: {
-                    type: 'boolean',
-                    description: 'Show only tree entries (directories), like -d flag',
-                },
-                show_size: {
-                    type: 'boolean',
-                    description: 'Show object size for blob entries',
-                },
-                name_only: {
-                    type: 'boolean',
-                    description: 'Show only file names without mode, type, or SHA',
-                },
-            },
-            required: ['tree_ish'],
-        },
-        handler: async (params) => {
-            const { tree_ish, path: filterPath, recursive, show_trees, show_size, name_only } = params;
-            const ctx = globalRepositoryContext;
-            // Security validation
-            if (/[;|&$`<>]/.test(tree_ish)) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid tree_ish: contains forbidden characters' }],
-                    isError: true,
-                };
-            }
-            if (filterPath && (filterPath.includes('..') || /[<>|&;$`]/.test(filterPath))) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid path: contains forbidden characters' }],
-                    isError: true,
-                };
-            }
-            // If repository context is set, use it (for testing with mocks)
-            if (ctx) {
-                try {
-                    // Resolve tree_ish to tree SHA
-                    let treeSha = null;
-                    // Try direct tree SHA first
-                    if (/^[a-f0-9]{40}$/i.test(tree_ish)) {
-                        const obj = await ctx.objectStore.getObject(tree_ish);
-                        if (obj?.type === 'tree') {
-                            treeSha = tree_ish;
-                        }
-                        else if (obj?.type === 'commit') {
-                            const commit = await ctx.objectStore.getCommit(tree_ish);
-                            treeSha = commit?.tree || null;
-                        }
-                    }
-                    // Try as HEAD or branch/tag reference
-                    if (!treeSha) {
-                        let commitSha = null;
-                        if (tree_ish === 'HEAD') {
-                            const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                            if (headRef) {
-                                commitSha = await ctx.refStore.getRef(headRef);
-                            }
-                            else {
-                                commitSha = await ctx.refStore.getHead();
-                            }
-                        }
-                        else {
-                            commitSha = await ctx.refStore.getRef(`refs/heads/${tree_ish}`);
-                            if (!commitSha) {
-                                commitSha = await ctx.refStore.getRef(`refs/tags/${tree_ish}`);
-                            }
-                        }
-                        if (commitSha) {
-                            const commit = await ctx.objectStore.getCommit(commitSha);
-                            treeSha = commit?.tree || null;
-                        }
-                    }
-                    if (!treeSha) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: not a valid object name '${tree_ish}'` }],
-                            isError: true,
-                        };
-                    }
-                    // Navigate to path if specified
-                    if (filterPath) {
-                        const pathParts = filterPath.replace(/\/$/, '').split('/');
-                        let currentTreeSha = treeSha;
-                        for (const part of pathParts) {
-                            const tree = await ctx.objectStore.getTree(currentTreeSha);
-                            if (!tree) {
-                                return {
-                                    content: [{ type: 'text', text: `fatal: path '${filterPath}' does not exist` }],
-                                    isError: true,
-                                };
-                            }
-                            const entry = tree.entries.find(e => e.name === part);
-                            if (!entry) {
-                                return {
-                                    content: [{ type: 'text', text: `fatal: path '${filterPath}' does not exist` }],
-                                    isError: true,
-                                };
-                            }
-                            if (entry.mode === '040000') {
-                                currentTreeSha = entry.sha;
-                            }
-                            else {
-                                // It's a file - show just this entry
-                                let output = '';
-                                if (name_only) {
-                                    output = entry.name;
-                                }
-                                else {
-                                    const typeStr = entry.mode === '040000' ? 'tree' :
-                                        entry.mode === '160000' ? 'commit' : 'blob';
-                                    output = `${entry.mode} ${typeStr} ${entry.sha}\t${entry.name}`;
-                                }
-                                return { content: [{ type: 'text', text: output }], isError: false };
-                            }
-                        }
-                        treeSha = currentTreeSha;
-                    }
-                    // List tree contents
-                    const entries = [];
-                    async function listTree(sha, prefix) {
-                        const tree = await ctx.objectStore.getTree(sha);
-                        if (!tree)
-                            return;
-                        for (const entry of tree.entries) {
-                            const fullPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-                            const typeStr = entry.mode === '040000' ? 'tree' :
-                                entry.mode === '160000' ? 'commit' : 'blob';
-                            if (show_trees) {
-                                // Only show tree entries
-                                if (typeStr === 'tree') {
-                                    entries.push({ mode: entry.mode, type: typeStr, sha: entry.sha, name: entry.name, path: fullPath });
-                                    if (recursive) {
-                                        await listTree(entry.sha, fullPath);
-                                    }
-                                }
-                            }
-                            else {
-                                if (typeStr === 'tree') {
-                                    if (recursive) {
-                                        await listTree(entry.sha, fullPath);
-                                    }
-                                    else {
-                                        entries.push({ mode: entry.mode, type: typeStr, sha: entry.sha, name: entry.name, path: fullPath });
-                                    }
-                                }
-                                else {
-                                    let size;
-                                    if (show_size && typeStr === 'blob') {
-                                        const blob = await ctx.objectStore.getBlob(entry.sha);
-                                        size = blob?.length;
-                                    }
-                                    entries.push({ mode: entry.mode, type: typeStr, sha: entry.sha, name: entry.name, path: fullPath, size });
-                                }
-                            }
-                        }
-                    }
-                    await listTree(treeSha, '');
-                    // Format output
-                    const outputLines = entries.map(e => {
-                        if (name_only) {
-                            return e.path;
-                        }
-                        if (show_size) {
-                            const sizeStr = e.type === 'tree' ? '-' : (e.size?.toString() || '0');
-                            return `${e.mode} ${e.type} ${e.sha} ${sizeStr.padStart(7)}\t${e.path}`;
-                        }
-                        return `${e.mode} ${e.type} ${e.sha}\t${e.path}`;
-                    });
-                    return {
-                        content: [{ type: 'text', text: outputLines.join('\n') }],
-                        isError: false,
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-                        isError: true,
-                    };
-                }
-            }
-            // Use bash CLI
-            const args = ['ls-tree'];
-            if (recursive) {
-                args.push('-r');
-            }
-            if (show_trees) {
-                args.push('-d');
-            }
-            if (show_size) {
-                args.push('-l');
-            }
-            if (name_only) {
-                args.push('--name-only');
-            }
-            args.push(tree_ish);
-            if (filterPath) {
-                args.push('--', filterPath);
-            }
-            const result = execGit(args);
-            if (result.exitCode !== 0) {
-                return {
-                    content: [{ type: 'text', text: result.stderr || `git ls-tree failed with exit code ${result.exitCode}` }],
-                    isError: true,
-                };
-            }
-            return {
-                content: [{ type: 'text', text: result.stdout }],
-                isError: false,
-            };
-        },
-    },
-    // git_cat_file tool - uses bash CLI
-    {
-        name: 'git_cat_file',
-        description: 'Show content or type/size information for repository objects',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                object: {
-                    type: 'string',
-                    description: 'Object SHA or reference to inspect',
-                },
-                type: {
-                    type: 'string',
-                    enum: ['blob', 'tree', 'commit', 'tag', 'auto'],
-                    description: 'Expected object type (auto to detect)',
-                },
-                pretty_print: {
-                    type: 'boolean',
-                    description: 'Pretty-print the object content',
-                },
-                show_size: {
-                    type: 'boolean',
-                    description: 'Show only the object size',
-                },
-                show_type: {
-                    type: 'boolean',
-                    description: 'Show only the object type',
-                },
-            },
-            required: ['object'],
-        },
-        handler: async (params) => {
-            const { object: objectRef, type: expectedType, pretty_print, show_size, show_type } = params;
-            const ctx = globalRepositoryContext;
-            // Security validation
-            if (/[;|&$`<>]/.test(objectRef)) {
-                return {
-                    content: [{ type: 'text', text: 'Invalid object: contains forbidden characters' }],
-                    isError: true,
-                };
-            }
-            // If repository context is set, use it (for testing with mocks)
-            if (ctx) {
-                try {
-                    // Resolve object reference to SHA
-                    let objectSha = null;
-                    if (objectRef === 'HEAD') {
-                        const headRef = await ctx.refStore.getSymbolicRef('HEAD');
-                        if (headRef) {
-                            objectSha = await ctx.refStore.getRef(headRef);
-                        }
-                        else {
-                            objectSha = await ctx.refStore.getHead();
-                        }
-                    }
-                    else {
-                        // First try direct object lookup (for testing with mock SHAs)
-                        if (await ctx.objectStore.hasObject(objectRef)) {
-                            objectSha = objectRef;
-                        }
-                        else if (/^[a-f0-9]{7,40}$/i.test(objectRef)) {
-                            // Try abbreviated SHA - for mock, check if it starts with the ref
-                            if (objectRef.length < 40) {
-                                // Search for matching object in mock (simplified)
-                                const hasObj = await ctx.objectStore.hasObject(objectRef + 'blob');
-                                if (hasObj) {
-                                    objectSha = objectRef + 'blob';
-                                }
-                                else {
-                                    objectSha = objectRef;
-                                }
-                            }
-                            else {
-                                objectSha = objectRef;
-                            }
-                        }
-                        else {
-                            // Try as branch/tag
-                            objectSha = await ctx.refStore.getRef(`refs/heads/${objectRef}`);
-                            if (!objectSha) {
-                                objectSha = await ctx.refStore.getRef(`refs/tags/${objectRef}`);
-                            }
-                        }
-                    }
-                    if (!objectSha) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: Not a valid object name ${objectRef}` }],
-                            isError: true,
-                        };
-                    }
-                    const obj = await ctx.objectStore.getObject(objectSha);
-                    if (!obj) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: Not a valid object name ${objectRef}` }],
-                            isError: true,
-                        };
-                    }
-                    // Check type mismatch
-                    if (expectedType && expectedType !== 'auto' && obj.type !== expectedType) {
-                        return {
-                            content: [{ type: 'text', text: `fatal: object type mismatch: expected ${expectedType}, got ${obj.type}` }],
-                            isError: true,
-                        };
-                    }
-                    // Show type only
-                    if (show_type) {
-                        return {
-                            content: [{ type: 'text', text: obj.type }],
-                            isError: false,
-                        };
-                    }
-                    // Show size only
-                    if (show_size) {
-                        return {
-                            content: [{ type: 'text', text: obj.data.length.toString() }],
-                            isError: false,
-                        };
-                    }
-                    // Show content based on type
-                    if (obj.type === 'blob') {
-                        const content = new TextDecoder().decode(obj.data);
-                        return {
-                            content: [{ type: 'text', text: content }],
-                            isError: false,
-                        };
-                    }
-                    if (obj.type === 'tree') {
-                        const tree = await ctx.objectStore.getTree(objectSha);
-                        if (!tree) {
-                            return {
-                                content: [{ type: 'text', text: 'fatal: unable to read tree' }],
-                                isError: true,
-                            };
-                        }
-                        const lines = tree.entries.map(e => {
-                            const typeStr = e.mode === '040000' ? 'tree' :
-                                e.mode === '160000' ? 'commit' : 'blob';
-                            return `${e.mode} ${typeStr} ${e.sha}\t${e.name}`;
-                        });
-                        return {
-                            content: [{ type: 'text', text: lines.join('\n') }],
-                            isError: false,
-                        };
-                    }
-                    if (obj.type === 'commit') {
-                        const commit = await ctx.objectStore.getCommit(objectSha);
-                        if (!commit) {
-                            return {
-                                content: [{ type: 'text', text: 'fatal: unable to read commit' }],
-                                isError: true,
-                            };
-                        }
-                        const lines = [];
-                        lines.push(`tree ${commit.tree}`);
-                        for (const parent of commit.parents) {
-                            lines.push(`parent ${parent}`);
-                        }
-                        lines.push(`author ${commit.author.name} <${commit.author.email}> ${commit.author.timestamp} ${commit.author.timezone}`);
-                        lines.push(`committer ${commit.committer?.name || commit.author.name} <${commit.committer?.email || commit.author.email}> ${commit.committer?.timestamp || commit.author.timestamp} ${commit.committer?.timezone || commit.author.timezone}`);
-                        if (commit.gpgsig) {
-                            lines.push(`gpgsig ${commit.gpgsig}`);
-                        }
-                        lines.push('');
-                        lines.push(commit.message);
-                        return {
-                            content: [{ type: 'text', text: lines.join('\n') }],
-                            isError: false,
-                        };
-                    }
-                    // Default - show raw data
-                    return {
-                        content: [{ type: 'text', text: new TextDecoder().decode(obj.data) }],
-                        isError: false,
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-                        isError: true,
-                    };
-                }
-            }
-            // Use bash CLI
-            const args = ['cat-file'];
-            if (show_type) {
-                args.push('-t');
-            }
-            else if (show_size) {
-                args.push('-s');
-            }
-            else if (pretty_print) {
-                args.push('-p');
-            }
-            else if (expectedType && expectedType !== 'auto') {
-                args.push(expectedType);
-            }
-            else {
-                args.push('-p');
-            }
-            args.push(objectRef);
-            const result = execGit(args);
-            if (result.exitCode !== 0) {
-                return {
-                    content: [{ type: 'text', text: result.stderr || `git cat-file failed with exit code ${result.exitCode}` }],
-                    isError: true,
-                };
-            }
-            return {
-                content: [{ type: 'text', text: result.stdout }],
-                isError: false,
-            };
-        },
-    },
-];
-// Register all git tools in the registry on module load
-gitTools.forEach((tool) => {
-    toolRegistry.set(tool.name, tool);
-});
-/**
- * Register a new tool in the registry.
- *
- * @description
- * Adds a custom tool to the global tool registry. The tool must have a valid
- * handler function and a unique name. Once registered, the tool can be invoked
- * using {@link invokeTool}.
- *
- * Note: Built-in git tools are automatically registered on module load.
- *
- * @param tool - The tool definition to register
- * @returns void
- * @throws {Error} If tool handler is missing or not a function
- * @throws {Error} If a tool with the same name already exists
- *
- * @example
- * import { registerTool, invokeTool } from './tools'
- *
- * // Register a custom tool
- * registerTool({
- *   name: 'custom_operation',
- *   description: 'Performs a custom operation',
- *   inputSchema: {
- *     type: 'object',
- *     properties: {
- *       value: { type: 'string', description: 'Input value' }
- *     },
- *     required: ['value']
- *   },
- *   handler: async (params) => {
- *     const { value } = params as { value: string }
- *     return {
- *       content: [{ type: 'text', text: `Processed: ${value}` }]
- *     }
- *   }
- * })
- *
- * // Now invoke the registered tool
- * const result = await invokeTool('custom_operation', { value: 'test' })
- */
-export function registerTool(tool) {
-    if (!tool.handler || typeof tool.handler !== 'function') {
-        throw new Error(`Tool '${tool.name}' must have a handler function`);
-    }
-    if (toolRegistry.has(tool.name)) {
-        throw new Error(`Tool with name '${tool.name}' already exists (duplicate)`);
-    }
-    toolRegistry.set(tool.name, tool);
-}
-/**
- * Validate input parameters against a tool's schema.
- *
- * @description
- * Performs comprehensive validation of tool parameters against the tool's
- * JSON Schema definition. Checks for required parameters, type correctness,
- * enum values, numeric constraints, string patterns, and array item types.
- *
- * This function is called automatically by {@link invokeTool} before
- * executing a tool handler, but can also be used independently for
- * pre-validation.
- *
- * @param tool - The tool whose schema to validate against
- * @param params - The parameters to validate
- * @returns Validation result object with valid flag and array of error messages
- *
- * @example
- * import { validateToolInput, getTool } from './tools'
- *
- * const tool = getTool('git_commit')
- * if (tool) {
- *   const validation = validateToolInput(tool, { path: '/repo' })
- *   if (!validation.valid) {
- *     console.error('Validation errors:', validation.errors)
- *     // Output: ['Missing required parameter: message']
- *   }
- * }
- *
- * @example
- * // Type validation example
- * const result = validateToolInput(tool, { maxCount: 'not-a-number' })
- * // result.errors: ["Parameter 'maxCount' has invalid type: expected number, got string"]
- */
-export function validateToolInput(tool, params) {
-    const errors = [];
-    const schema = tool.inputSchema;
-    // Check required parameters
-    if (schema.required) {
-        for (const requiredParam of schema.required) {
-            if (!(requiredParam in params) || params[requiredParam] === undefined) {
-                errors.push(`Missing required parameter: ${requiredParam}`);
-            }
-        }
-    }
-    // Check parameter types
-    if (schema.properties) {
-        for (const [key, value] of Object.entries(params)) {
-            const propSchema = schema.properties[key];
-            if (!propSchema) {
-                // Unknown parameter - could be an error or we could ignore it
-                continue;
-            }
-            // Type validation
-            const valueType = Array.isArray(value) ? 'array' : typeof value;
-            if (propSchema.type && valueType !== propSchema.type) {
-                errors.push(`Parameter '${key}' has invalid type: expected ${propSchema.type}, got ${valueType}`);
-            }
-            // Enum validation
-            if (propSchema.enum && !propSchema.enum.includes(value)) {
-                errors.push(`Parameter '${key}' must be one of: ${propSchema.enum.join(', ')}`);
-            }
-            // Number constraints
-            if (propSchema.type === 'number' && typeof value === 'number') {
-                if (propSchema.minimum !== undefined && value < propSchema.minimum) {
-                    errors.push(`Parameter '${key}' must be at least ${propSchema.minimum}`);
-                }
-                if (propSchema.maximum !== undefined && value > propSchema.maximum) {
-                    errors.push(`Parameter '${key}' must be at most ${propSchema.maximum}`);
-                }
-            }
-            // String pattern validation
-            if (propSchema.type === 'string' && typeof value === 'string' && propSchema.pattern) {
-                const regex = new RegExp(propSchema.pattern);
-                if (!regex.test(value)) {
-                    errors.push(`Parameter '${key}' does not match required pattern: ${propSchema.pattern}`);
-                }
-            }
-            // Array item type validation
-            if (propSchema.type === 'array' && Array.isArray(value) && propSchema.items) {
-                const itemType = propSchema.items.type;
-                for (let i = 0; i < value.length; i++) {
-                    const itemValueType = typeof value[i];
-                    if (itemType && itemValueType !== itemType) {
-                        errors.push(`Array item at index ${i} in '${key}' has invalid type: expected ${itemType}, got ${itemValueType}`);
-                    }
-                }
-            }
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}
-/**
- * Invoke a tool by name with the given parameters.
- *
- * @description
- * Looks up a tool by name in the registry, validates the provided parameters
- * against the tool's schema, and executes the tool's handler. Validation
- * errors and execution errors are returned as MCPToolResult with isError=true
- * rather than throwing exceptions.
- *
- * This is the primary function for executing MCP tools. Ensure the repository
- * context is set via {@link setRepositoryContext} before invoking git tools.
- *
- * @param toolName - Name of the tool to invoke (e.g., 'git_status')
- * @param params - Parameters to pass to the tool handler
- * @returns Promise resolving to the tool result
- * @throws {Error} If the tool is not found in the registry
- *
- * @example
- * import { invokeTool, setRepositoryContext } from './tools'
- *
- * // Set up repository context first
- * setRepositoryContext(myRepoContext)
- *
- * // Invoke git_status tool
- * const status = await invokeTool('git_status', { short: true })
- * if (!status.isError) {
- *   console.log(status.content[0].text)
- * }
- *
- * @example
- * // Invoke git_log with parameters
- * const log = await invokeTool('git_log', {
- *   maxCount: 10,
- *   oneline: true,
- *   ref: 'main'
- * })
- *
- * @example
- * // Handle validation errors
- * const result = await invokeTool('git_commit', {})
- * if (result.isError) {
- *   // result.content[0].text contains validation error message
- *   console.error('Error:', result.content[0].text)
- * }
- */
-export async function invokeTool(toolName, params) {
-    const tool = toolRegistry.get(toolName);
-    if (!tool) {
-        throw new Error(`Tool '${toolName}' not found (does not exist)`);
-    }
-    // Validate parameters before invoking
-    const validation = validateToolInput(tool, params);
-    if (!validation.valid) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Validation error: ${validation.errors.join('; ')}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-    // Invoke the handler with error handling
-    try {
-        return await tool.handler(params);
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: error instanceof Error ? error.message : String(error),
-                },
-            ],
-            isError: true,
-        };
-    }
-}
-/**
- * Get a list of all registered tools.
- *
- * @description
- * Returns an array of all tools in the registry with their names, descriptions,
- * and input schemas. Handler functions are omitted for security and serialization.
- * This is useful for discovery and documentation purposes.
- *
- * @returns Array of tool definitions without handler functions
- *
- * @example
- * import { listTools } from './tools'
- *
- * const tools = listTools()
- * console.log(`Available tools: ${tools.length}`)
- *
- * for (const tool of tools) {
- *   console.log(`- ${tool.name}: ${tool.description}`)
- *   console.log(`  Required params: ${tool.inputSchema.required?.join(', ') || 'none'}`)
- * }
- */
-export function listTools() {
-    const tools = [];
-    for (const tool of toolRegistry.values()) {
-        // Return tool without handler
-        tools.push({
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-        });
-    }
-    return tools;
-}
-/**
- * Get a tool by name.
- *
- * @description
- * Retrieves a tool definition from the registry by its name. Returns the
- * complete tool object including the handler function. Returns undefined
- * if no tool with the given name exists.
- *
- * @param name - Name of the tool to retrieve (e.g., 'git_status')
- * @returns The complete tool definition if found, undefined otherwise
- *
- * @example
- * import { getTool } from './tools'
- *
- * const statusTool = getTool('git_status')
- * if (statusTool) {
- *   console.log(`Description: ${statusTool.description}`)
- *   console.log(`Parameters:`, Object.keys(statusTool.inputSchema.properties || {}))
- * }
- *
- * @example
- * // Check if a tool exists before using it
- * const tool = getTool('my_custom_tool')
- * if (!tool) {
- *   console.error('Tool not found')
- * }
- */
-export function getTool(name) {
-    return toolRegistry.get(name);
-}
-//# sourceMappingURL=tools.js.map