@bretwardjames/ghp-mcp 0.1.4 → 0.1.5

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @bretwardjames/ghp-mcp@0.1.3 build /home/bretwardjames/IdeaProjects/ghp/packages/mcp
+> @bretwardjames/ghp-mcp@0.1.5 build /home/bretwardjames/IdeaProjects/ghp/packages/mcp
 > tsup src/index.ts --format esm --dts
 
 CLI Building entry: src/index.ts
@@ -7,8 +7,8 @@ CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 52.39 KB
-ESM ⚡️ Build success in 54ms
+ESM dist/index.js 55.56 KB
+ESM ⚡️ Build success in 42ms
 DTS Build start
-DTS ⚡️ Build success in 1637ms
+DTS ⚡️ Build success in 2277ms
 DTS dist/index.d.ts 20.00 B

package/CHANGELOG.md

@@ -1,5 +1,72 @@
 # @bretwardjames/ghp-mcp
 
+## 0.1.5
+
+### Patch Changes
+
+- QA Checkpoint 2026-02-02
+
+  ## @bretwardjames/ghp-core
+
+  ### Security
+
+  - Fix command injection vulnerabilities by using `spawn()` with array arguments instead of `exec()` with string interpolation
+  - Add `shell-utils` module with `shellEscape()`, `validateNumericInput()`, `validateSafeString()`, `validateUrl()`
+
+  ### Error Handling
+
+  - Add `GitError` class that captures command, stderr, exitCode, and cwd for debugging
+  - Remove silent catch blocks from git-utils functions - errors now propagate properly
+
+  ### New Features
+
+  - Add retry logic for transient GitHub API failures (`withRetry`, `isTransientError`, `calculateBackoffDelay`)
+  - Add configurable hook failure behavior (`OnFailureBehavior`: 'fail-fast' | 'continue')
+  - Support per-event hook settings via `eventDefaults` in event-hooks.json
+
+  ### Bug Fixes
+
+  - Fix repository field in GraphQL queries to return full `owner/repo` format
+
+  ## @bretwardjames/ghp-cli
+
+  ### New Features
+
+  - Add centralized exit utility with cleanup handler support (`registerCleanupHandler`, `exit`)
+  - Add validation module for enum flags, mutual exclusion, and numeric bounds
+
+  ### Bug Fixes
+
+  - Fix `deepMergeObjects` to recursively merge nested config at all depths
+  - Fix type safety issues - replace `any` types with `SortableFieldValue` in sorting logic
+  - Fix `planCommand` parameter type from `any` to `Command | PlanOptions`
+
+  ### Documentation
+
+  - Document all hook events (pre-pr, pr-creating) and template variables
+  - Update create-pr command to mention committing ragtime branch context
+
+  ### Test Coverage
+
+  - Add 25 tests for CLI commands (start, add-issue)
+  - Add 21 tests for exit utility
+  - Add 34 tests for config operations
+  - Add 33 tests for validation module
+
+  ## @bretwardjames/ghp-mcp
+
+  ### Security
+
+  - Fix command injection in worktree operations
+
+  ### Test Coverage
+
+  - Add 9 tests for tool registry
+
+- Updated dependencies
+- Updated dependencies [fbe1b3c]
+  - @bretwardjames/ghp-core@0.6.0
+
 ## 0.1.4
 
 ### Patch Changes

package/README.md

@@ -65,13 +65,14 @@ The server uses the same GitHub authentication as the CLI. Run `ghp auth` to aut
 
 | Tool | Description |
 |------|-------------|
-| `work` | View items assigned to you |
+| `get_my_work` | View items assigned to you |
 | `get_project_board` | View project board/items (with optional status/assignee filters) |
 | `create_issue` | Create a new issue and add to project |
 | `update_issue` | Update an issue's title and/or body |
 | `move` | Move an issue to a different status |
 | `done` | Mark an issue as done |
 | `start` | Start working on an issue |
+| `create_worktree` | Create a worktree for parallel development |
 | `assign` | Assign users to an issue |
 | `comment` | Add a comment to an issue |
 | `set_field` | Set a field value on an issue |
@@ -80,7 +81,7 @@ The server uses the same GitHub authentication as the CLI. Run `ghp auth` to aut
 
 ```
 AI: "Show me my current work items"
-→ Uses the `work` tool
+→ Uses the `get_my_work` tool
 
 AI: "Create a bug report for the login timeout issue"
 → Uses `create_issue` with appropriate title/body

package/dist/index.js

@@ -120,7 +120,7 @@ function createTokenProvider() {
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 
 // src/tools/work.ts
 var work_exports = {};
@@ -671,6 +671,11 @@ __export(start_exports, {
   register: () => register5
 });
 import * as z5 from "zod";
+import {
+  getCurrentBranch,
+  executeHooksForEvent,
+  hasHooksForEvent
+} from "@bretwardjames/ghp-core";
 var meta5 = {
   name: "start_work",
   category: "action"
@@ -771,16 +776,7 @@ WARNING: This issue is blocked by: ${openBlockers.map((b) => `#${b.number} (${b.
           statusField.fieldId,
           inProgressOption.id
         );
-        if (success) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Started work on issue #${issue} "${item.title}" - status set to "${inProgressOption.name}".${blockingWarning}`
-              }
-            ]
-          };
-        } else {
+        if (!success) {
           return {
             content: [
               {
@@ -791,6 +787,43 @@ WARNING: This issue is blocked by: ${openBlockers.map((b) => `#${b.number} (${b.
             isError: true
           };
         }
+        let hookInfo = "";
+        if (hasHooksForEvent("issue-started")) {
+          const branch = await getCurrentBranch() || "";
+          const payload = {
+            repo: `${repo.owner}/${repo.name}`,
+            issue: {
+              number: issue,
+              title: item.title,
+              body: "",
+              // Body not available from ProjectItem
+              url: `https://github.com/${repo.owner}/${repo.name}/issues/${issue}`
+            },
+            branch
+          };
+          const hooksConfig = loadHooksConfig();
+          const hookResults = await executeHooksForEvent("issue-started", payload, {
+            onFailure: hooksConfig.onFailure
+          });
+          const successCount = hookResults.filter((r) => r.success).length;
+          const failCount = hookResults.length - successCount;
+          if (hookResults.length > 0) {
+            hookInfo = `
+
+Hooks: ${successCount} succeeded`;
+            if (failCount > 0) {
+              hookInfo += `, ${failCount} failed`;
+            }
+          }
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Started work on issue #${issue} "${item.title}" - status set to "${inProgressOption.name}".${blockingWarning}${hookInfo}`
+            }
+          ]
+        };
       } catch (error) {
         return {
           content: [
@@ -813,6 +846,10 @@ __export(add_issue_exports, {
   register: () => register6
 });
 import * as z6 from "zod";
+import {
+  executeHooksForEvent as executeHooksForEvent2,
+  hasHooksForEvent as hasHooksForEvent2
+} from "@bretwardjames/ghp-core";
 var meta6 = {
   name: "create_issue",
   category: "action"
@@ -910,6 +947,31 @@ Warning: Status "${status}" not found. Valid options: ${validStatuses}`;
             }
           }
         }
+        if (hasHooksForEvent2("issue-created")) {
+          const payload = {
+            repo: `${repo.owner}/${repo.name}`,
+            issue: {
+              number: result.number,
+              title,
+              body: body || "",
+              url: issueUrl
+            }
+          };
+          const hooksConfig = loadHooksConfig();
+          const hookResults = await executeHooksForEvent2("issue-created", payload, {
+            onFailure: hooksConfig.onFailure
+          });
+          const successCount = hookResults.filter((r) => r.success).length;
+          const failCount = hookResults.length - successCount;
+          if (hookResults.length > 0) {
+            message += `
+
+Hooks: ${successCount} succeeded`;
+            if (failCount > 0) {
+              message += `, ${failCount} failed`;
+            }
+          }
+        }
         return {
           content: [
             {
@@ -1348,7 +1410,8 @@ __export(worktree_exports, {
   register: () => register11
 });
 import * as z11 from "zod";
-import { execSync } from "child_process";
+import { spawnSync } from "child_process";
+import { validateNumericInput } from "@bretwardjames/ghp-core";
 var meta11 = {
   name: "create_worktree",
   category: "action"
@@ -1404,18 +1467,23 @@ function register11(server, context) {
         };
       }
       try {
-        let cmd = `ghp start ${issue} --parallel -fd --force`;
+        const safeIssue = validateNumericInput(issue, "issue");
+        const args = ["start", String(safeIssue), "--parallel", "-fd", "--force"];
         if (worktreePath) {
-          cmd += ` --worktree-path "${worktreePath}"`;
+          args.push("--worktree-path", worktreePath);
         }
         if (spawnSubagent) {
-          cmd += " --spawn-subagent";
+          args.push("--spawn-subagent");
         }
-        const output = execSync(cmd, {
+        const result = spawnSync("ghp", args, {
           encoding: "utf-8",
           cwd: process.cwd(),
           env: process.env
         });
+        if (result.status !== 0) {
+          throw new Error(result.stderr || `ghp start failed with exit code ${result.status}`);
+        }
+        const output = result.stdout;
         const directive = spawnSubagent ? parseSpawnDirective(output) : null;
         const response = {
           content: [
@@ -1476,7 +1544,7 @@ var DEFAULT_MCP_CONFIG = {
 };
 function getRepoRoot() {
   try {
-    return execSync2("git rev-parse --show-toplevel", {
+    return execSync("git rev-parse --show-toplevel", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -1528,6 +1596,23 @@ function loadMcpConfig() {
   }
   return result;
 }
+function loadHooksConfig() {
+  const userConfigPath = join(homedir(), ".config", "ghp-cli", "config.json");
+  const userConfig = loadConfigFile(userConfigPath);
+  const repoRoot = getRepoRoot();
+  const workspaceConfigPath = repoRoot ? join(repoRoot, ".ghp", "config.json") : null;
+  const workspaceConfig = workspaceConfigPath ? loadConfigFile(workspaceConfigPath) : null;
+  const result = { onFailure: "fail-fast" };
+  const userHooks = userConfig?.hooks;
+  if (userHooks?.onFailure === "fail-fast" || userHooks?.onFailure === "continue") {
+    result.onFailure = userHooks.onFailure;
+  }
+  const workspaceHooks = workspaceConfig?.hooks;
+  if (workspaceHooks?.onFailure === "fail-fast" || workspaceHooks?.onFailure === "continue") {
+    result.onFailure = workspaceHooks.onFailure;
+  }
+  return result;
+}
 function isToolEnabled(tool, config) {
   const toolsConfig = config.tools || DEFAULT_MCP_CONFIG.tools;
   const disabledTools = new Set(config.disabledTools || []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bretwardjames/ghp-mcp",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "MCP server for ghp (GitHub Projects)",
   "publishConfig": {
     "access": "public"
@@ -29,12 +29,13 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "zod": "^3.22.0",
-    "@bretwardjames/ghp-core": "0.5.0"
+    "@bretwardjames/ghp-core": "0.6.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
     "tsup": "^8.0.0",
-    "typescript": "^5.3.2"
+    "typescript": "^5.3.2",
+    "vitest": "^3.0.5"
   },
   "engines": {
     "node": ">=18"
@@ -42,6 +43,8 @@
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts",
     "dev": "tsup src/index.ts --format esm --dts --watch",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }

package/src/tool-registry.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Tests for the tool registry
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock fs
+vi.mock('fs', () => ({
+    existsSync: vi.fn(() => false),
+    readFileSync: vi.fn(),
+}));
+
+// Mock os
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/home/testuser'),
+}));
+
+// Mock child_process
+vi.mock('child_process', () => ({
+    execSync: vi.fn(() => '/test/repo'),
+    exec: vi.fn(),
+}));
+
+// Mock util for promisify
+vi.mock('util', async () => {
+    const actual = await vi.importActual<typeof import('util')>('util');
+    return {
+        ...actual,
+        promisify: vi.fn(() => vi.fn()),
+    };
+});
+
+// Mock @bretwardjames/ghp-core
+vi.mock('@bretwardjames/ghp-core', () => ({
+    getCurrentBranch: vi.fn(),
+    executeHooksForEvent: vi.fn(() => []),
+    hasHooksForEvent: vi.fn(() => false),
+    branchExists: vi.fn(),
+    createBranch: vi.fn(),
+    checkoutBranch: vi.fn(),
+    generateBranchName: vi.fn(),
+    createWorktree: vi.fn(),
+    removeWorktree: vi.fn(),
+    listWorktrees: vi.fn(),
+}));
+
+// Import after mocks
+import { loadMcpConfig, getToolList, registerEnabledTools } from './tool-registry.js';
+import { existsSync, readFileSync } from 'fs';
+import { execSync } from 'child_process';
+
+describe('tool-registry', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('loadMcpConfig', () => {
+        it('should return default config when no config files exist', () => {
+            vi.mocked(existsSync).mockReturnValue(false);
+
+            const config = loadMcpConfig();
+
+            expect(config).toEqual({
+                tools: {
+                    read: true,
+                    action: true,
+                },
+                disabledTools: [],
+            });
+        });
+
+        it('should merge user config with defaults', () => {
+            vi.mocked(existsSync).mockImplementation((path) => {
+                return String(path).includes('.config/ghp-cli');
+            });
+            vi.mocked(readFileSync).mockReturnValue(JSON.stringify({
+                mcp: {
+                    tools: { read: false },
+                    disabledTools: ['create_issue'],
+                },
+            }));
+
+            const config = loadMcpConfig();
+
+            expect(config.tools?.read).toBe(false);
+            expect(config.tools?.action).toBe(true); // from defaults
+            expect(config.disabledTools).toContain('create_issue');
+        });
+
+        it('should prefer workspace config over user config', () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (String(path).includes('.ghp/config.json')) {
+                    return JSON.stringify({
+                        mcp: { tools: { action: false } },
+                    });
+                }
+                return JSON.stringify({
+                    mcp: { tools: { action: true } },
+                });
+            });
+
+            const config = loadMcpConfig();
+
+            expect(config.tools?.action).toBe(false); // workspace wins
+        });
+
+        it('should handle JSON with comments', () => {
+            vi.mocked(existsSync).mockImplementation((path) => {
+                return String(path).includes('.config/ghp-cli');
+            });
+            vi.mocked(readFileSync).mockReturnValue(`{
+                // This is a comment
+                "mcp": {
+                    /* Block comment */
+                    "tools": { "read": false }
+                }
+            }`);
+
+            const config = loadMcpConfig();
+
+            expect(config.tools?.read).toBe(false);
+        });
+
+        it('should handle missing git repo gracefully', () => {
+            vi.mocked(execSync).mockImplementation(() => {
+                throw new Error('Not a git repo');
+            });
+            vi.mocked(existsSync).mockReturnValue(false);
+
+            const config = loadMcpConfig();
+
+            // Should still return defaults
+            expect(config.tools?.read).toBe(true);
+            expect(config.tools?.action).toBe(true);
+        });
+    });
+
+    describe('getToolList', () => {
+        it('should return all registered tools with their categories', () => {
+            const tools = getToolList();
+
+            // Should have multiple tools
+            expect(tools.length).toBeGreaterThan(0);
+
+            // Each tool should have name and category
+            for (const tool of tools) {
+                expect(tool).toHaveProperty('name');
+                expect(tool).toHaveProperty('category');
+                expect(['read', 'action']).toContain(tool.category);
+            }
+
+            // Check some expected tools exist
+            const toolNames = tools.map(t => t.name);
+            expect(toolNames).toContain('create_issue');
+            expect(toolNames).toContain('get_my_work'); // actual tool name
+        });
+    });
+
+    describe('registerEnabledTools', () => {
+        it('should register tools based on config', () => {
+            const mockServer = {
+                registerTool: vi.fn(),
+            };
+            const mockContext = {
+                ensureAuthenticated: vi.fn(),
+                getRepo: vi.fn(),
+                api: {},
+            };
+
+            // All categories enabled
+            registerEnabledTools(mockServer as any, mockContext as any, {
+                tools: { read: true, action: true },
+                disabledTools: [],
+            });
+
+            // Should have registered multiple tools
+            expect(mockServer.registerTool).toHaveBeenCalled();
+        });
+
+        it('should skip disabled categories', () => {
+            const mockServer = {
+                registerTool: vi.fn(),
+            };
+            const mockContext = {
+                ensureAuthenticated: vi.fn(),
+                getRepo: vi.fn(),
+                api: {},
+            };
+
+            // Only read category enabled
+            registerEnabledTools(mockServer as any, mockContext as any, {
+                tools: { read: true, action: false },
+                disabledTools: [],
+            });
+
+            // Get the names of registered tools
+            const registeredNames = mockServer.registerTool.mock.calls.map(
+                (call) => call[0]
+            );
+
+            // Should only have read tools (list_work_items, view_plan)
+            // No action tools (create_issue, move_issue, etc.)
+            expect(registeredNames).not.toContain('create_issue');
+            expect(registeredNames).not.toContain('move_issue');
+        });
+
+        it('should skip specifically disabled tools', () => {
+            const mockServer = {
+                registerTool: vi.fn(),
+            };
+            const mockContext = {
+                ensureAuthenticated: vi.fn(),
+                getRepo: vi.fn(),
+                api: {},
+            };
+
+            // All categories enabled but specific tool disabled
+            registerEnabledTools(mockServer as any, mockContext as any, {
+                tools: { read: true, action: true },
+                disabledTools: ['create_issue'],
+            });
+
+            const registeredNames = mockServer.registerTool.mock.calls.map(
+                (call) => call[0]
+            );
+
+            expect(registeredNames).not.toContain('create_issue');
+            // Other action tools should still be registered
+            expect(registeredNames).toContain('move_issue');
+        });
+    });
+});

package/src/tool-registry.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ServerContext } from './server.js';
 import type { ToolCategory, McpConfig, McpToolsConfig } from './types.js';
+import type { OnFailureBehavior } from '@bretwardjames/ghp-core';
 import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -142,6 +143,45 @@ export function loadMcpConfig(): McpConfig {
     return result;
 }
 
+/**
+ * Hooks configuration for onFailure behavior
+ */
+export interface HooksConfig {
+    onFailure: OnFailureBehavior;
+}
+
+/**
+ * Load hooks configuration from user and workspace config files.
+ * Workspace config takes precedence over user config.
+ */
+export function loadHooksConfig(): HooksConfig {
+    // User config: ~/.config/ghp-cli/config.json
+    const userConfigPath = join(homedir(), '.config', 'ghp-cli', 'config.json');
+    const userConfig = loadConfigFile(userConfigPath);
+
+    // Workspace config: <repo-root>/.ghp/config.json
+    const repoRoot = getRepoRoot();
+    const workspaceConfigPath = repoRoot ? join(repoRoot, '.ghp', 'config.json') : null;
+    const workspaceConfig = workspaceConfigPath ? loadConfigFile(workspaceConfigPath) : null;
+
+    // Default
+    const result: HooksConfig = { onFailure: 'fail-fast' };
+
+    // Apply user config
+    const userHooks = userConfig?.hooks as { onFailure?: string } | undefined;
+    if (userHooks?.onFailure === 'fail-fast' || userHooks?.onFailure === 'continue') {
+        result.onFailure = userHooks.onFailure;
+    }
+
+    // Apply workspace config (takes precedence)
+    const workspaceHooks = workspaceConfig?.hooks as { onFailure?: string } | undefined;
+    if (workspaceHooks?.onFailure === 'fail-fast' || workspaceHooks?.onFailure === 'continue') {
+        result.onFailure = workspaceHooks.onFailure;
+    }
+
+    return result;
+}
+
 /**
  * Get list of all tool names and categories
  */

package/src/tools/add-issue.ts

@@ -2,6 +2,7 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import * as z from 'zod';
 import type { ServerContext } from '../server.js';
 import type { ToolMeta } from '../types.js';
+import { loadHooksConfig } from '../tool-registry.js';
 import {
     executeHooksForEvent,
     hasHooksForEvent,
@@ -132,7 +133,10 @@ export function register(server: McpServer, context: ServerContext): void {
                         },
                     };
 
-                    const hookResults = await executeHooksForEvent('issue-created', payload);
+                    const hooksConfig = loadHooksConfig();
+                    const hookResults = await executeHooksForEvent('issue-created', payload, {
+                        onFailure: hooksConfig.onFailure,
+                    });
                     const successCount = hookResults.filter(r => r.success).length;
                     const failCount = hookResults.length - successCount;
 

package/src/tools/start.ts

@@ -2,6 +2,7 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import * as z from 'zod';
 import type { ServerContext } from '../server.js';
 import type { ToolMeta } from '../types.js';
+import { loadHooksConfig } from '../tool-registry.js';
 import {
     getCurrentBranch,
     executeHooksForEvent,
@@ -162,7 +163,10 @@ export function register(server: McpServer, context: ServerContext): void {
                         branch,
                     };
 
-                    const hookResults = await executeHooksForEvent('issue-started', payload);
+                    const hooksConfig = loadHooksConfig();
+                    const hookResults = await executeHooksForEvent('issue-started', payload, {
+                        onFailure: hooksConfig.onFailure,
+                    });
                     const successCount = hookResults.filter(r => r.success).length;
                     const failCount = hookResults.length - successCount;
 

package/src/tools/worktree.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import * as z from 'zod';
-import { execSync } from 'child_process';
+import { spawnSync } from 'child_process';
+import { validateNumericInput } from '@bretwardjames/ghp-core';
 import type { ServerContext } from '../server.js';
 import type { ToolMeta } from '../types.js';
 
@@ -102,22 +103,32 @@ export function register(server: McpServer, context: ServerContext): void {
             }
 
             try {
-                // Build the CLI command
-                let cmd = `ghp start ${issue} --parallel -fd --force`;
+                // Validate issue number to prevent injection
+                const safeIssue = validateNumericInput(issue, 'issue');
+
+                // Build CLI args as array to prevent command injection
+                // Using spawnSync with array args avoids shell entirely
+                const args = ['start', String(safeIssue), '--parallel', '-fd', '--force'];
                 if (worktreePath) {
-                    cmd += ` --worktree-path "${worktreePath}"`;
+                    args.push('--worktree-path', worktreePath);
                 }
                 if (spawnSubagent) {
-                    cmd += ' --spawn-subagent';
+                    args.push('--spawn-subagent');
                 }
 
                 // Execute the CLI command
-                const output = execSync(cmd, {
+                const result = spawnSync('ghp', args, {
                     encoding: 'utf-8',
                     cwd: process.cwd(),
                     env: process.env,
                 });
 
+                if (result.status !== 0) {
+                    throw new Error(result.stderr || `ghp start failed with exit code ${result.status}`);
+                }
+
+                const output = result.stdout;
+
                 // Parse the spawn directive if present
                 const directive = spawnSubagent ? parseSpawnDirective(output) : null;
 

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['src/**/*.test.ts'],
+        coverage: {
+            provider: 'v8',
+            include: ['src/**/*.ts'],
+            exclude: ['src/**/*.test.ts', 'src/index.ts'],
+        },
+    },
+});