Fix plop template for non-interactive environments

Fixes issue where plop generator fails with readline errors when run from
non-TTY environments like AI agents, CI, or piped scripts.

## Changes

### plopfile.cjs
- Added comprehensive JSDoc comments explaining both interactive and non-interactive usage
- Documented command-line argument syntax: `npx plop create-tool "ToolName" "tool_name_tool"`
- Fixed tool registration to include `{ httpRequest }` parameter

### plop-templates/tool.hbs
- Fixed execute() method signature to include `accessToken: string` parameter
- Added proper `annotations` property (title, readOnlyHint, openWorldHint, etc.)
- Replaced invalid syntax with valid TypeScript (throw Error vs invalid ellipsis)
- Updated example to use correct API: `mapboxApiEndpoint` (not MAPBOX_API_ENDPOINT)
- Added comprehensive TODO comments with proper code structure

### plop-templates/tool.test.hbs
- Migrated from Jest to Vitest (describe, it, expect, vi)
- Updated imports to use current test utilities (setupHttpRequest, assertHeadersSent)
- Fixed import paths to match current structure
- Added copyright header
- Added MAPBOX_ACCESS_TOKEN env var setup
- Added three test cases: custom header, structured content, API errors

### CLAUDE.md
- Documented both interactive and non-interactive modes
- Added clear examples and usage notes
- Emphasized non-interactive mode for AI agents to avoid readline errors

## Testing

Verified generator works in non-interactive mode:
```bash
npx plop create-tool "Example" "example_tool"
```

Generated files:
- ExampleTool.ts with proper structure and annotations
- ExampleTool.input.schema.ts
- ExampleTool.output.schema.ts
- ExampleTool.test.ts with vitest tests
- Auto-updates toolRegistry.ts with correct registration

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: mattpodwysocki

CLAUDE.md

@@ -64,10 +64,19 @@ npm run inspect:build    # Test with MCP inspector
 ### Creating a New Tool
 
 ```bash
-npx plop create-tool     # Interactive tool scaffolding
-# Provide tool name without suffix (e.g., "Search" creates "SearchTool")
+# Interactive mode (requires TTY - use in terminal):
+npx plop create-tool
+
+# Non-interactive mode (for AI agents, CI, or scripts):
+npx plop create-tool "ToolName" "tool_name_tool"
+
+# Example:
+npx plop create-tool "Search" "search_tool"
+# Creates SearchTool in src/tools/search-tool/ with schemas and tests
 ```
 
+**Note**: When running from AI agents or non-TTY environments (like Claude Code), always use non-interactive mode with command-line arguments to avoid readline errors.
+
 ### Pre-commit
 
 - Husky hooks auto-run linting and formatting

plop-templates/tool.hbs

@@ -16,6 +16,13 @@ export class {{pascalCase name}}Tool extends MapboxApiBasedTool<
 > {
   name = '{{toolName}}';
   description = 'TODO: Add tool description here.';
+  annotations = {
+    title: '{{pascalCase name}} Tool',
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  };
 
   constructor({ httpRequest }: { httpRequest: HttpRequest }) {
     super({
@@ -28,16 +35,29 @@ export class {{pascalCase name}}Tool extends MapboxApiBasedTool<
   /**
    * Execute the tool logic
    * @param input - Validated input from {{pascalCase name}}InputSchema
+   * @param accessToken - Mapbox access token
    * @returns CallToolResult with structured output
    */
   protected async execute(
-    input: z.infer<typeof {{pascalCase name}}InputSchema>
+    input: z.infer<typeof {{pascalCase name}}InputSchema>,
+    accessToken: string
   ): Promise<any> {
-    ... write your logic here ...
-    // e.g.:
-    // const url = `${MapboxApiBasedTool.MAPBOX_API_ENDPOINT}...?access_token=${MapboxApiBasedTool.MAPBOX_ACCESS_TOKEN}`;
-    // const response = await fetch(url);
-    // const data = await response.json();
-    // return data;
+    // TODO: Implement your tool logic here
+    // Example:
+    // const url = `${MapboxApiBasedTool.mapboxApiEndpoint}your-api-endpoint?access_token=${accessToken}`;
+    // const response = await this.httpRequest(url);
+    // if (!response.ok) {
+    //   return {
+    //     content: [{ type: 'text', text: `Error: ${response.statusText}` }],
+    //     isError: true
+    //   };
+    // }
+    // const data = (await response.json()) as {{pascalCase name}}Output;
+    // return {
+    //   content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    //   structuredContent: data,
+    //   isError: false
+    // };
+    throw new Error('Not implemented');
   }
 }

plop-templates/tool.test.hbs

@@ -1,31 +1,69 @@
-import { {{pascalCase name}}Tool } from '../{{kebabCase name}}-tool/{{pascalCase name}}Tool.js';
-import { setupFetch, assertHeadersSent } from '../../utils/requestUtils.test-helpers.js';
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+
+process.env.MAPBOX_ACCESS_TOKEN =
+  'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.signature';
+
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import {
+  setupHttpRequest,
+  assertHeadersSent
+} from '../../utils/httpPipelineUtils.js';
+import { {{pascalCase name}}Tool } from '../../../src/tools/{{kebabCase name}}-tool/{{pascalCase name}}Tool.js';
+
+// TODO: Add sample response data
+const sampleResponse = {
+  // Add expected API response structure here
+};
 
 describe('{{pascalCase name}}Tool', () => {
   afterEach(() => {
-    jest.restoreAllMocks();
+    vi.restoreAllMocks();
   });
 
   it('sends custom header', async () => {
-    const mockFetch = setupFetch();
-    await new {{pascalCase name}}Tool().run({...});
-    assertHeadersSent(mockFetch);
+    const { httpRequest, mockHttpRequest } = setupHttpRequest({
+      json: async () => sampleResponse
+    });
+
+    await new {{pascalCase name}}Tool({ httpRequest }).run({
+      // TODO: Add required input parameters
+    });
+
+    assertHeadersSent(mockHttpRequest);
   });
 
-  it('handles fetch errors gracefully', async () => {
-    const mockFetch = setupFetch({
+  it('returns structured content for valid input', async () => {
+    const { httpRequest } = setupHttpRequest({
+      json: async () => sampleResponse
+    });
+
+    const tool = new {{pascalCase name}}Tool({ httpRequest });
+    const result = await tool.run({
+      // TODO: Add required input parameters
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.structuredContent).toBeDefined();
+  });
+
+  it('handles API errors gracefully', async () => {
+    const { httpRequest } = setupHttpRequest({
       ok: false,
-      status: 404,
-      statusText: 'Not Found'
+      status: 400,
+      statusText: 'Bad Request',
+      text: async () => JSON.stringify({ message: 'Invalid parameters' })
     });
 
-    const result = await new {{pascalCase name}}Tool().run({...});
+    const tool = new {{pascalCase name}}Tool({ httpRequest });
+    const result = await tool.run({
+      // TODO: Add required input parameters
+    });
 
     expect(result.isError).toBe(true);
     expect(result.content[0]).toMatchObject({
       type: 'text',
-      text: 'Request failed with status 404: Not Found'
+      text: expect.stringContaining('Invalid parameters')
     });
-    assertHeadersSent(mockFetch);
   });
 });

plopfile.cjs

@@ -1,3 +1,24 @@
+/**
+ * Plop generator for creating new MCP tools.
+ *
+ * Usage:
+ *   Interactive mode (requires TTY):
+ *     npx plop create-tool
+ *
+ *   Non-interactive mode (for CI, scripts, or non-TTY environments):
+ *     npx plop create-tool "ToolName" "tool_name_tool"
+ *
+ * Example:
+ *   npx plop create-tool "Search" "search_tool"
+ *
+ * This generates:
+ *   - src/tools/search-tool/SearchTool.ts
+ *   - src/tools/search-tool/SearchTool.input.schema.ts
+ *   - src/tools/search-tool/SearchTool.output.schema.ts
+ *   - test/tools/search-tool/SearchTool.test.ts
+ *   - Updates src/tools/toolRegistry.ts
+ *   - Updates README.md
+ */
 module.exports = function (plop) {
     plop.setGenerator('create-tool', {
         description: 'Generate a TypeScript class and its test',
@@ -6,7 +27,7 @@ module.exports = function (plop) {
                 type: 'input',
                 name: 'name',
                 message: 'Tool class name without suffix using PascalCase e.g. Search:',
-            },            
+            },
             {
                 type: 'input',
                 name: 'toolName',
@@ -44,7 +65,7 @@ module.exports = function (plop) {
                 type: 'append',
                 path: 'src/tools/toolRegistry.ts',
                 pattern: /(\/\/ INSERT NEW TOOL INSTANCE HERE)/,
-                template: '  new {{pascalCase name}}Tool(),',
+                template: '  new {{pascalCase name}}Tool({ httpRequest }),',
             },
             {
                 type: 'append',