@andrebuzeli/git-mcp 5.0.4 → 5.0.6

package/dist/tools/git-stash.d.ts

@@ -1,19 +1,124 @@
-import { UniversalResponse } from '../utils/auto-detection.js';
-export declare const gitStashTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            action: {
-                type: string;
-            };
-            projectPath: {
-                type: string;
+/**
+ * Git Stash Tool
+ *
+ * Comprehensive Git stash tool providing stash management operations.
+ * Supports stash, pop, apply, list, show, drop, clear operations for temporary changes storage.
+ *
+ * Operations: stash, pop, apply, list, show, drop, clear
+ */
+import { ToolParams } from '../utils/parameter-validator.js';
+import { ToolResult } from '../utils/operation-error-handler.js';
+export interface GitStashParams extends ToolParams {
+    action: 'stash' | 'pop' | 'apply' | 'list' | 'show' | 'drop' | 'clear';
+    message?: string;
+    stashRef?: string;
+    includeUntracked?: boolean;
+    keepIndex?: boolean;
+    patch?: boolean;
+    quiet?: boolean;
+    index?: boolean;
+    oneline?: boolean;
+}
+export declare class GitStashTool {
+    private gitExecutor;
+    constructor();
+    /**
+     * Execute git-stash operation
+     */
+    execute(params: GitStashParams): Promise<ToolResult>;
+    /**
+     * Validate operation-specific parameters
+     */
+    private validateOperationParams;
+    /**
+     * Validate stash reference format
+     */
+    private isValidStashRef;
+    /**
+     * Handle git stash operation (save current changes)
+     */
+    private handleStash;
+    /**
+     * Handle git stash pop operation (apply and remove latest stash)
+     */
+    private handlePop;
+    /**
+     * Handle git stash apply operation (apply stash without removing)
+     */
+    private handleApply; /**
+  
+     * Handle git stash list operation (show all stashes)
+     */
+    private handleList;
+    /**
+     * Handle git stash show operation (show stash contents)
+     */
+    private handleShow;
+    /**
+     * Handle git stash drop operation (remove specific stash)
+     */
+    private handleDrop;
+    /**
+     * Handle git stash clear operation (remove all stashes)
+     */
+    private handleClear;
+    /**
+     * Normalize stash reference to proper format
+     */
+    private normalizeStashRef;
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema(): {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                action: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                projectPath: {
+                    type: string;
+                    description: string;
+                };
+                message: {
+                    type: string;
+                    description: string;
+                };
+                stashRef: {
+                    type: string;
+                    description: string;
+                };
+                includeUntracked: {
+                    type: string;
+                    description: string;
+                };
+                keepIndex: {
+                    type: string;
+                    description: string;
+                };
+                patch: {
+                    type: string;
+                    description: string;
+                };
+                quiet: {
+                    type: string;
+                    description: string;
+                };
+                index: {
+                    type: string;
+                    description: string;
+                };
+                oneline: {
+                    type: string;
+                    description: string;
+                };
             };
+            required: string[];
         };
-        required: string[];
     };
-    handler(input: any): Promise<UniversalResponse>;
-};
+}
 //# sourceMappingURL=git-stash.d.ts.map

package/dist/tools/git-stash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-stash.d.ts","sourceRoot":"","sources":["../../src/tools/git-stash.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,iBAAiB,EAAc,MAAM,4BAA4B,CAAC;AAEpG,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;mBAIF,GAAG,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAItD,CAAC"}
+{"version":3,"file":"git-stash.d.ts","sourceRoot":"","sources":["../../src/tools/git-stash.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAsB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAyB,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAExF,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,MAAM,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAGvE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAGhB,KAAK,CAAC,EAAE,OAAO,CAAC;IAGhB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,WAAW,CAAqB;;IAMxC;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA8E1D;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA8B/B;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;YACW,WAAW;IAoEzB;;OAEG;YACW,SAAS;IAuDvB;;OAEG;YACW,WAAW,EAqDtB;;;OAGA;YACW,UAAU;IA4DxB;;OAEG;YACW,UAAU;IAoDxB;;OAEG;YACW,UAAU;IAiDxB;;OAEG;YACW,WAAW;IAwDzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;OAEG;IACH,MAAM,CAAC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDrB"}

package/dist/tools/git-stash.js

@@ -1,14 +1,506 @@
 "use strict";
+/**
+ * Git Stash Tool
+ *
+ * Comprehensive Git stash tool providing stash management operations.
+ * Supports stash, pop, apply, list, show, drop, clear operations for temporary changes storage.
+ *
+ * Operations: stash, pop, apply, list, show, drop, clear
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gitStashTool = void 0;
-const auto_detection_js_1 = require("../utils/auto-detection.js");
-exports.gitStashTool = {
-    name: 'git-stash',
-    description: '📚 STASH - Gerenciamento de stash',
-    inputSchema: { type: 'object', properties: { action: { type: 'string' }, projectPath: { type: 'string' } }, required: ['action', 'projectPath'] },
-    async handler(input) {
-        const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath);
-        return (0, auto_detection_js_1.createUniversalResponse)(true, input.action, 'Stash processado', detection, 'git-stash', { stashes: [] });
-    }
-};
+exports.GitStashTool = void 0;
+const git_command_executor_js_1 = require("../utils/git-command-executor.js");
+const parameter_validator_js_1 = require("../utils/parameter-validator.js");
+const operation_error_handler_js_1 = require("../utils/operation-error-handler.js");
+class GitStashTool {
+    gitExecutor;
+    constructor() {
+        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
+    }
+    /**
+     * Execute git-stash operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
+        try {
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-stash', params);
+            if (!validation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Parameter validation failed: ${validation.errors.join(', ')}`, params.action, { validationErrors: validation.errors }, validation.suggestions);
+            }
+            // Validate operation-specific parameters
+            const operationValidation = this.validateOperationParams(params);
+            if (!operationValidation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Operation validation failed: ${operationValidation.errors.join(', ')}`, params.action, { validationErrors: operationValidation.errors }, operationValidation.suggestions);
+            }
+            // Check if it's a Git repository
+            const isRepo = await this.gitExecutor.isGitRepository(params.projectPath);
+            if (!isRepo) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('NOT_A_GIT_REPOSITORY', 'The specified path is not a Git repository', params.action, { projectPath: params.projectPath }, ['Initialize a Git repository first with: git init']);
+            }
+            // Route to appropriate handler
+            switch (params.action) {
+                case 'stash':
+                    return await this.handleStash(params, startTime);
+                case 'pop':
+                    return await this.handlePop(params, startTime);
+                case 'apply':
+                    return await this.handleApply(params, startTime);
+                case 'list':
+                    return await this.handleList(params, startTime);
+                case 'show':
+                    return await this.handleShow(params, startTime);
+                case 'drop':
+                    return await this.handleDrop(params, startTime);
+                case 'clear':
+                    return await this.handleClear(params, startTime);
+                default:
+                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNSUPPORTED_OPERATION', `Operation '${params.action}' is not supported`, params.action, {}, ['Use one of: stash, pop, apply, list, show, drop, clear']);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('EXECUTION_ERROR', `Failed to execute ${params.action}: ${errorMessage}`, params.action, { error: errorMessage }, ['Check the error details and try again']);
+        }
+    }
+    /**
+     * Validate operation-specific parameters
+     */
+    validateOperationParams(params) {
+        const errors = [];
+        const suggestions = [];
+        switch (params.action) {
+            case 'pop':
+            case 'apply':
+            case 'show':
+            case 'drop':
+                // These operations can optionally specify a stash reference
+                if (params.stashRef && !this.isValidStashRef(params.stashRef)) {
+                    errors.push('Invalid stash reference format');
+                    suggestions.push('Use format like "stash@{0}", "0", or omit for latest stash');
+                }
+                break;
+            case 'stash':
+            case 'list':
+            case 'clear':
+                // These operations don't require specific validation
+                break;
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            suggestions
+        };
+    }
+    /**
+     * Validate stash reference format
+     */
+    isValidStashRef(stashRef) {
+        // Valid formats: "stash@{0}", "stash@{1}", "0", "1", etc.
+        return /^(stash@\{\d+\}|\d+)$/.test(stashRef);
+    }
+    /**
+     * Handle git stash operation (save current changes)
+     */
+    async handleStash(params, startTime) {
+        try {
+            const args = [];
+            // Add message if provided
+            if (params.message) {
+                args.push('push', '-m', params.message);
+            }
+            else {
+                args.push('push');
+            }
+            // Add options
+            if (params.includeUntracked) {
+                args.push('--include-untracked');
+            }
+            if (params.keepIndex) {
+                args.push('--keep-index');
+            }
+            if (params.patch) {
+                args.push('--patch');
+            }
+            if (params.quiet) {
+                args.push('--quiet');
+            }
+            const result = await this.gitExecutor.executeGitCommand('stash', args, params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'stash', params.projectPath);
+            }
+            // Check if anything was actually stashed
+            const output = result.stdout.trim();
+            const noChanges = output.includes('No local changes to save');
+            return {
+                success: true,
+                data: {
+                    message: noChanges ? 'No local changes to save' : 'Changes stashed successfully',
+                    stashed: !noChanges,
+                    stashMessage: params.message || 'WIP on current branch',
+                    options: {
+                        includeUntracked: params.includeUntracked || false,
+                        keepIndex: params.keepIndex || false,
+                        patch: params.patch || false
+                    },
+                    output
+                },
+                metadata: {
+                    operation: 'stash',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STASH_ERROR', `Failed to stash changes: ${errorMessage}`, 'stash', { error: errorMessage, message: params.message });
+        }
+    }
+    /**
+     * Handle git stash pop operation (apply and remove latest stash)
+     */
+    async handlePop(params, startTime) {
+        try {
+            const args = ['pop'];
+            // Add stash reference if provided
+            if (params.stashRef) {
+                const normalizedRef = this.normalizeStashRef(params.stashRef);
+                args.push(normalizedRef);
+            }
+            // Add index option if specified
+            if (params.index) {
+                args.push('--index');
+            }
+            // Add quiet option if specified
+            if (params.quiet) {
+                args.push('--quiet');
+            }
+            const result = await this.gitExecutor.executeGitCommand('stash', args, params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'stash pop', params.projectPath);
+            }
+            const stashRef = params.stashRef || 'stash@{0}';
+            return {
+                success: true,
+                data: {
+                    message: `Stash ${stashRef} popped successfully`,
+                    stashRef,
+                    applied: true,
+                    removed: true,
+                    description: 'Stash applied to working directory and removed from stash list',
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'stash pop',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STASH_POP_ERROR', `Failed to pop stash: ${errorMessage}`, 'pop', { error: errorMessage, stashRef: params.stashRef });
+        }
+    }
+    /**
+     * Handle git stash apply operation (apply stash without removing)
+     */
+    async handleApply(params, startTime) {
+        try {
+            const args = ['apply'];
+            // Add stash reference if provided
+            if (params.stashRef) {
+                const normalizedRef = this.normalizeStashRef(params.stashRef);
+                args.push(normalizedRef);
+            }
+            // Add index option if specified
+            if (params.index) {
+                args.push('--index');
+            }
+            // Add quiet option if specified
+            if (params.quiet) {
+                args.push('--quiet');
+            }
+            const result = await this.gitExecutor.executeGitCommand('stash', args, params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'stash apply', params.projectPath);
+            }
+            const stashRef = params.stashRef || 'stash@{0}';
+            return {
+                success: true,
+                data: {
+                    message: `Stash ${stashRef} applied successfully`,
+                    stashRef,
+                    applied: true,
+                    removed: false,
+                    description: 'Stash applied to working directory but kept in stash list',
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'stash apply',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STASH_APPLY_ERROR', `Failed to apply stash: ${errorMessage}`, 'apply', { error: errorMessage, stashRef: params.stashRef });
+        }
+    } /**
+  
+     * Handle git stash list operation (show all stashes)
+     */
+    async handleList(params, startTime) {
+        try {
+            const args = ['list'];
+            // Add oneline format if specified
+            if (params.oneline) {
+                args.push('--oneline');
+            }
+            const result = await this.gitExecutor.executeGitCommand('stash', args, params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'stash list', params.projectPath);
+            }
+            const output = result.stdout.trim();
+            const stashes = output ? output.split('\n').map((line, index) => {
+                const match = line.match(/^(stash@\{\d+\}):\s*(.+)$/);
+                if (match) {
+                    return {
+                        ref: match[1],
+                        index,
+                        message: match[2],
+                        fullLine: line
+                    };
+                }
+                return {
+                    ref: `stash@{${index}}`,
+                    index,
+                    message: line,
+                    fullLine: line
+                };
+            }) : [];
+            return {
+                success: true,
+                data: {
+                    message: stashes.length > 0 ? `Found ${stashes.length} stash(es)` : 'No stashes found',
+                    count: stashes.length,
+                    stashes,
+                    isEmpty: stashes.length === 0,
+                    output
+                },
+                metadata: {
+                    operation: 'stash list',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STASH_LIST_ERROR', `Failed to list stashes: ${errorMessage}`, 'list', { error: errorMessage });
+        }
+    }
+    /**
+     * Handle git stash show operation (show stash contents)
+     */
+    async handleShow(params, startTime) {
+        try {
+            const args = ['show'];
+            // Add stash reference if provided
+            if (params.stashRef) {
+                const normalizedRef = this.normalizeStashRef(params.stashRef);
+                args.push(normalizedRef);
+            }
+            // Add patch format for detailed diff
+            args.push('--patch');
+            const result = await this.gitExecutor.executeGitCommand('stash', args, params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'stash show', params.projectPath);
+            }
+            const stashRef = params.stashRef || 'stash@{0}';
+            // Get stash summary (files changed)
+            const summaryResult = await this.gitExecutor.executeGitCommand('stash', ['show', '--stat', stashRef], params.projectPath);
+            const summary = summaryResult.success ? summaryResult.stdout.trim() : '';
+            return {
+                success: true,
+                data: {
+                    message: `Showing stash ${stashRef}`,
+                    stashRef,
+                    summary,
+                    diff: result.stdout,
+                    description: 'Detailed diff of stashed changes',
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'stash show',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STASH_SHOW_ERROR', `Failed to show stash: ${errorMessage}`, 'show', { error: errorMessage, stashRef: params.stashRef });
+        }
+    }
+    /**
+     * Handle git stash drop operation (remove specific stash)
+     */
+    async handleDrop(params, startTime) {
+        try {
+            const args = ['drop'];
+            // Add stash reference if provided
+            if (params.stashRef) {
+                const normalizedRef = this.normalizeStashRef(params.stashRef);
+                args.push(normalizedRef);
+            }
+            // Add quiet option if specified
+            if (params.quiet) {
+                args.push('--quiet');
+            }
+            const result = await this.gitExecutor.executeGitCommand('stash', args, params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'stash drop', params.projectPath);
+            }
+            const stashRef = params.stashRef || 'stash@{0}';
+            return {
+                success: true,
+                data: {
+                    message: `Stash ${stashRef} dropped successfully`,
+                    stashRef,
+                    removed: true,
+                    description: 'Stash permanently removed from stash list',
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'stash drop',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STASH_DROP_ERROR', `Failed to drop stash: ${errorMessage}`, 'drop', { error: errorMessage, stashRef: params.stashRef });
+        }
+    }
+    /**
+     * Handle git stash clear operation (remove all stashes)
+     */
+    async handleClear(params, startTime) {
+        try {
+            // Get current stash count before clearing
+            const listResult = await this.gitExecutor.executeGitCommand('stash', ['list'], params.projectPath);
+            const stashCount = listResult.success ? listResult.stdout.trim().split('\n').filter(line => line.trim()).length : 0;
+            if (stashCount === 0) {
+                return {
+                    success: true,
+                    data: {
+                        message: 'No stashes to clear',
+                        cleared: 0,
+                        description: 'Stash list was already empty'
+                    },
+                    metadata: {
+                        operation: 'stash clear',
+                        timestamp: new Date().toISOString(),
+                        executionTime: Date.now() - startTime
+                    }
+                };
+            }
+            const args = ['clear'];
+            const result = await this.gitExecutor.executeGitCommand('stash', args, params.projectPath);
+            if (!result.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'stash clear', params.projectPath);
+            }
+            return {
+                success: true,
+                data: {
+                    message: `All ${stashCount} stash(es) cleared successfully`,
+                    cleared: stashCount,
+                    description: 'All stashes permanently removed from stash list',
+                    warning: 'This operation cannot be undone',
+                    output: result.stdout
+                },
+                metadata: {
+                    operation: 'stash clear',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('STASH_CLEAR_ERROR', `Failed to clear stashes: ${errorMessage}`, 'clear', { error: errorMessage });
+        }
+    }
+    /**
+     * Normalize stash reference to proper format
+     */
+    normalizeStashRef(stashRef) {
+        // If it's just a number, convert to stash@{n} format
+        if (/^\d+$/.test(stashRef)) {
+            return `stash@{${stashRef}}`;
+        }
+        return stashRef;
+    }
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-stash',
+            description: 'Git stash tool for temporary changes management. Supports stash, pop, apply, list, show, drop, clear operations for storing and retrieving work-in-progress changes.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['stash', 'pop', 'apply', 'list', 'show', 'drop', 'clear'],
+                        description: 'The stash operation to perform'
+                    },
+                    projectPath: {
+                        type: 'string',
+                        description: 'Absolute path to the project directory'
+                    },
+                    message: {
+                        type: 'string',
+                        description: 'Stash message (for stash operation)'
+                    },
+                    stashRef: {
+                        type: 'string',
+                        description: 'Stash reference (e.g., "stash@{0}", "0") for pop, apply, show, drop operations'
+                    },
+                    includeUntracked: {
+                        type: 'boolean',
+                        description: 'Include untracked files when stashing'
+                    },
+                    keepIndex: {
+                        type: 'boolean',
+                        description: 'Keep index unchanged when stashing'
+                    },
+                    patch: {
+                        type: 'boolean',
+                        description: 'Interactive patch mode for selective stashing'
+                    },
+                    quiet: {
+                        type: 'boolean',
+                        description: 'Suppress output during stash operations'
+                    },
+                    index: {
+                        type: 'boolean',
+                        description: 'Try to reinstate index changes when applying/popping'
+                    },
+                    oneline: {
+                        type: 'boolean',
+                        description: 'Show stash list in oneline format'
+                    }
+                },
+                required: ['action', 'projectPath']
+            }
+        };
+    }
+}
+exports.GitStashTool = GitStashTool;
 //# sourceMappingURL=git-stash.js.map