@popoverai/dotrequirements 0.22.0 → 0.24.0

package/dist/mcp/index.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { loadAllRequirements } from './requirements.js';
-import { discoverProjects, resolveProject, } from '../utils/project-discovery.js';
-import { getCredentialsFromEnv } from '../utils/project-settings.js';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { handleDebugMcpEnvironment, handleSearchRequirements, handleListAllRequirements, handleListUntestedRequirements, handleGetRequirement, handleGetRequirementsByTest, handleGetTestsByRequirement, handleGetRequirementCoverage, handleGetProjectCoverageSummary, handleCreateRequirementDocument, handleValidateRequirements, handlePushRequirements, handleStyleCheck, handleReviewTest, } from './handlers/index.js';
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { loadAllRequirements, } from "../requirements/index.js";
+import { discoverProjects, resolveProject, } from "../utils/project-discovery.js";
+import { getCredentialsFromEnv } from "../utils/project-settings.js";
+import { handleCreateRequirementDocument, handleDebugMcpEnvironment, handleGetRequirement, handleGetRequirementsByTest, handleGetTestsByRequirement, handleList, handlePushRequirements, handleReport, handleReviewTest, handleSearchRequirements, handleStyleCheck, handleValidateRequirements, } from "./handlers/index.js";
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const packageJson = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
 const VERSION = packageJson.version;
 // Get project paths from environment variables
 // Supports both PROJ_* pattern (Antigravity) and REQUIREMENTS_DIR fallback
@@ -20,7 +20,7 @@ function getProjectPathsFromEnv() {
     const projects = new Map();
     // Check for PROJ_* env vars (project ID -> path mapping)
     for (const [key, value] of Object.entries(process.env)) {
-        if (key.startsWith('PROJ_') && value) {
+        if (key.startsWith("PROJ_") && value) {
             const projectId = key.substring(5); // Remove 'PROJ_' prefix
             projects.set(projectId, value);
         }
@@ -32,27 +32,26 @@ const WORKSPACE_ROOT = process.env.REQUIREMENTS_DIR || process.cwd();
 const PROJECT_PATHS = getProjectPathsFromEnv();
 // Parse --auth-from-env flag for CI/CD environments
 // When set, credentials are read from DOTREQ_PROJECT_ID and DOTREQ_PROJECT_SECRET env vars
-const USE_ENV_AUTH = process.argv.includes('--auth-from-env');
-// Cache for loaded requirements (refreshed on each tool call for now)
-let cachedRequirements = new Map();
+const USE_ENV_AUTH = process.argv.includes("--auth-from-env");
 let cachedDiscoveryResult = null;
+// Requirements are loaded fresh on every call. A long-lived in-memory cache
+// silently served stale data when .requirements/*.md files were created or
+// edited mid-session, which is the primary authoring workflow the MCP server
+// is meant to support. If this ever becomes a measured performance concern,
+// invalidate via directory mtime rather than reintroducing a lifetime cache.
 async function getRequirements(projectId) {
     const project = await getProjectFromDiscovery(projectId);
-    const cacheKey = project.projectId;
-    if (!cachedRequirements.has(cacheKey)) {
-        const { flattened } = await loadAllRequirements(project.path);
-        cachedRequirements.set(cacheKey, flattened);
-    }
-    return cachedRequirements.get(cacheKey);
+    const { flattened } = await loadAllRequirements(project.path);
+    return flattened;
 }
 async function getProjectFromDiscovery(projectId) {
-    const { isConfiguredProject } = await import('../utils/project-discovery.js');
+    const { isConfiguredProject } = await import("../utils/project-discovery.js");
     // If --auth-from-env flag is set, use credentials from environment variables
     // This is the explicit opt-in for CI/CD environments
     if (USE_ENV_AUTH) {
         const envCredentials = getCredentialsFromEnv();
         if (!envCredentials) {
-            throw new Error('--auth-from-env flag requires DOTREQ_PROJECT_ID and DOTREQ_PROJECT_SECRET environment variables to be set');
+            throw new Error("--auth-from-env flag requires DOTREQ_PROJECT_ID and DOTREQ_PROJECT_SECRET environment variables to be set");
         }
         // Return a synthetic project using env credentials and workspace root
         return {
@@ -65,7 +64,7 @@ async function getProjectFromDiscovery(projectId) {
     if (PROJECT_PATHS.size > 0) {
         const projects = [];
         // Validate all env var projects
-        for (const [id, path] of PROJECT_PATHS.entries()) {
+        for (const [, path] of PROJECT_PATHS.entries()) {
             const project = isConfiguredProject(path);
             if (project) {
                 projects.push(project);
@@ -74,15 +73,15 @@ async function getProjectFromDiscovery(projectId) {
         // Build discovery result from env var projects
         if (projects.length === 0) {
             cachedDiscoveryResult = {
-                type: 'none',
-                message: 'No valid dotrequirements projects found in PROJ_* environment variables',
+                type: "none",
+                message: "No valid dotrequirements projects found in PROJ_* environment variables",
             };
         }
         else if (projects.length === 1) {
-            cachedDiscoveryResult = { type: 'single', project: projects[0] };
+            cachedDiscoveryResult = { type: "single", project: projects[0] };
         }
         else {
-            cachedDiscoveryResult = { type: 'multiple', projects };
+            cachedDiscoveryResult = { type: "multiple", projects };
         }
         return resolveProject(cachedDiscoveryResult, projectId);
     }
@@ -92,175 +91,155 @@ async function getProjectFromDiscovery(projectId) {
     }
     return resolveProject(cachedDiscoveryResult, projectId);
 }
-// Invalidate cache (call before operations that should see fresh data)
-// Exported for testing
+// Invalidate the project-discovery cache. Requirements are no longer cached,
+// so this only resets discovery state. Exported for testing.
 export function invalidateCache() {
-    cachedRequirements.clear();
     cachedDiscoveryResult = null;
 }
 // Tool definitions
 const tools = [
     {
-        name: 'debug_mcp_environment',
-        description: 'DEBUG TOOL: Returns diagnostic information about the MCP server environment (working directory, env vars, etc.)',
+        name: "debug_mcp_environment",
+        description: "DEBUG TOOL: Returns diagnostic information about the MCP server environment (working directory, env vars, etc.)",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {},
             required: [],
         },
     },
     {
-        name: 'search_requirements',
-        description: 'Search requirements by text or regex query. Searches requirement IDs, content, and labels. Returns matching requirements with their full context.',
+        name: "search_requirements",
+        description: "Search requirements by text or regex query. Searches requirement IDs, content, and labels. Returns matching requirements with their full context.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 query: {
-                    type: 'string',
-                    description: 'Text or regex pattern to search for in requirement IDs, content, or labels',
+                    type: "string",
+                    description: "Text or regex pattern to search for in requirement IDs, content, or labels",
                 },
                 useRegex: {
-                    type: 'boolean',
-                    description: 'If true, treat query as a regular expression (default: false)',
+                    type: "boolean",
+                    description: "If true, treat query as a regular expression (default: false)",
                 },
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to search (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: Specify which project to search (required when multiple projects exist)",
                 },
             },
-            required: ['query'],
+            required: ["query"],
         },
     },
     {
-        name: 'get_requirement',
+        name: "get_requirement",
         description: 'Get a requirement and all its children, including test coverage information. Accepts any requirement path (e.g., "REQ-123" returns the root and all children, "REQ-123.0" returns that node and its children). Shows which tests reference this requirement and includes the test code.',
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 id: {
-                    type: 'string',
+                    type: "string",
                     description: 'The requirement ID or path (e.g., "REQ-123" for root, "REQ-123.0" for child)',
                 },
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to search (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: Specify which project to search (required when multiple projects exist)",
                 },
             },
-            required: ['id'],
+            required: ["id"],
         },
     },
     {
-        name: 'list_untested_requirements',
-        description: 'List all requirements that have no test references. Compares requirements in .requirements/ files against requirement() calls in the codebase.',
+        name: "list_requirements",
+        description: "List requirements in the workspace. Defaults to every root requirement (summary of IDs and content with child counts). Set untested to true to filter to only the root requirements that have no requirement() references in the codebase.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
-                projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to search (required when multiple projects exist)',
+                untested: {
+                    type: "boolean",
+                    description: "When true, return only root requirements that have no test references (default: false)",
                 },
-            },
-            required: [],
-        },
-    },
-    {
-        name: 'list_all_requirements',
-        description: 'List all requirements in the workspace. Returns a summary of all requirements with their IDs, labels, and content.',
-        inputSchema: {
-            type: 'object',
-            properties: {
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to search (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: Specify which project to search (required when multiple projects exist)",
                 },
             },
             required: [],
         },
     },
     {
-        name: 'get_requirements_by_test',
-        description: 'Get the semantic meaning of requirement() references in a test file. Returns requirement content with line numbers where they are referenced.',
+        name: "get_requirements_by_test",
+        description: "Get the semantic meaning of requirement() references in a test file. Returns requirement content with line numbers where they are referenced.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 testFile: {
-                    type: 'string',
-                    description: 'Path to the test file to analyze',
+                    type: "string",
+                    description: "Path to the test file to analyze",
                 },
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to search (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: Specify which project to search (required when multiple projects exist)",
                 },
             },
-            required: ['testFile'],
+            required: ["testFile"],
         },
     },
     {
-        name: 'get_tests_by_requirement',
-        description: 'Show which requirements from a requirements file have test coverage. Returns a coverage report showing which requirements are tested and where the tests are located. This is the inverse of get_requirements_by_test.',
+        name: "get_tests_by_requirement",
+        description: "Show which requirements from a requirements file have test coverage. Returns a coverage report showing which requirements are tested and where the tests are located. This is the inverse of get_requirements_by_test.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 requirementsFile: {
-                    type: 'string',
+                    type: "string",
                     description: 'Path to the requirements file (e.g., ".requirements/auth.requirements.md")',
                 },
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to search (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: Specify which project to search (required when multiple projects exist)",
                 },
             },
-            required: ['requirementsFile'],
+            required: ["requirementsFile"],
         },
     },
     {
-        name: 'get_requirement_coverage',
-        description: 'Get test coverage information for a specific requirement from dot•requirements cloud. Shows when the requirement was last tested, on which branch, and in which test file. Requires project to be linked to cloud (run `dotrequirements link`).',
+        name: "report_coverage",
+        description: "Display test coverage for the project's requirements. Defaults to local source (most recent test run on this machine, requires `dotrequirements harness prepare` to have run); set source to cloud to query the dot•requirements cloud-persisted record (requires project to be linked via `dotrequirements link`). Optional requirementKey scopes to a single requirement; branch / sinceTimestamp filter cloud-source results.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
-                requirementKey: {
-                    type: 'string',
-                    description: 'The requirement key (e.g., "REQ-123", "AUTH-LOGIN")',
+                source: {
+                    type: "string",
+                    enum: ["local", "cloud"],
+                    description: "Where to read coverage from (default: local)",
                 },
-                projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to use (required when multiple projects exist)',
+                requirementKey: {
+                    type: "string",
+                    description: 'Optional: scope to a single requirement (e.g., "REQ-123"). For local source, also includes that requirement\'s children.',
                 },
-            },
-            required: ['requirementKey'],
-        },
-    },
-    {
-        name: 'get_project_coverage_summary',
-        description: 'Get a summary of test coverage for all requirements in the project from dot•requirements cloud. Shows which requirements have been tested and which haven\'t. Optionally filter by branch or time range. Requires project to be linked to cloud (run `dotrequirements link`).',
-        inputSchema: {
-            type: 'object',
-            properties: {
                 branch: {
-                    type: 'string',
-                    description: 'Optional: Filter coverage to a specific git branch (e.g., "main")',
+                    type: "string",
+                    description: 'Cloud-only: filter coverage to a specific git branch (e.g., "main")',
                 },
                 sinceTimestamp: {
-                    type: 'number',
-                    description: 'Optional: Only show coverage since this timestamp (milliseconds since epoch)',
+                    type: "number",
+                    description: "Cloud-only: only include coverage recorded after this timestamp (milliseconds since epoch)",
                 },
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to use (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: specify which project to use (required when multiple projects exist)",
                 },
             },
             required: [],
         },
     },
     {
-        name: 'create_requirement_document',
-        description: 'Returns a well-formatted Markdown template that demonstrates the requirements file format. Use this to understand the format before creating requirements files. AI should use this template as a reference, then use filesystem tools (Read/Write) to create actual files.',
+        name: "create_requirement_document",
+        description: "Returns a well-formatted Markdown template that demonstrates the requirements file format. Use this to understand the format before creating requirements files. AI should use this template as a reference, then use filesystem tools (Read/Write) to create actual files.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 filePath: {
-                    type: 'string',
+                    type: "string",
                     description: 'Optional: Suggested file path for documentation purposes (e.g., ".requirements/auth.requirements.md")',
                 },
             },
@@ -268,97 +247,97 @@ const tools = [
         },
     },
     {
-        name: 'validate_requirements',
-        description: 'Validate a requirements Markdown file without pushing to cloud. Checks schema validity and returns detailed error messages. Works offline (no network/auth required). Use this to verify files before pushing.',
+        name: "validate_requirements",
+        description: "Validate a requirements Markdown file's schema. Returns detailed error messages on syntax problems. Works offline (no network/auth required). Use this to verify files before pushing.",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 filePath: {
-                    type: 'string',
+                    type: "string",
                     description: 'Path to the Markdown file to validate (e.g., ".requirements/auth.requirements.md")',
                 },
             },
-            required: ['filePath'],
+            required: ["filePath"],
         },
     },
     {
-        name: 'push_requirements',
-        description: 'Push local requirements from .requirements/ directory to dot•requirements cloud. First call returns diff summary for user review. Second call with confirmed=true executes the push. Requires project to be linked to cloud (run `dotrequirements link`).',
+        name: "push_requirements",
+        description: "Push local requirements from .requirements/ directory to dot•requirements cloud. First call returns diff summary for user review. Second call with confirmed=true executes the push. Requires project to be linked to cloud (run `dotrequirements link`).",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 filePath: {
-                    type: 'string',
+                    type: "string",
                     description: 'Optional: Push specific file only (e.g., ".requirements/auth.requirements.md"). If omitted, pushes all files.',
                 },
                 confirmed: {
-                    type: 'boolean',
-                    description: 'Set to true to execute the push after reviewing the diff. First call should omit this.',
+                    type: "boolean",
+                    description: "Set to true to execute the push after reviewing the diff. First call should omit this.",
                 },
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to use (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: Specify which project to use (required when multiple projects exist)",
                 },
             },
             required: [],
         },
     },
     {
-        name: 'style_check',
-        description: 'Check requirements files or test files for style issues and best practices. Uses AI to provide actionable feedback on writing style, clarity, and conventions. Supports requirements files (*.requirements.md) and test files (*.test.*, *.spec.*). For requirements files, you can optionally specify requirement keys to check only those requirements instead of the entire file. Requires project to be linked to cloud (run `dotrequirements link`).',
+        name: "style_check",
+        description: "Check requirements files or test files for style issues and best practices. Uses AI to provide actionable feedback on writing style, clarity, and conventions. Supports requirements files (*.requirements.md) and test files (*.test.*, *.spec.*). For requirements files, you can optionally specify requirement keys to check only those requirements instead of the entire file. Requires project to be linked to cloud (run `dotrequirements link`).",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 filePath: {
-                    type: 'string',
+                    type: "string",
                     description: 'Path to the file to check (e.g., ".requirements/auth.requirements.md" or "src/auth.test.ts")',
                 },
                 requirementKeys: {
-                    type: 'array',
-                    items: { type: 'string' },
+                    type: "array",
+                    items: { type: "string" },
                     description: 'Optional: Array of requirement keys to check (e.g., ["AUTH-1", "AUTH-2"]). Only valid for requirements files (*.requirements.md). When provided, only these requirements are checked instead of the entire file.',
                 },
                 model: {
-                    type: 'string',
+                    type: "string",
                     description: 'Optional: AI model to use for style checking (default: "anthropic/claude-haiku-4.5"). Supported models: "anthropic/claude-haiku-4.5", "google/gemini-3-flash"',
                 },
             },
-            required: ['filePath'],
+            required: ["filePath"],
         },
     },
     {
-        name: 'review_test',
-        description: 'Comprehensively review a test file for both style and semantic correctness. Checks if tests actually validate what the requirements specify (not just style). Loads referenced requirements and validates that test setup, actions, and assertions match requirement preconditions, triggers, and outcomes. Requires project to be linked to cloud (run `dotrequirements link`).',
+        name: "review_test",
+        description: "Comprehensively review a test file for both style and semantic correctness. Checks if tests actually validate what the requirements specify (not just style). Loads referenced requirements and validates that test setup, actions, and assertions match requirement preconditions, triggers, and outcomes. Requires project to be linked to cloud (run `dotrequirements link`).",
         inputSchema: {
-            type: 'object',
+            type: "object",
             properties: {
                 testFilePath: {
-                    type: 'string',
+                    type: "string",
                     description: 'Path to the test file to review (e.g., "src/auth.test.ts")',
                 },
                 projectId: {
-                    type: 'string',
-                    description: 'Optional: Specify which project to use (required when multiple projects exist)',
+                    type: "string",
+                    description: "Optional: Specify which project to use (required when multiple projects exist)",
                 },
             },
-            required: ['testFilePath'],
+            required: ["testFilePath"],
         },
     },
 ];
 // Prompt definitions
 const prompts = [
     {
-        name: 'capture-requirements',
-        description: 'Guide the user through capturing requirements for a new feature before implementation',
+        name: "capture-requirements",
+        description: "Guide the user through capturing requirements for a new feature before implementation",
     },
     {
-        name: 'write-tests',
-        description: 'Guide writing tests that reference and validate requirements',
+        name: "write-tests",
+        description: "Guide writing tests that reference and validate requirements",
     },
 ];
 // Create server (exported for testing with InMemoryTransport)
 export const server = new Server({
-    name: 'dotrequirements',
+    name: "dotrequirements",
     version: VERSION,
 }, {
     capabilities: {
@@ -377,13 +356,13 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
 // Handle get prompt
 server.setRequestHandler(GetPromptRequestSchema, async (request) => {
     const { name } = request.params;
-    if (name === 'capture-requirements') {
+    if (name === "capture-requirements") {
         return {
             messages: [
                 {
-                    role: 'user',
+                    role: "user",
                     content: {
-                        type: 'text',
+                        type: "text",
                         text: `# Capture Requirements for New Feature
 
 Let's document what this feature should do before building it.
@@ -431,13 +410,13 @@ After capturing requirements:
             ],
         };
     }
-    if (name === 'write-tests') {
+    if (name === "write-tests") {
         return {
             messages: [
                 {
-                    role: 'user',
+                    role: "user",
                     content: {
-                        type: 'text',
+                        type: "text",
                         text: `# Write Tests for Requirements
 
 Let's write tests that validate the requirements.
@@ -535,7 +514,7 @@ After writing tests:
 
 - \`get_requirement\` - Get requirement tree with existing coverage
 - \`get_requirements_by_test\` - See requirements referenced in a test file
-- \`list_untested_requirements\` - Find requirements without tests
+- \`list_requirements\` (with \`untested: true\`) - Find requirements without tests
 - \`review_test\` - Validate test actually checks what requirement specifies (run after writing tests)`,
                     },
                 },
@@ -559,39 +538,38 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     };
     try {
         switch (name) {
-            case 'debug_mcp_environment':
-                return handleDebugMcpEnvironment(args, handlerContext);
-            case 'search_requirements':
+            case "debug_mcp_environment":
+                return handleDebugMcpEnvironment({}, handlerContext);
+            case "search_requirements":
                 return handleSearchRequirements(args, handlerContext);
-            case 'get_requirement':
+            case "get_requirement":
                 return handleGetRequirement(args, handlerContext);
-            case 'list_untested_requirements':
-                return handleListUntestedRequirements(args, handlerContext);
-            case 'list_all_requirements':
-                return handleListAllRequirements(args, handlerContext);
-            case 'get_requirements_by_test':
+            case "list_requirements":
+                return handleList(args, handlerContext);
+            case "get_requirements_by_test":
                 return handleGetRequirementsByTest(args, handlerContext);
-            case 'get_tests_by_requirement':
+            case "get_tests_by_requirement":
                 return handleGetTestsByRequirement(args, handlerContext);
-            case 'get_requirement_coverage':
-                return handleGetRequirementCoverage(args, handlerContext);
-            case 'get_project_coverage_summary':
-                return handleGetProjectCoverageSummary(args, handlerContext);
-            case 'create_requirement_document':
+            case "report_coverage":
+                return handleReport(args, handlerContext);
+            case "create_requirement_document":
                 return handleCreateRequirementDocument(args, handlerContext);
-            case 'validate_requirements':
+            case "validate_requirements":
                 return handleValidateRequirements(args, handlerContext);
-            case 'push_requirements':
+            case "push_requirements":
                 return handlePushRequirements(args, handlerContext);
-            case 'style_check':
-                return handleStyleCheck(args, handlerContext, { useEnvAuth: USE_ENV_AUTH, apiBaseUrl: process.env.DOTREQUIREMENTS_API_URL });
-            case 'review_test':
+            case "style_check":
+                return handleStyleCheck(args, handlerContext, {
+                    useEnvAuth: USE_ENV_AUTH,
+                    apiBaseUrl: process.env.DOTREQUIREMENTS_API_URL,
+                });
+            case "review_test":
                 return handleReviewTest(args, handlerContext, { apiBaseUrl: process.env.DOTREQUIREMENTS_API_URL });
             default:
                 return {
                     content: [
                         {
-                            type: 'text',
+                            type: "text",
                             text: `Unknown tool: ${name}`,
                         },
                     ],
@@ -603,7 +581,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: `Error: ${error instanceof Error ? error.message : String(error)}`,
                 },
             ],
@@ -615,10 +593,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 export async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('dot•requirements MCP server running');
-    console.error('WORKSPACE_ROOT:', WORKSPACE_ROOT);
-    console.error('process.cwd():', process.cwd());
-    console.error('REQUIREMENTS_DIR env:', process.env.REQUIREMENTS_DIR);
+    console.error("dot•requirements MCP server running");
+    console.error("WORKSPACE_ROOT:", WORKSPACE_ROOT);
+    console.error("process.cwd():", process.cwd());
+    console.error("REQUIREMENTS_DIR env:", process.env.REQUIREMENTS_DIR);
 }
 // Only run when executed directly, not when imported (enables InMemoryTransport testing)
 if (import.meta.url === `file://${process.argv[1]}`) {

package/dist/mcp/requirements.d.ts

@@ -1,5 +1,5 @@
-import { type RequirementNode, type Metadata } from '../schema/index.js';
-import type { FlattenedRequirement } from './types.js';
+import { type Metadata, type RequirementNode } from "../schema/index.js";
+import type { FlattenedRequirement } from "./types.js";
 /**
  * Parsed requirements file
  */