@hubspot/cli 7.6.0-beta.5 → 7.6.0-beta.7

package/mcp-server/tools/project/__tests__/{AddFeatureToProject.test.js → AddFeatureToProjectTool.test.js}

@@ -1,16 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AddFeatureToProject_1 = require("../AddFeatureToProject");
-const project_1 = require("../../../utils/project");
-const command_1 = require("../../../utils/command");
-const constants_1 = require("../../../../lib/constants");
+import { AddFeatureToProjectTool, } from '../AddFeatureToProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../../lib/constants.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../../lib/constants');
 vi.mock('../../../utils/toolUsageTracking');
-const mockRunCommandInDir = project_1.runCommandInDir;
-const mockAddFlag = command_1.addFlag;
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
 describe('mcp-server/tools/project/AddFeatureToProject', () => {
     let mockMcpServer;
     let tool;
@@ -23,18 +21,18 @@ describe('mcp-server/tools/project/AddFeatureToProject', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new AddFeatureToProject_1.AddFeatureToProject(mockMcpServer);
+        tool = new AddFeatureToProjectTool(mockMcpServer);
         // Mock addFlag to simulate command building
         mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('add-feature-to-hubspot-project', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('add-feature-to-hubspot-project', expect.objectContaining({
                 title: 'Add feature to HubSpot Project',
-                description: 'Adds a feature to an existing HubSpot project',
+                description: expect.stringContaining('Adds a feature to an existing HubSpot project'),
                 inputSchema: expect.any(Object),
-            }, tool.handler);
+            }), tool.handler);
             expect(result).toBe(mockRegisteredTool);
         });
     });
@@ -94,7 +92,7 @@ describe('mcp-server/tools/project/AddFeatureToProject', () => {
             const input = {
                 ...baseInput,
                 addApp: true,
-                distribution: constants_1.APP_DISTRIBUTION_TYPES.PRIVATE,
+                distribution: APP_DISTRIBUTION_TYPES.PRIVATE,
             };
             const result = await tool.handler(input);
             expect(result.content).toEqual([
@@ -112,13 +110,13 @@ describe('mcp-server/tools/project/AddFeatureToProject', () => {
             const input = {
                 ...baseInput,
                 addApp: true,
-                distribution: constants_1.APP_DISTRIBUTION_TYPES.MARKETPLACE,
-                auth: constants_1.APP_AUTH_TYPES.OAUTH,
+                distribution: APP_DISTRIBUTION_TYPES.MARKETPLACE,
+                auth: APP_AUTH_TYPES.OAUTH,
                 features: ['webhooks'],
             };
             await tool.handler(input);
-            expect(mockAddFlag).toHaveBeenCalledWith('hs project add', 'distribution', constants_1.APP_DISTRIBUTION_TYPES.MARKETPLACE);
-            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'auth', constants_1.APP_AUTH_TYPES.OAUTH);
+            expect(mockAddFlag).toHaveBeenCalledWith('hs project add', 'distribution', APP_DISTRIBUTION_TYPES.MARKETPLACE);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'auth', APP_AUTH_TYPES.OAUTH);
             expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'features', [
                 'webhooks',
             ]);

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

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const CreateProjectTool_1 = require("../CreateProjectTool");
-const project_1 = require("../../../utils/project");
-const command_1 = require("../../../utils/command");
-const constants_1 = require("../../../../lib/constants");
-const v3_1 = require("../../../../lib/projects/create/v3");
+import { CreateProjectTool, } from '../CreateProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
+import { APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../../lib/constants.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../../lib/constants');
 vi.mock('../../../../lib/projects/create/v3');
 vi.mock('../../../utils/toolUsageTracking');
-const mockRunCommandInDir = project_1.runCommandInDir;
-const mockAddFlag = command_1.addFlag;
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
 describe('mcp-server/tools/project/CreateProjectTool', () => {
     let mockMcpServer;
     let tool;
@@ -25,7 +22,7 @@ describe('mcp-server/tools/project/CreateProjectTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new CreateProjectTool_1.CreateProjectTool(mockMcpServer);
+        tool = new CreateProjectTool(mockMcpServer);
         // Mock addFlag to simulate command building
         mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
     });
@@ -45,7 +42,7 @@ describe('mcp-server/tools/project/CreateProjectTool', () => {
             absoluteCurrentWorkingDirectory: '/test/workspace',
             name: 'test-project',
             destination: './test-dest',
-            projectBase: v3_1.EMPTY_PROJECT,
+            projectBase: EMPTY_PROJECT,
         };
         it('should handle successful command execution', async () => {
             mockRunCommandInDir.mockResolvedValue({
@@ -56,7 +53,7 @@ describe('mcp-server/tools/project/CreateProjectTool', () => {
             expect(mockAddFlag).toHaveBeenCalledWith('hs project create', 'platform-version', '2025.2');
             expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'name', 'test-project');
             expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'dest', './test-dest');
-            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'project-base', v3_1.EMPTY_PROJECT);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.any(String), 'project-base', EMPTY_PROJECT);
             expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', expect.any(String));
             expect(result).toEqual({
                 content: [
@@ -76,7 +73,7 @@ describe('mcp-server/tools/project/CreateProjectTool', () => {
         it('should prompt for distribution and auth when creating app project without both', async () => {
             const input = {
                 ...baseInput,
-                projectBase: v3_1.PROJECT_WITH_APP,
+                projectBase: PROJECT_WITH_APP,
             };
             const result = await tool.handler(input);
             expect(result.content).toEqual([
@@ -93,8 +90,8 @@ describe('mcp-server/tools/project/CreateProjectTool', () => {
         it('should prompt for auth when creating app project without auth', async () => {
             const input = {
                 ...baseInput,
-                projectBase: v3_1.PROJECT_WITH_APP,
-                distribution: constants_1.APP_DISTRIBUTION_TYPES.PRIVATE,
+                projectBase: PROJECT_WITH_APP,
+                distribution: APP_DISTRIBUTION_TYPES.PRIVATE,
             };
             const result = await tool.handler(input);
             expect(result.content).toEqual([

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

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

package/mcp-server/tools/project/__tests__/{DeployProject.test.js → DeployProjectTool.test.js}

@@ -1,14 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const DeployProject_1 = require("../DeployProject");
-const project_1 = require("../../../utils/project");
-const command_1 = require("../../../utils/command");
+import { DeployProjectTool } from '../DeployProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
+import { addFlag } from '../../../utils/command.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../utils/toolUsageTracking');
-const mockRunCommandInDir = project_1.runCommandInDir;
-const mockAddFlag = command_1.addFlag;
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
 describe('mcp-server/tools/project/DeployProject', () => {
     let mockMcpServer;
     let tool;
@@ -21,7 +19,7 @@ describe('mcp-server/tools/project/DeployProject', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new DeployProject_1.DeployProject(mockMcpServer);
+        tool = new DeployProjectTool(mockMcpServer);
         // Mock addFlag to simulate command building
         mockAddFlag.mockImplementation((command, flag, value) => `${command} --${flag} "${value}"`);
     });

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

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

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

@@ -0,0 +1,198 @@
+import { GetConfigValuesTool } from '../GetConfigValuesTool.js';
+import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/toolUsageTracking');
+const mockGetIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
+const mockMapToInternalType = mapToInternalType;
+const mockGetAccountId = getAccountId;
+describe('mcp-server/tools/project/GetConfigValuesTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole thing
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new GetConfigValuesTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register tool with correct parameters', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-hubspot-project-feature-config-schema', {
+                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),
+                    }),
+                }),
+            }, tool.handler);
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        const input = {
+            platformVersion: '2025.2',
+            featureType: 'card',
+        };
+        beforeEach(() => {
+            mockGetAccountId.mockReturnValue(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(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 () => {
+            mockGetAccountId.mockReturnValue(null);
+            mockGetIntermediateRepresentationSchema.mockRejectedValue(new Error('No account ID'));
+            const result = await tool.handler(input);
+            expect(result).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Unable to locate JSON schema for type card',
+                    },
+                ],
+            });
+        });
+        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.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const GuidedWalkthroughTool_1 = require("../GuidedWalkthroughTool");
-const command_1 = require("../../../utils/command");
+import { GuidedWalkthroughTool } from '../GuidedWalkthroughTool.js';
+import { execAsync } from '../../../utils/command.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/command');
 vi.mock('../../../utils/toolUsageTracking');
-const mockExecAsync = command_1.execAsync;
+const mockExecAsync = execAsync;
 describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
     let mockMcpServer;
     let tool;
@@ -18,7 +16,7 @@ describe('mcp-server/tools/project/GuidedWalkthroughTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new GuidedWalkthroughTool_1.GuidedWalkthroughTool(mockMcpServer);
+        tool = new GuidedWalkthroughTool(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {

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

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const UploadProjectTools_1 = require("../UploadProjectTools");
-const project_1 = require("../../../utils/project");
+import { UploadProjectTools } from '../UploadProjectTools.js';
+import { runCommandInDir } from '../../../utils/project.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/toolUsageTracking');
-const mockRunCommandInDir = project_1.runCommandInDir;
+const mockRunCommandInDir = runCommandInDir;
 describe('mcp-server/tools/project/UploadProjectTools', () => {
     let mockMcpServer;
     let tool;
@@ -18,7 +16,7 @@ describe('mcp-server/tools/project/UploadProjectTools', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new UploadProjectTools_1.UploadProjectTools(mockMcpServer);
+        tool = new UploadProjectTools(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {

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

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ValidateProjectTool_1 = require("../ValidateProjectTool");
-const project_1 = require("../../../utils/project");
+import { ValidateProjectTool, } from '../ValidateProjectTool.js';
+import { runCommandInDir } from '../../../utils/project.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/toolUsageTracking');
-const mockRunCommandInDir = project_1.runCommandInDir;
+const mockRunCommandInDir = runCommandInDir;
 describe('mcp-server/tools/project/ValidateProjectTool', () => {
     let mockMcpServer;
     let tool;
@@ -18,7 +16,7 @@ describe('mcp-server/tools/project/ValidateProjectTool', () => {
         };
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
-        tool = new ValidateProjectTool_1.ValidateProjectTool(mockMcpServer);
+        tool = new ValidateProjectTool(mockMcpServer);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {

package/mcp-server/tools/project/constants.d.ts

@@ -1,3 +1,4 @@
 import z from 'zod';
 export declare const absoluteProjectPath: z.ZodString;
 export declare const absoluteCurrentWorkingDirectory: z.ZodString;
+export declare const features: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">, z.ZodLiteral<"workflow-action">]>, "many">>;

package/mcp-server/tools/project/constants.js

@@ -1,13 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.absoluteCurrentWorkingDirectory = exports.absoluteProjectPath = void 0;
-const zod_1 = __importDefault(require("zod"));
-exports.absoluteProjectPath = zod_1.default
+import z from 'zod';
+export const absoluteProjectPath = z
     .string()
     .describe('The absolute path to the project directory.');
-exports.absoluteCurrentWorkingDirectory = zod_1.default
+export const absoluteCurrentWorkingDirectory = z
     .string()
     .describe('The absolute path to the current working directory.');
+export const features = z
+    .array(z
+    .union([
+    z.literal('card'),
+    z.literal('settings'),
+    z.literal('app-function'),
+    z.literal('webhooks'),
+    z.literal('workflow-action'),
+])
+    .describe('The features to include in the project, multiple options can be selected'))
+    .optional();

package/mcp-server/types.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tool = void 0;
-class Tool {
+export class Tool {
     mcpServer;
     constructor(mcpServer) {
         this.mcpServer = mcpServer;
@@ -14,4 +11,3 @@ class Tool {
         throw new Error('Must implement handler');
     }
 }
-exports.Tool = Tool;

package/mcp-server/utils/__tests__/command.test.js

@@ -1,43 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("../command");
+import { addFlag } from '../command.js';
 vi.mock('child_process');
 vi.mock('util');
 describe('mcp-server/utils/command', () => {
     describe('addFlag', () => {
         it('should add string flag to command', () => {
-            const result = (0, command_1.addFlag)('hs project create', 'name', 'test-project');
+            const result = addFlag('hs project create', 'name', 'test-project');
             expect(result).toBe('hs project create --name "test-project"');
         });
         it('should add number flag to command', () => {
-            const result = (0, command_1.addFlag)('hs project deploy', 'build', 123);
+            const result = addFlag('hs project deploy', 'build', 123);
             expect(result).toBe('hs project deploy --build "123"');
         });
         it('should add boolean flag to command', () => {
-            const result = (0, command_1.addFlag)('hs project upload', 'watch', true);
+            const result = addFlag('hs project upload', 'watch', true);
             expect(result).toBe('hs project upload --watch "true"');
         });
         it('should add array flag to command', () => {
-            const result = (0, command_1.addFlag)('hs project create', 'features', [
+            const result = addFlag('hs project create', 'features', [
                 'card',
                 'settings',
             ]);
             expect(result).toBe('hs project create --features "card" "settings"');
         });
         it('should handle empty array', () => {
-            const result = (0, command_1.addFlag)('hs project create', 'features', []);
+            const result = addFlag('hs project create', 'features', []);
             expect(result).toBe('hs project create --features ');
         });
         it('should handle array with one item', () => {
-            const result = (0, command_1.addFlag)('hs project create', 'features', ['card']);
+            const result = addFlag('hs project create', 'features', ['card']);
             expect(result).toBe('hs project create --features "card"');
         });
         it('should handle special characters in string values', () => {
-            const result = (0, command_1.addFlag)('hs project create', 'name', 'my-project with spaces');
+            const result = addFlag('hs project create', 'name', 'my-project with spaces');
             expect(result).toBe('hs project create --name "my-project with spaces"');
         });
         it('should handle special characters in array values', () => {
-            const result = (0, command_1.addFlag)('hs project create', 'features', [
+            const result = addFlag('hs project create', 'features', [
                 'card with spaces',
                 'settings',
             ]);

package/mcp-server/utils/__tests__/project.test.js

@@ -1,19 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const project_1 = require("../project");
-const command_1 = require("../command");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+import { runCommandInDir } from '../project.js';
+import { execAsync } from '../command.js';
+import fs from 'fs';
+import path from 'path';
 vi.mock('../command');
 vi.mock('fs');
 vi.mock('path');
-const mockExecAsync = command_1.execAsync;
-const mockExistsSync = fs_1.default.existsSync;
-const mockMkdirSync = fs_1.default.mkdirSync;
-const mockResolve = path_1.default.resolve;
+const mockExecAsync = execAsync;
+const mockExistsSync = fs.existsSync;
+const mockMkdirSync = fs.mkdirSync;
+const mockResolve = path.resolve;
 describe('mcp-server/utils/project', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -32,7 +27,7 @@ describe('mcp-server/utils/project', () => {
             };
             mockExistsSync.mockReturnValue(true);
             mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await (0, project_1.runCommandInDir)(mockDirectory, mockCommand);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
             expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
             expect(mockMkdirSync).not.toHaveBeenCalled();
             expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
@@ -49,7 +44,7 @@ describe('mcp-server/utils/project', () => {
             };
             mockExistsSync.mockReturnValue(false);
             mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await (0, project_1.runCommandInDir)(mockDirectory, mockCommand);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
             expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
             expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
             expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
@@ -63,7 +58,7 @@ describe('mcp-server/utils/project', () => {
             const error = new Error('Command failed');
             mockExistsSync.mockReturnValue(true);
             mockExecAsync.mockRejectedValue(error);
-            await expect((0, project_1.runCommandInDir)(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
+            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
             expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
                 cwd: mockResolvedPath,
                 env: expect.any(Object),
@@ -76,7 +71,7 @@ describe('mcp-server/utils/project', () => {
             };
             mockExistsSync.mockReturnValue(true);
             mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await (0, project_1.runCommandInDir)(mockDirectory, mockCommand);
+            const result = await runCommandInDir(mockDirectory, mockCommand);
             expect(result.stdout).toBe('some output');
             expect(result.stderr).toBe('warning message');
         });

package/mcp-server/utils/command.d.ts

@@ -1,3 +1,3 @@
-import { exec } from 'child_process';
+import { exec } from 'node:child_process';
 export declare const execAsync: typeof exec.__promisify__;
 export declare function addFlag(command: string, flagName: string, value: string | number | boolean | string[]): string;

package/mcp-server/utils/command.js

@@ -1,14 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.execAsync = void 0;
-exports.addFlag = addFlag;
-const util_1 = __importDefault(require("util"));
-const child_process_1 = require("child_process");
-exports.execAsync = util_1.default.promisify(child_process_1.exec);
-function addFlag(command, flagName, value) {
+import util from 'util';
+import { exec } from 'node:child_process';
+export const execAsync = util.promisify(exec);
+export function addFlag(command, flagName, value) {
     if (Array.isArray(value)) {
         return `${command} --${flagName} ${value.map(item => `"${item}"`).join(' ')}`;
     }