@hubspot/cli 8.1.0 → 8.1.1-experimental.0

package/mcp-server/tools/project/__tests__/GetConfigValuesTool.test.js

@@ -1,209 +0,0 @@
-import { GetConfigValuesTool } from '../GetConfigValuesTool.js';
-import { getIntermediateRepresentationSchema } from '@hubspot/project-parsing-lib/schema';
-import { mapToInternalType } from '@hubspot/project-parsing-lib/transform';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('@hubspot/project-parsing-lib/schema');
-vi.mock('@hubspot/project-parsing-lib/transform');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockGetIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
-const mockMapToInternalType = mapToInternalType;
-const mockGetConfigDefaultAccountIfExists = getConfigDefaultAccountIfExists;
-describe('mcp-server/tools/project/GetConfigValuesTool', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error Not mocking the whole thing
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        tool = new GetConfigValuesTool(mockMcpServer);
-    });
-    describe('register', () => {
-        it('should register tool with correct parameters', () => {
-            const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-feature-config-schema', expect.objectContaining({
-                title: 'Fetch the JSON Schema for component',
-                description: expect.stringContaining('Fetches and returns the JSON schema for the provided feature'),
-                inputSchema: expect.objectContaining({
-                    platformVersion: expect.objectContaining({
-                        describe: expect.any(Function),
-                    }),
-                    featureType: expect.objectContaining({
-                        describe: expect.any(Function),
-                    }),
-                }),
-            }), expect.any(Function));
-            expect(result).toBe(mockRegisteredTool);
-        });
-    });
-    describe('handler', () => {
-        const input = {
-            platformVersion: '2025.2',
-            featureType: 'card',
-            absoluteCurrentWorkingDirectory: '/foo',
-        };
-        beforeEach(() => {
-            mockGetConfigDefaultAccountIfExists.mockReturnValue({
-                accountId: 123456789,
-            });
-        });
-        it('should return config schema when component type exists', async () => {
-            const mockSchema = {
-                'internal-card-type': {
-                    type: 'object',
-                    properties: {
-                        title: { type: 'string' },
-                        description: { type: 'string' },
-                    },
-                },
-            };
-            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
-            mockMapToInternalType.mockReturnValue('internal-card-type');
-            const result = await tool.handler(input);
-            expect(mockGetConfigDefaultAccountIfExists).toHaveBeenCalled();
-            expect(mockGetIntermediateRepresentationSchema).toHaveBeenCalledWith({
-                platformVersion: '2025.2',
-                projectSourceDir: '',
-                accountId: 123456789,
-            });
-            expect(mockMapToInternalType).toHaveBeenCalledWith('card');
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            config: {
-                                type: 'object',
-                                properties: {
-                                    title: { type: 'string' },
-                                    description: { type: 'string' },
-                                },
-                            },
-                        }),
-                    },
-                ],
-            });
-        });
-        it('should return error message when component type does not exist in schema', async () => {
-            const mockSchema = {
-                'other-type': {
-                    type: 'object',
-                    properties: {},
-                },
-            };
-            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
-            mockMapToInternalType.mockReturnValue('internal-card-type');
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Unable to locate JSON schema for type card',
-                    },
-                ],
-            });
-        });
-        it('should return error message when getIntermediateRepresentationSchema throws', async () => {
-            mockGetIntermediateRepresentationSchema.mockRejectedValue(new Error('Schema fetch failed'));
-            mockMapToInternalType.mockReturnValue('internal-card-type');
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Unable to locate JSON schema for type card',
-                    },
-                ],
-            });
-        });
-        it('should return error message when mapToInternalType throws', async () => {
-            const mockSchema = {};
-            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
-            mockMapToInternalType.mockImplementation(() => {
-                throw new Error('Mapping failed');
-            });
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Unable to locate JSON schema for type card',
-                    },
-                ],
-            });
-        });
-        it('should handle null account id', async () => {
-            mockGetConfigDefaultAccountIfExists.mockReturnValue(undefined);
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: 'text',
-                        text: 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`',
-                    },
-                ],
-            });
-        });
-        it('should handle empty schema object', async () => {
-            const mockSchema = {};
-            mockGetIntermediateRepresentationSchema.mockResolvedValue(mockSchema);
-            mockMapToInternalType.mockReturnValue('internal-card-type');
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Unable to locate JSON schema for type card',
-                    },
-                ],
-            });
-        });
-        it('should handle complex nested schema structures', async () => {
-            const complexSchema = {
-                'internal-card-type': {
-                    type: 'object',
-                    properties: {
-                        title: { type: 'string', maxLength: 100 },
-                        metadata: {
-                            type: 'object',
-                            properties: {
-                                author: { type: 'string' },
-                                tags: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                },
-                            },
-                            required: ['author'],
-                        },
-                    },
-                    required: ['title'],
-                },
-            };
-            mockGetIntermediateRepresentationSchema.mockResolvedValue(complexSchema);
-            mockMapToInternalType.mockReturnValue('internal-card-type');
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            config: complexSchema['internal-card-type'],
-                        }),
-                    },
-                ],
-            });
-        });
-    });
-});

package/mcp-server/tools/project/__tests__/GuidedWalkthroughTool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/mcp-server/tools/project/__tests__/GuidedWalkthroughTool.test.js

@@ -1,158 +0,0 @@
-import { GuidedWalkthroughTool } from '../GuidedWalkthroughTool.js';
-import { execAsync } from '../../../utils/command.js';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/command');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockExecAsync = execAsync;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error Not mocking whole server
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        tool = new GuidedWalkthroughTool(mockMcpServer);
-    });
-    describe('register', () => {
-        it('should register tool with correct parameters and enhanced description', () => {
-            const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('guided-walkthrough-cli', expect.objectContaining({
-                title: 'Guided walkthrough of the CLI',
-                description: expect.stringContaining('Give the user a guided walkthrough of the HubSpot CLI'),
-                inputSchema: expect.any(Object),
-            }), expect.any(Function));
-            expect(result).toBe(mockRegisteredTool);
-        });
-    });
-    describe('handler', () => {
-        it('should show help for hs init command', async () => {
-            const helpOutput = 'Usage: hs init [options]\nInitialize HubSpot CLI';
-            mockExecAsync.mockResolvedValue({
-                stdout: helpOutput,
-                stderr: '',
-            });
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: 'hs init',
-            });
-            expect(mockExecAsync).toHaveBeenCalledWith('hs init --help');
-            expect(result.content).toHaveLength(1);
-            expect(result.content[0].text).toContain(helpOutput);
-            expect(result.content[0].text).toContain('hs auth');
-        });
-        it('should show help for hs auth command', async () => {
-            const helpOutput = 'Usage: hs auth [options]\nAuthenticate with HubSpot';
-            mockExecAsync.mockResolvedValue({
-                stdout: helpOutput,
-                stderr: '',
-            });
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: 'hs auth',
-            });
-            expect(mockExecAsync).toHaveBeenCalledWith('hs auth --help');
-            expect(result.content[0].text).toContain(helpOutput);
-            expect(result.content[0].text).toContain('hs project create');
-        });
-        it('should show help for hs project create command', async () => {
-            const helpOutput = 'Usage: hs project create [options]\nCreate a new project';
-            mockExecAsync.mockResolvedValue({
-                stdout: helpOutput,
-                stderr: '',
-            });
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: 'hs project create',
-            });
-            expect(mockExecAsync).toHaveBeenCalledWith('hs project create --help');
-            expect(result.content[0].text).toContain(helpOutput);
-            expect(result.content[0].text).toContain('hs project upload');
-        });
-        it('should show help for hs project upload command', async () => {
-            const helpOutput = 'Usage: hs project upload [options]\nUpload project to HubSpot';
-            mockExecAsync.mockResolvedValue({
-                stdout: helpOutput,
-                stderr: '',
-            });
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: 'hs project upload',
-            });
-            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --help');
-            expect(result.content[0].text).toContain(helpOutput);
-            expect(result.content[0].text).toContain('hs project dev');
-        });
-        it('should handle command without next step', async () => {
-            const helpOutput = 'Usage: hs project dev [options]\nStart development server';
-            mockExecAsync.mockResolvedValue({
-                stdout: helpOutput,
-                stderr: '',
-            });
-            // Test with a command that doesn't have a next command
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: 'hs project upload',
-            });
-            expect(result.content[0].text).toContain(helpOutput);
-            expect(result.content[0].text).toContain('hs project dev');
-        });
-        it('should handle no command provided', async () => {
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-            });
-            expect(mockExecAsync).not.toHaveBeenCalled();
-            expect(result.content).toEqual([
-                {
-                    type: 'text',
-                    text: 'Is there another command you would like to learn more about?',
-                },
-            ]);
-        });
-        it('should handle undefined command', async () => {
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: undefined,
-            });
-            expect(mockExecAsync).not.toHaveBeenCalled();
-            expect(result.content).toEqual([
-                {
-                    type: 'text',
-                    text: 'Is there another command you would like to learn more about?',
-                },
-            ]);
-        });
-        it('should handle execAsync errors', async () => {
-            const error = new Error('Command not found');
-            mockExecAsync.mockRejectedValue(error);
-            await expect(tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: 'hs init',
-            })).rejects.toThrow('Command not found');
-        });
-        it('should format help text with proper instructions', async () => {
-            const helpOutput = 'Usage: hs init\nOptions:\n  --help  Show help';
-            mockExecAsync.mockResolvedValue({
-                stdout: helpOutput,
-                stderr: '',
-            });
-            const result = await tool.handler({
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                command: 'hs init',
-            });
-            expect(result.content[0].text).toContain('Display this help output for the user amd wait for them to acknowledge:');
-            expect(result.content[0].text).toContain(helpOutput);
-            expect(result.content[0].text).toContain('Once they are ready, A good command to look at next is hs auth');
-        });
-    });
-});

package/mcp-server/tools/project/__tests__/UploadProjectTools.test.d.ts

@@ -1 +0,0 @@
-export {};

package/mcp-server/tools/project/__tests__/UploadProjectTools.test.js

@@ -1,179 +0,0 @@
-import { UploadProjectTools } from '../UploadProjectTools.js';
-import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
-import { getProjectConfig } from '../../../../lib/projects/config.js';
-import { runCommandInDir } from '../../../utils/project.js';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('@hubspot/project-parsing-lib/profiles');
-vi.mock('../../../../lib/projects/config.js');
-vi.mock('../../../utils/project');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockRunCommandInDir = runCommandInDir;
-const mockGetProjectConfig = getProjectConfig;
-const mockGetAllHsProfiles = getAllHsProfiles;
-describe('mcp-server/tools/project/UploadProjectTools', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error noy mocking whole server
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        mockGetProjectConfig.mockResolvedValue({
-            projectConfig: {
-                srcDir: 'src',
-                name: 'test-project',
-                platformVersion: '2025.2',
-            },
-            projectDir: '/test/project',
-        });
-        mockGetAllHsProfiles.mockResolvedValue([]);
-        tool = new UploadProjectTools(mockMcpServer);
-    });
-    describe('register', () => {
-        it('should register tool with correct parameters', () => {
-            const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('upload-project', expect.objectContaining({
-                title: 'Upload HubSpot Project',
-                description: expect.stringContaining('Uploads the HubSpot project in current working directory.'),
-                inputSchema: expect.any(Object),
-            }), expect.any(Function));
-            expect(result).toBe(mockRegisteredTool);
-        });
-    });
-    describe('handler', () => {
-        const input = {
-            absoluteCurrentWorkingDirectory: '/test/dir',
-            absoluteProjectPath: '/test/project',
-            uploadMessage: 'Test upload message',
-        };
-        it('should upload project successfully', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Project uploaded successfully',
-                stderr: '',
-            });
-            const result = await tool.handler(input);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('hs project upload'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--force-create'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--message "Test upload message"'));
-            expect(result).toEqual({
-                content: [
-                    { type: 'text', text: 'Project uploaded successfully' },
-                    { type: 'text', text: '' },
-                    {
-                        type: 'text',
-                        text: '\nIMPORTANT: If this project contains cards, remember that uploading does NOT make them live automatically. Cards must be manually added to a view in HubSpot to become visible to users.',
-                    },
-                ],
-            });
-        });
-        it('should handle upload with warnings', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Project uploaded with warnings',
-                stderr: 'Warning: some files were ignored',
-            });
-            const result = await tool.handler(input);
-            expect(result.content).toEqual([
-                { type: 'text', text: 'Project uploaded with warnings' },
-                { type: 'text', text: 'Warning: some files were ignored' },
-                {
-                    type: 'text',
-                    text: '\nIMPORTANT: If this project contains cards, remember that uploading does NOT make them live automatically. Cards must be manually added to a view in HubSpot to become visible to users.',
-                },
-            ]);
-        });
-        it('should handle upload errors', async () => {
-            const error = new Error('Upload failed');
-            mockRunCommandInDir.mockRejectedValue(error);
-            await expect(tool.handler(input)).rejects.toThrow('Upload failed');
-        });
-        it('should use force-create and message flags', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Project created and uploaded',
-                stderr: '',
-            });
-            await tool.handler(input);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('hs project upload'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--force-create'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--message "Test upload message"'));
-        });
-        it('should use profiles', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Project created and uploaded',
-                stderr: '',
-            });
-            await tool.handler({
-                ...input,
-                profile: 'dev',
-            });
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('hs project upload'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--force-create'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--message "Test upload message"'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', expect.stringContaining('--profile "dev"'));
-        });
-        it('should prompt for profile if not specified and the project requires them', async () => {
-            mockGetAllHsProfiles.mockResolvedValue(['prod', 'dev']);
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Project created and uploaded',
-                stderr: '',
-            });
-            const result = await tool.handler(input);
-            expect(mockRunCommandInDir).not.toHaveBeenCalled();
-            expect(result.content).toEqual([
-                {
-                    type: 'text',
-                    text: 'Ask the user which profile they would like to use for the upload.',
-                },
-            ]);
-        });
-        it('should handle empty stdout and stderr', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: '',
-                stderr: '',
-            });
-            const result = await tool.handler(input);
-            expect(result.content).toEqual([
-                { type: 'text', text: '' },
-                { type: 'text', text: '' },
-                {
-                    type: 'text',
-                    text: '\nIMPORTANT: If this project contains cards, remember that uploading does NOT make them live automatically. Cards must be manually added to a view in HubSpot to become visible to users.',
-                },
-            ]);
-        });
-        it('should work with different project paths', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Upload complete',
-                stderr: '',
-            });
-            const differentInput = {
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                absoluteProjectPath: '/different/path/to/project',
-                uploadMessage: 'Different test upload message',
-            };
-            await tool.handler(differentInput);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', expect.stringContaining('hs project upload'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', expect.stringContaining('--force-create'));
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', expect.stringContaining('--message "Different test upload message"'));
-        });
-        it('should handle very long output', async () => {
-            const longOutput = 'A'.repeat(10000);
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: longOutput,
-                stderr: 'Long stderr output',
-            });
-            const result = await tool.handler(input);
-            expect(result.content[0].text).toBe(longOutput);
-            expect(result.content[1].text).toBe('Long stderr output');
-        });
-    });
-});

package/mcp-server/tools/project/__tests__/ValidateProjectTool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/mcp-server/tools/project/__tests__/ValidateProjectTool.test.js

@@ -1,118 +0,0 @@
-import { ValidateProjectTool, } from '../ValidateProjectTool.js';
-import { runCommandInDir } from '../../../utils/project.js';
-import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
-import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
-vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
-vi.mock('../../../utils/project');
-vi.mock('../../../utils/toolUsageTracking');
-vi.mock('../../../utils/feedbackTracking');
-const mockTrackToolUsage = trackToolUsage;
-const mockMcpFeedbackRequest = mcpFeedbackRequest;
-const mockRunCommandInDir = runCommandInDir;
-describe('mcp-server/tools/project/ValidateProjectTool', () => {
-    let mockMcpServer;
-    let tool;
-    let mockRegisteredTool;
-    beforeEach(() => {
-        // @ts-expect-error Not mocking the whole thing
-        mockMcpServer = {
-            registerTool: vi.fn(),
-        };
-        mockRegisteredTool = {};
-        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        mockMcpFeedbackRequest.mockResolvedValue('');
-        mockTrackToolUsage.mockResolvedValue(undefined);
-        tool = new ValidateProjectTool(mockMcpServer);
-    });
-    describe('register', () => {
-        it('should register tool with correct parameters', () => {
-            const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('validate-project', expect.objectContaining({
-                title: expect.stringContaining('Validate HubSpot Project'),
-                description: expect.stringContaining('Validates the HubSpot project and its configuration files.'),
-                inputSchema: expect.any(Object),
-            }), expect.any(Function));
-            expect(result).toBe(mockRegisteredTool);
-        });
-    });
-    describe('handler', () => {
-        const input = {
-            absoluteCurrentWorkingDirectory: '/test/dir',
-            absoluteProjectPath: '/test/project',
-        };
-        it('should validate project successfully', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Project validation successful',
-                stderr: '',
-            });
-            const result = await tool.handler(input);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/project', 'hs project validate');
-            expect(result).toEqual({
-                content: [
-                    { type: 'text', text: 'Project validation successful' },
-                    { type: 'text', text: '' },
-                ],
-            });
-        });
-        it('should handle validation with warnings', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Project is valid',
-                stderr: 'Warning: some files may need updates',
-            });
-            const result = await tool.handler(input);
-            expect(result.content).toEqual([
-                { type: 'text', text: 'Project is valid' },
-                { type: 'text', text: 'Warning: some files may need updates' },
-            ]);
-        });
-        it('should handle validation errors', async () => {
-            const error = new Error('Validation failed');
-            mockRunCommandInDir.mockRejectedValue(error);
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [{ type: 'text', text: 'Validation failed' }],
-            });
-        });
-        it('should handle non-Error rejection', async () => {
-            mockRunCommandInDir.mockRejectedValue('String error');
-            const result = await tool.handler(input);
-            expect(result).toEqual({
-                content: [{ type: 'text', text: 'String error' }],
-            });
-        });
-        it('should handle empty stdout and stderr', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'stdout',
-                stderr: 'stderr',
-            });
-            const result = await tool.handler(input);
-            expect(result.content).toEqual([
-                { type: 'text', text: 'stdout' },
-                { type: 'text', text: 'stderr' },
-            ]);
-        });
-        it('should work with different project paths', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: 'Validation complete',
-                stderr: '',
-            });
-            const differentInput = {
-                absoluteCurrentWorkingDirectory: '/test/dir',
-                absoluteProjectPath: '/different/path/to/project',
-            };
-            await tool.handler(differentInput);
-            expect(mockRunCommandInDir).toHaveBeenCalledWith('/different/path/to/project', 'hs project validate');
-        });
-        it('should handle validation errors with stderr', async () => {
-            mockRunCommandInDir.mockResolvedValue({
-                stdout: '',
-                stderr: 'Error: Missing required configuration file',
-            });
-            const result = await tool.handler(input);
-            expect(result.content).toEqual([
-                { type: 'text', text: '' },
-                { type: 'text', text: 'Error: Missing required configuration file' },
-            ]);
-        });
-    });
-});