@hubspot/cli 7.7.27-experimental.2 → 7.7.29-experimental.0

package/mcp-server/tools/cms/__tests__/HsCreateModuleTool.test.js

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsCreateModuleTool } from '../HsCreateModuleTool.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', () => ({
+    trackToolUsage: vi.fn(),
+}));
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('HsCreateModuleTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new HsCreateModuleTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-hubspot-cms-module', {
+                title: 'Create HubSpot CMS Module',
+                description: 'Creates a new HubSpot CMS module using the hs create module command. Modules can be created non-interactively by specifying moduleLabel and other module options. You can create either HubL or React modules by setting the reactType parameter.',
+                inputSchema: expect.any(Object),
+            }, expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should prompt for missing required parameters', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(3);
+            expect(result.content[0].text).toContain('Ask the user to specify the name of the module');
+            expect(result.content[1].text).toContain('Ask the user to provide a label for the module');
+            expect(result.content[2].text).toContain('Ask the user what type of module they want to create: HubL or React?');
+        });
+        it('should prompt for missing name only when other params provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to specify the name of the module');
+        });
+        it('should prompt for missing moduleLabel when name provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                reactType: true,
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user to provide a label for the module');
+        });
+        it('should prompt for missing reactType when other required params provided', async () => {
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Ask the user what type of module they want to create: HubL or React?');
+        });
+        it('should execute command with all required parameters (HubL module)', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs create module "Test Module"', 'module-label', 'Test Label');
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('module-label'), 'react-type', false);
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('react-type'), 'content-types', 'ANY');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', expect.stringContaining('hs create module'));
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Module created successfully');
+        });
+        it('should execute command with React module', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "React Module" --module-label React Label')
+                .mockReturnValueOnce('hs create module "React Module" --module-label React Label --react-type true')
+                .mockReturnValueOnce('hs create module "React Module" --module-label React Label --react-type true --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'React module created successfully',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'React Module',
+                moduleLabel: 'React Label',
+                reactType: true,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('module-label'), 'react-type', true);
+            expect(result.content[0].text).toContain('React module created successfully');
+        });
+        it('should execute command with destination path', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" "custom/path" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" "custom/path" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" "custom/path" --module-label Test Label --react-type false --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created at custom path',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                dest: 'custom/path',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', expect.stringContaining('"custom/path"'));
+            expect(result.content[0].text).toContain('Module created at custom path');
+        });
+        it('should execute command with custom content types', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types LANDING_PAGE,BLOG_POST');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module with custom content types created',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+                contentTypes: 'LANDING_PAGE,BLOG_POST',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('react-type'), 'content-types', 'LANDING_PAGE,BLOG_POST');
+            expect(result.content[0].text).toContain('Module with custom content types created');
+        });
+        it('should execute command with global flag', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label')
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label --react-type false')
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label --react-type false --content-types ANY')
+                .mockReturnValueOnce('hs create module "Global Module" --module-label Global Label --react-type false --content-types ANY --global true');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Global module created',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Global Module',
+                moduleLabel: 'Global Label',
+                reactType: false,
+                global: true,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('content-types'), 'global', true);
+            expect(result.content[0].text).toContain('Global module created');
+        });
+        it('should execute command with availableForNewContent flag', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY --available-for-new-content false');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created with availableForNewContent false',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+                availableForNewContent: false,
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith(expect.stringContaining('content-types'), 'available-for-new-content', false);
+            expect(result.content[0].text).toContain('Module created with availableForNewContent false');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Command failed'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Command failed');
+        });
+        it('should handle stderr output', async () => {
+            mockAddFlag
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false')
+                .mockReturnValueOnce('hs create module "Test Module" --module-label Test Label --react-type false --content-types ANY');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'Module created successfully',
+                stderr: 'Warning: Deprecated feature used',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                userSuppliedName: 'Test Module',
+                moduleLabel: 'Test Label',
+                reactType: false,
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('Module created successfully');
+            expect(result.content[1].text).toContain('Warning: Deprecated feature used');
+        });
+    });
+});

package/mcp-server/tools/cms/__tests__/HsListTool.test.d.ts

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

package/mcp-server/tools/cms/__tests__/HsListTool.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HsListTool } from '../HsListTool.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', () => ({
+    trackToolUsage: vi.fn(),
+}));
+const mockRunCommandInDir = runCommandInDir;
+const mockAddFlag = addFlag;
+describe('HsListTool', () => {
+    let mockMcpServer;
+    let tool;
+    let mockRegisteredTool;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // @ts-expect-error Not mocking the whole server
+        mockMcpServer = {
+            registerTool: vi.fn(),
+        };
+        mockRegisteredTool = {};
+        mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
+        tool = new HsListTool(mockMcpServer);
+    });
+    describe('register', () => {
+        it('should register the tool with the MCP server', () => {
+            const result = tool.register();
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-hubspot-cms-remote-contents', {
+                title: 'List HubSpot CMS Directory Contents',
+                description: 'List remote contents of a HubSpot CMS directory.',
+                inputSchema: expect.any(Object),
+            }, expect.any(Function));
+            expect(result).toBe(mockRegisteredTool);
+        });
+    });
+    describe('handler', () => {
+        it('should execute hs list command with no parameters', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'file1.html\nfile2.js\nfolder/',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('file1.html\nfile2.js\nfolder/');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with path parameter', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'nested-file.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                path: '/my-modules',
+            });
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list /my-modules');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('nested-file.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with account parameter', async () => {
+            mockAddFlag.mockReturnValue('hs list --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'account-specific-files.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs list', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('account-specific-files.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should execute hs list command with both path and account parameters', async () => {
+            mockAddFlag.mockReturnValue('hs list /my-path --account test-account');
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'path-and-account-files.html',
+                stderr: '',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+                path: '/my-path',
+                account: 'test-account',
+            });
+            expect(mockAddFlag).toHaveBeenCalledWith('hs list /my-path', 'account', 'test-account');
+            expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/dir', 'hs list /my-path --account test-account');
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('path-and-account-files.html');
+            expect(result.content[1].text).toBe('');
+        });
+        it('should handle command execution errors', async () => {
+            mockRunCommandInDir.mockRejectedValue(new Error('Command failed'));
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0].text).toContain('Error executing hs list command: Command failed');
+        });
+        it('should handle stderr output', async () => {
+            mockRunCommandInDir.mockResolvedValue({
+                stdout: 'file1.html',
+                stderr: 'Warning: Some warning message',
+            });
+            const result = await tool.handler({
+                absoluteCurrentWorkingDirectory: '/test/dir',
+            });
+            expect(result.content).toHaveLength(2);
+            expect(result.content[0].text).toContain('file1.html');
+            expect(result.content[1].text).toContain('Warning: Some warning message');
+        });
+    });
+});

package/mcp-server/tools/index.d.ts

@@ -1,2 +1,3 @@
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerProjectTools(mcpServer: McpServer): RegisteredTool[];
+export declare function registerCmsTools(mcpServer: McpServer): RegisteredTool[];

package/mcp-server/tools/index.js

@@ -5,6 +5,10 @@ import { DeployProjectTool } from './project/DeployProjectTool.js';
 import { AddFeatureToProjectTool } from './project/AddFeatureToProjectTool.js';
 import { ValidateProjectTool } from './project/ValidateProjectTool.js';
 import { GetConfigValuesTool } from './project/GetConfigValuesTool.js';
+import { DocsSearchTool } from './project/DocsSearchTool.js';
+import { DocFetchTool } from './project/DocFetchTool.js';
+import { HsListTool } from './cms/HsListTool.js';
+import { HsCreateModuleTool } from './cms/HsCreateModuleTool.js';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
@@ -14,5 +18,13 @@ export function registerProjectTools(mcpServer) {
         new AddFeatureToProjectTool(mcpServer).register(),
         new ValidateProjectTool(mcpServer).register(),
         new GetConfigValuesTool(mcpServer).register(),
+        new DocsSearchTool(mcpServer).register(),
+        new DocFetchTool(mcpServer).register(),
+    ];
+}
+export function registerCmsTools(mcpServer) {
+    return [
+        new HsListTool(mcpServer).register(),
+        new HsCreateModuleTool(mcpServer).register(),
     ];
 }

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

@@ -0,0 +1,17 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    docUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docUrl: string;
+}, {
+    docUrl: string;
+}>;
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocFetchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docUrl }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,49 @@
+import z from 'zod';
+import { Tool } from '../../types.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { docUrl } from './constants.js';
+import { http } from '@hubspot/local-dev-lib/http/unauthed';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+const inputSchema = {
+    docUrl,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'fetch-hubspot-doc';
+export class DocFetchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docUrl }) {
+        await trackToolUsage(toolName);
+        try {
+            // Append .md extension to the URL
+            const markdownUrl = `${docUrl}.md`;
+            const response = await http.get({
+                url: markdownUrl,
+            });
+            const content = response.data;
+            if (!content || content.trim().length === 0) {
+                return formatTextContents('Document is empty or contains no content.');
+            }
+            return formatTextContents(content);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error fetching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Fetch HubSpot Developer Documentation (single file)',
+            description: 'Always use this immediately after `search-hubspot-docs` and before creating a plan, writing code, or answering technical questions. This tool retrieves the full, authoritative content of a HubSpot Developer Documentation page from its URL, ensuring responses are accurate, up-to-date, and grounded in the official docs.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,26 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    docsSearchQuery: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docsSearchQuery: string;
+}, {
+    docsSearchQuery: string;
+}>;
+export interface DocsSearchResponse {
+    results: {
+        title: string;
+        content: string;
+        description: string;
+        url: string;
+        score: number;
+    }[];
+}
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocsSearchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,62 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import z from 'zod';
+import { Tool } from '../../types.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { docsSearchQuery } from './constants.js';
+import { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+const inputSchema = {
+    docsSearchQuery,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'search-hubspot-docs';
+export class DocsSearchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docsSearchQuery, }) {
+        await trackToolUsage(toolName, { mode: docsSearchQuery });
+        loadConfig(getConfigPath());
+        const accountId = getAccountId();
+        if (!accountId) {
+            const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
+            return formatTextContents(authErrorMessage);
+        }
+        try {
+            const response = await http.post(accountId, {
+                url: 'dev/docs/llms/v1/docs-search',
+                data: {
+                    query: docsSearchQuery,
+                },
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return formatTextContents('No documentation found for your query.');
+            }
+            const formattedResults = results
+                .map(result => `**${result.title}**\n${result.description}\nURL: ${result.url}\nScore: ${result.score}\n\n${result.content}\n---\n`)
+                .join('\n');
+            const successMessage = `Found ${results.length} documentation results:\n\n${formattedResults}`;
+            return formatTextContents(successMessage);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle different status codes
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error searching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Search HubSpot Developer Documentation',
+            description: 'Use this first whenever you need details about HubSpot APIs, SDKs, integrations, or developer platform features. This searches the official HubSpot Developer Documentation and returns the most relevant pages, each with a URL for use in `fetch-hubspot-doc`. Always follow this with a fetch to get the full, authoritative content before making plans or writing answers.',
+            inputSchema,
+        }, this.handler);
+    }
+}

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

@@ -2,7 +2,7 @@ import { Tool } from '../../types.js';
 import { z } from 'zod';
 import { formatTextContents } from '../../utils/content.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
 import { useV3Api } from '../../../lib/projects/buildAndDeploy.js';
 const inputSchema = {
     platformVersion: z
@@ -16,7 +16,7 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({
     ...inputSchema,
 });
-const toolName = 'get-hubspot-project-feature-config-schema';
+const toolName = 'get-hubspot-feature-config-schema';
 export class GetConfigValuesTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
@@ -26,6 +26,7 @@ export class GetConfigValuesTool extends Tool {
             if (!useV3Api(platformVersion)) {
                 return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
             }
+            loadConfig(getConfigPath());
             const schema = await getIntermediateRepresentationSchema({
                 platformVersion,
                 projectSourceDir: '',

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

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