@popoverai/dotrequirements 0.16.0 → 0.17.1

package/dist/mcp/index.js

@@ -2,18 +2,13 @@
 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, searchRequirements, getRequirementById, getRequirementTree, formatRequirementTree, filterRequirementsByKeys, } from './requirements.js';
-import { findAllTestReferences, getReferencedRequirementIds, } from './grep.js';
-import { findTestCodeForRequirement, findFilesWithRequirement, } from './testCodeExtractor.js';
-import { glob } from 'glob';
-import { CONVEX_URL, getRequirementCoverage as queryRequirementCoverage, getProjectCoverage as queryProjectCoverage, getProjectContext, } from './convexClient.js';
+import { loadAllRequirements } from './requirements.js';
 import { discoverProjects, resolveProject, } from '../utils/project-discovery.js';
 import { getCredentialsFromEnv } from '../utils/project-settings.js';
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
-import { dirname, join, resolve, basename } from 'path';
-import { parseFilesForPush, dryRunPush, executePush, } from '../push/index.js';
-import { findRequirementsFiles } from './requirements.js';
+import { dirname, join } from 'path';
+import { handleDebugMcpEnvironment, handleSearchRequirements, handleListAllRequirements, handleListUntestedRequirements, handleGetRequirement, handleGetRequirementsByTest, handleGetTestsByRequirement, handleGetRequirementCoverage, handleGetProjectCoverageSummary, handleCreateRequirementDocument, handleValidateRequirements, handlePushRequirements, handleStyleCheck, handleReviewTest, } from './handlers/index.js';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -38,17 +33,6 @@ 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');
-const STYLE_CHECK_GUIDANCE = `
-
----
-
-## How to use this feedback
-
-1. **This check is stateless.** It is a "new set of eyes" from any previous feedback rounds — it has no memory of prior suggestions or changes you've already made.
-
-2. **Act on feedback from the posture of "what will make the requirements better."** The severity categories (MUST FIX / SHOULD FIX / COULD IMPROVE) are prioritized for convenience, but unless the user has explicitly told you to ignore lower-priority feedback, go ahead and make any improvements — minor or otherwise. If you believe acting on a specific piece of feedback would make the requirements *worse*, surface that feedback to the user rather than silently ignoring it. Otherwise, just act.
-
-3. **Next steps:** Always run \`validate_requirements\` again after making updates. If you make significant changes based on this feedback, you can run \`style_check\` again — but be aware that will be a fresh set of eyes, not a continued conversation.`;
 // Cache for loaded requirements (refreshed on each tool call for now)
 let cachedRequirements = new Map();
 let cachedDiscoveryResult = null;
@@ -109,7 +93,8 @@ async function getProjectFromDiscovery(projectId) {
     return resolveProject(cachedDiscoveryResult, projectId);
 }
 // Invalidate cache (call before operations that should see fresh data)
-function invalidateCache() {
+// Exported for testing
+export function invalidateCache() {
     cachedRequirements.clear();
     cachedDiscoveryResult = null;
 }
@@ -371,8 +356,8 @@ const prompts = [
         description: 'Guide writing tests that reference and validate requirements',
     },
 ];
-// Create server
-const server = new Server({
+// Create server (exported for testing with InMemoryTransport)
+export const server = new Server({
     name: 'dotrequirements',
     version: VERSION,
 }, {
@@ -564,1195 +549,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     // Refresh cache for each request to pick up changes
     invalidateCache();
+    // Create handler context for extracted handlers
+    const handlerContext = {
+        getRequirements,
+        getProjectFromDiscovery,
+        workspaceRoot: WORKSPACE_ROOT,
+        projectPaths: PROJECT_PATHS,
+        env: process.env,
+    };
     try {
         switch (name) {
-            case 'debug_mcp_environment': {
-                // Check for Antigravity-specific env vars
-                const antigravityVars = Object.entries(process.env)
-                    .filter(([key]) => key.startsWith('GEMINI_') || key.startsWith('ANTIGRAVITY_'))
-                    .map(([key, value]) => `  ${key}: ${value}`)
-                    .join('\n');
-                // Show discovered projects from env vars
-                const projectList = Array.from(PROJECT_PATHS.entries())
-                    .map(([id, path]) => `  ${id}: ${path}`)
-                    .join('\n');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `# MCP Server Environment Debug Info
-
-**process.cwd():** ${process.cwd()}
-**WORKSPACE_ROOT:** ${WORKSPACE_ROOT}
-**REQUIREMENTS_DIR env:** ${process.env.REQUIREMENTS_DIR || '(not set)'}
-**HOME:** ${process.env.HOME || '(not set)'}
-**PWD:** ${process.env.PWD || '(not set)'}
-**OLDPWD:** ${process.env.OLDPWD || '(not set)'}
-
-**Antigravity/Gemini env vars:**
-${antigravityVars || '(none found)'}
-
-**Projects from PROJ_* env vars:**
-${projectList || '(none found)'}`,
-                        },
-                    ],
-                };
-            }
-            case 'search_requirements': {
-                const { query, useRegex = false, projectId } = args;
-                const requirements = await getRequirements(projectId);
-                let results;
-                if (useRegex) {
-                    try {
-                        const regex = new RegExp(query, 'i');
-                        results = requirements.filter((r) => regex.test(r.id) ||
-                            regex.test(r.content) ||
-                            regex.test(r.label));
-                    }
-                    catch (error) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: `Invalid regular expression: ${error instanceof Error ? error.message : String(error)}`,
-                                },
-                            ],
-                            isError: true,
-                        };
-                    }
-                }
-                else {
-                    results = searchRequirements(requirements, query);
-                }
-                // Filter to root requirements only (path.length === 0)
-                const rootResults = results.filter((r) => r.path.length === 0);
-                if (rootResults.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `No requirements found matching "${query}"${useRegex ? ' (regex)' : ''}`,
-                            },
-                        ],
-                    };
-                }
-                // For each root result, get the full tree
-                const formatted = rootResults
-                    .map((r) => {
-                    const tree = getRequirementTree(requirements, r.id);
-                    const treeFormatted = formatRequirementTree(tree);
-                    return `**${r.id}** (${r.label})\n${r.content}\n_Source: ${r.documentTitle}_\n\n\`\`\`\n${treeFormatted}\n\`\`\``;
-                })
-                    .join('\n\n---\n\n');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Found ${rootResults.length} requirement(s) matching "${query}"${useRegex ? ' (regex)' : ''}:\n\n${formatted}`,
-                        },
-                    ],
-                };
-            }
-            case 'get_requirement': {
-                const { id, projectId } = args;
-                const project = await getProjectFromDiscovery(projectId);
-                const requirements = await getRequirements(projectId);
-                // Get the tree starting from this ID
-                const tree = getRequirementTree(requirements, id);
-                if (tree.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Requirement "${id}" not found`,
-                            },
-                        ],
-                    };
-                }
-                const root = tree[0];
-                const formatted = formatRequirementTree(tree);
-                // Find test files that reference this requirement
-                const testFiles = await glob('**/*.{test,spec}.{js,jsx,ts,tsx}', {
-                    cwd: project.path,
-                    absolute: true,
-                    ignore: ['**/node_modules/**', '**/dist/**', '**/build/**'],
-                });
-                const matchingFiles = findFilesWithRequirement(testFiles, id);
-                let testCodeSections = [];
-                for (const file of matchingFiles) {
-                    const testRefs = findTestCodeForRequirement(file, id);
-                    // Deduplicate by removing nested blocks - keep only outermost blocks
-                    const deduplicated = testRefs.filter((ref, i) => {
-                        // Check if this ref is contained within any other ref
-                        const isNested = testRefs.some((other, j) => {
-                            if (i === j)
-                                return false;
-                            // other contains ref if it starts before or at the same line and ends after or at the same line
-                            return other.startLine <= ref.startLine && other.endLine >= ref.endLine &&
-                                (other.startLine < ref.startLine || other.endLine > ref.endLine);
-                        });
-                        return !isNested;
-                    });
-                    for (const ref of deduplicated) {
-                        testCodeSections.push(`**${ref.requirementId}** tested in \`${ref.file}:${ref.startLine}-${ref.endLine}\`:\n\n\`\`\`typescript\n${ref.code}\n\`\`\``);
-                    }
-                }
-                const testSection = testCodeSections.length > 0
-                    ? `\n\n## Test Coverage (${testCodeSections.length} reference(s)):\n\n${testCodeSections.join('\n\n---\n\n')}`
-                    : '\n\n## Test Coverage\n\nNo tests found referencing this requirement.';
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `# ${id}\n\n**Document:** ${root.documentTitle}\n**Source:** ${root.sourceFile}\n\n## Requirement Tree (${tree.length} node(s)):\n\n\`\`\`\n${formatted}\n\`\`\`${testSection}`,
-                        },
-                    ],
-                };
-            }
-            case 'list_untested_requirements': {
-                const { projectId } = args;
-                const project = await getProjectFromDiscovery(projectId);
-                const requirements = await getRequirements(projectId);
-                const referencedIds = await getReferencedRequirementIds(project.path);
-                // Get root requirements only for this comparison
-                const rootRequirements = requirements.filter((r) => r.path.length === 0);
-                const untested = rootRequirements.filter((r) => !referencedIds.has(r.id));
-                if (untested.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `All ${rootRequirements.length} requirements have test references!`,
-                            },
-                        ],
-                    };
-                }
-                const formatted = untested
-                    .map((r) => `- **${r.id}**: ${r.content}`)
-                    .join('\n');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Found ${untested.length} untested requirement(s) out of ${rootRequirements.length} total:\n\n${formatted}`,
-                        },
-                    ],
-                };
-            }
-            case 'list_all_requirements': {
-                const { projectId } = args;
-                const project = await getProjectFromDiscovery(projectId);
-                const requirements = await getRequirements(projectId);
-                if (requirements.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `No requirements found in project: ${project.path}\n\nMake sure .requirements/ directory exists with Markdown files (*.requirements.md).`,
-                            },
-                        ],
-                    };
-                }
-                // Group by root ID
-                const grouped = new Map();
-                for (const req of requirements) {
-                    const existing = grouped.get(req.rootId) || [];
-                    existing.push(req);
-                    grouped.set(req.rootId, existing);
-                }
-                const formatted = Array.from(grouped.entries())
-                    .map(([rootId, reqs]) => {
-                    const root = reqs.find((r) => r.path.length === 0);
-                    const childCount = reqs.length - 1;
-                    return `- **${rootId}**: ${root?.content || '(no content)'} (${childCount} children)`;
-                })
-                    .join('\n');
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Found ${grouped.size} requirement(s) with ${requirements.length} total nodes:\n\n${formatted}`,
-                        },
-                    ],
-                };
-            }
-            case 'get_requirements_by_test': {
-                const { testFile, projectId } = args;
-                const requirements = await getRequirements(projectId);
-                // Find all requirement references in the test file
-                const { findRequirementsInFile } = await import('./grep.js');
-                const refs = await findRequirementsInFile(testFile);
-                if (refs.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `No requirement references found in "${testFile}"`,
-                            },
-                        ],
-                    };
-                }
-                // For each reference, get the requirement content
-                const entries = refs.map((ref) => {
-                    const req = getRequirementById(requirements, ref.requirementId);
-                    const reqContent = req
-                        ? `**${req.label}:** ${req.content}`
-                        : `(requirement not found)`;
-                    return `**Line ${ref.line}:** \`${ref.requirementId}\` - ${reqContent}`;
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Requirements referenced in "${testFile}":\n\n${entries.join('\n\n')}`,
-                        },
-                    ],
-                };
-            }
-            case 'get_tests_by_requirement': {
-                const { requirementsFile, projectId } = args;
-                const fs = await import('fs');
-                const path = await import('path');
-                const fullPath = path.resolve(WORKSPACE_ROOT, requirementsFile);
-                // Verify file exists
-                if (!fs.existsSync(fullPath)) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Requirements file not found: ${requirementsFile}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Verify it's a requirements file
-                if (!requirementsFile.endsWith('.requirements.md')) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `File must be a requirements file: *.requirements.md`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Load all requirements from this file
-                const requirements = await getRequirements(projectId);
-                const fileRequirements = requirements.filter(req => path.resolve(WORKSPACE_ROOT, req.sourceFile) === fullPath);
-                if (fileRequirements.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `No requirements found in "${requirementsFile}"`,
-                            },
-                        ],
-                    };
-                }
-                // Get unique root requirement IDs from this file
-                const rootIds = new Set(fileRequirements.map(req => req.rootId));
-                // Find all test references in the workspace
-                const allTestRefs = await findAllTestReferences(WORKSPACE_ROOT);
-                // Build coverage map: requirement ID -> list of test references
-                const coverageMap = new Map();
-                for (const ref of allTestRefs) {
-                    if (!coverageMap.has(ref.requirementId)) {
-                        coverageMap.set(ref.requirementId, []);
-                    }
-                    coverageMap.get(ref.requirementId).push(ref);
-                }
-                // Categorize requirements as covered or not covered
-                const covered = [];
-                const notCovered = [];
-                for (const rootId of rootIds) {
-                    // Check if this requirement ID or any of its children are referenced
-                    const reqAndChildren = fileRequirements.filter(r => r.rootId === rootId);
-                    const allIds = reqAndChildren.map(r => r.id);
-                    const testsForThisReq = [];
-                    for (const id of allIds) {
-                        const refs = coverageMap.get(id);
-                        if (refs) {
-                            testsForThisReq.push(...refs);
-                        }
-                    }
-                    if (testsForThisReq.length > 0) {
-                        covered.push({ id: rootId, tests: testsForThisReq });
-                    }
-                    else {
-                        notCovered.push(rootId);
-                    }
-                }
-                // Format output
-                let output = `# Test Coverage for \`${requirementsFile}\`\n\n`;
-                if (covered.length > 0) {
-                    output += `## Covered (${covered.length})\n\n`;
-                    for (const { id, tests } of covered) {
-                        // Group tests by file
-                        const testsByFile = new Map();
-                        for (const test of tests) {
-                            if (!testsByFile.has(test.file)) {
-                                testsByFile.set(test.file, []);
-                            }
-                            testsByFile.get(test.file).push(test.line);
-                        }
-                        output += `- **${id}**: ${tests.length} test${tests.length === 1 ? '' : 's'}\n`;
-                        for (const [file, lines] of testsByFile.entries()) {
-                            const relPath = path.relative(WORKSPACE_ROOT, file);
-                            const lineList = lines.sort((a, b) => a - b).join(', ');
-                            output += `  - \`${relPath}\` (lines ${lineList})\n`;
-                        }
-                    }
-                    output += '\n';
-                }
-                if (notCovered.length > 0) {
-                    output += `## Not Covered (${notCovered.length})\n\n`;
-                    for (const id of notCovered) {
-                        output += `- **${id}**: No tests found\n`;
-                    }
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: output,
-                        },
-                    ],
-                };
-            }
-            case 'get_requirement_coverage': {
-                const { requirementKey, projectId } = args;
-                const project = await getProjectFromDiscovery(projectId);
-                const coverage = await queryRequirementCoverage(requirementKey, project.projectId, project.projectSecret, CONVEX_URL);
-                if (!coverage.lastTestedAt) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `**${requirementKey}** has not been tested yet.`,
-                            },
-                        ],
-                    };
-                }
-                const lastTested = new Date(coverage.lastTestedAt);
-                const testLocation = coverage.testFile
-                    ? `\n**Test Location:** \`${coverage.testFile}${coverage.testLine ? `:${coverage.testLine}` : ''}\``
-                    : '';
-                let branchInfo = `\n**Branch:** ${coverage.branch}`;
-                if (coverage.allBranches.length > 1) {
-                    const otherBranches = coverage.allBranches
-                        .filter((b) => b.branch !== coverage.branch)
-                        .map((b) => `- ${b.branch}: ${new Date(b.lastTestedAt).toISOString()}`)
-                        .join('\n');
-                    branchInfo += `\n\n**Also tested on:**\n${otherBranches}`;
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `# Coverage for ${requirementKey}\n\n**Last Tested:** ${lastTested.toISOString()}${branchInfo}${testLocation}`,
-                        },
-                    ],
-                };
-            }
-            case 'get_project_coverage_summary': {
-                const { branch, sinceTimestamp, projectId } = args;
-                const project = await getProjectFromDiscovery(projectId);
-                const coverage = await queryProjectCoverage(project.projectId, project.projectSecret, CONVEX_URL, { branch, sinceTimestamp });
-                const total = coverage.tested.length + coverage.untested.length;
-                const percentage = total > 0 ? ((coverage.tested.length / total) * 100).toFixed(1) : '0.0';
-                let filterInfo = '';
-                if (branch) {
-                    filterInfo += `\n**Branch:** ${branch}`;
-                }
-                if (sinceTimestamp) {
-                    filterInfo += `\n**Since:** ${new Date(sinceTimestamp).toISOString()}`;
-                }
-                let testedSection = '';
-                if (coverage.tested.length > 0) {
-                    const testedList = coverage.tested
-                        .map((t) => {
-                        const date = new Date(t.lastTestedAt).toISOString();
-                        const location = t.testFile
-                            ? ` (\`${t.testFile}${t.testLine ? `:${t.testLine}` : ''}\`)`
-                            : '';
-                        return `- **${t.requirementKey}** [${t.branch}]: ${date}${location}`;
-                    })
-                        .join('\n');
-                    testedSection = `\n\n## Tested Requirements (${coverage.tested.length})\n\n${testedList}`;
-                }
-                let untestedSection = '';
-                if (coverage.untested.length > 0) {
-                    const untestedList = coverage.untested
-                        .map((key) => `- ${key}`)
-                        .join('\n');
-                    untestedSection = `\n\n## Untested Requirements (${coverage.untested.length})\n\n${untestedList}`;
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `# Project Coverage Summary\n\n**Total Requirements:** ${total}\n**Coverage:** ${percentage}%${filterInfo}${testedSection}${untestedSection}`,
-                        },
-                    ],
-                };
-            }
-            case 'create_requirement_document': {
-                const { filePath = '.requirements/example.requirements.md' } = args;
-                // Discover existing label and key patterns in the codebase
-                // Try to get requirements, but don't fail if no project is configured
-                let requirements = [];
-                try {
-                    requirements = await getRequirements();
-                }
-                catch {
-                    // No project configured - that's okay, we'll just not have discovered patterns
-                }
-                const labels = new Set();
-                const keyPrefixes = new Set();
-                for (const req of requirements) {
-                    // findRequirementsFiles now excludes example/fixture files automatically
-                    // Collect labels (empty string means unlabeled, so skip those)
-                    if (req.label && req.label.trim()) {
-                        labels.add(req.label);
-                    }
-                    // Collect requirement key prefixes (root IDs only)
-                    // Extract prefix from keys like "AUTH-1" -> "AUTH", "LOGIN-FLOW-2" -> "LOGIN-FLOW"
-                    if (req.path.length === 0 && req.id) {
-                        const lastDashIndex = req.id.lastIndexOf('-');
-                        if (lastDashIndex > 0) {
-                            const prefix = req.id.substring(0, lastDashIndex);
-                            keyPrefixes.add(prefix);
-                        }
-                    }
-                }
-                const discoveredLabels = Array.from(labels).sort();
-                const discoveredPrefixes = Array.from(keyPrefixes).sort();
-                let labelGuidance = '';
-                let keyGuidance = '';
-                // Generate label guidance
-                if (discoveredLabels.length > 0) {
-                    const labelList = discoveredLabels.slice(0, 10).map(l => `"${l}"`).join(', ');
-                    const more = discoveredLabels.length > 10 ? ` (and ${discoveredLabels.length - 10} more)` : '';
-                    labelGuidance = `**Existing labels in this codebase:** ${labelList}${more}
-
-**Use these existing labels** to maintain consistency. If you're unsure which labels to use for a new requirement, ask the user.`;
-                }
-                else {
-                    labelGuidance = `**No existing requirements found in this codebase.**
-
-**Default to unlabeled requirements** (\`0. → content\`). If the user wants labels, ask them which format they prefer. Do not choose an opinionated framework like Given/When/Then without explicit user consent.`;
-                }
-                // Generate key guidance
-                if (discoveredPrefixes.length > 0) {
-                    const prefixList = discoveredPrefixes.map(p => `"${p}"`).join(', ');
-                    keyGuidance = `**Existing requirement key prefixes in this codebase:** ${prefixList}
-
-**Match the existing pattern** when creating new requirement keys. Use the same domain prefixes and sequential numbering style.`;
-                }
-                else {
-                    keyGuidance = `**No existing requirements found in this codebase.**
-
-**Use concise domain prefixes** like \`AUTH-1\`, \`LOGIN-1\`, etc. Start numbering at 1 and increment sequentially.`;
-                }
-                // PROJ-CONTEXT-7: Try to fetch user-provided style context from cloud
-                let userStyleGuidance = '';
-                try {
-                    const project = await getProjectFromDiscovery();
-                    const context = await getProjectContext(project.projectId, project.projectSecret, CONVEX_URL);
-                    if (context?.requirementsStyleContext?.trim()) {
-                        userStyleGuidance = `
-
-## User-Provided Style Guidelines
-
-The following style guidelines were provided by the project owner. When these conflict with the defaults above, prioritize the user's guidelines.
-
-${context.requirementsStyleContext.trim()}`;
-                    }
-                }
-                catch {
-                    // No credentials or cloud unavailable - continue without user context
-                }
-                const template = `---
-document:
-  title: "Example Requirements"
----
-
-# Example Requirements
-
-This template demonstrates the dotrequirements Markdown format and style guidelines.
-
-## Syntax Overview
-
-**File naming:** Use \`*.requirements.md\` pattern (colocated: \`auth.requirements.md\` or centralized: \`.requirements/auth.requirements.md\`)
-
-**Block format:**
-\`\`\`dotrequirements
-KEY: Root requirement content
-  0. → First criterion (unlabeled)
-  1. Label → Second criterion (with label)
-    1.0. → Nested criterion (unlabeled)
-\`\`\`
-
-- First line: \`KEY: content\` (requirement key and description)
-- Criteria: \`position. Label → content\` or \`position. → content\` (unlabeled)
-- Position: \`0\`, \`1\`, \`2\` (top-level) or \`0.0\`, \`1.0\` (nested) - defines hierarchy
-- Delimiter: \`→\` or \`->\` separates optional label from content
-
-## Requirement Keys: Concise and Sequential
-
-${keyGuidance}
-
-**Key format:** \`DOMAIN-FEATURE-N\` where N is sequential (1, 2, 3...)
-
-**Best practices:**
-1. **Concise domains** - Use short, clear prefixes
-   - ✅ \`AUTHZ-1\` (authorization)
-   - ✅ \`AUTH-1\` (authentication)
-   - ❌ \`AUTHORIZATION-1\` (too verbose)
-   - ❌ \`REQ-IDENTITY-ACCESS-AUTHZ-1\` (too nested)
-
-2. **Sequential, 1-indexed numbering** - Start at 1, no padding
-   - ✅ \`LOGIN-1\`, \`LOGIN-2\`, \`LOGIN-3\`
-   - ❌ \`LOGIN-0\` (don't use 0-indexing for requirement IDs)
-   - ❌ \`LOGIN-001\` (no zero-padding)
-
-3. **Unique across project** - Each key must be unique in the entire project
-
-4. **Match existing patterns** - Check existing requirements first and follow their convention
-
-## Labels: Match Your Codebase or Ask the User
-
-${labelGuidance}
-
-## Style Principles for Requirements
-
-**1. Use Concrete Examples**: Replace vague language with specific, testable conditions.
-- ❌ "users can log in" or "works properly"
-- ✅ "When a registered user provides valid credentials, they are authenticated"
-
-**2. Write Natural, Concise Prose**: Avoid terseness and verbosity. Use declarative style (not "should").
-- ❌ "registered user with valid credentials is authenticated" (too terse)
-- ❌ "A registered user, whose account was created on Tuesday and whose life story is as follows..." (too verbose)
-- ✅ "When a registered user provides valid credentials, they are authenticated"
-
-**3. Keep Arrange/Act/Assert in Mind**: Well-written requirements describe preconditions, trigger, and result.
-- ✅ "When [preconditions:] a registered user [trigger:] provides valid credentials, [result:] they are authenticated"
-
-**4. Be Framework Neutral**: Don't prescribe Given/When/Then vs AC vs other formats - focus on content quality.
-
-**5. Use Named Personas**: Establish personas in parent requirements, reuse in children.
-- ✅ Parent: "A registered user, Jamie, can log in normally" → Child: "When Jamie provides valid credentials, they are authenticated"
-
-**6. Use User-Centric Language**: Describe user experience, not technical internals.
-- ❌ "they are redirected to app.dotrequirements.io/redirect/dashboard"
-- ✅ "they are automatically brought to the dashboard"
-
-**7. Single Action Per Requirement**: Don't chain multiple actions with "and then".
-- ❌ "When Robin provides credentials, requests an OTP, then provides the OTP..."
-- ✅ Break into separate requirements for each action
-
-**8. Each Requirement Should Be Independent**: Requirements within a block should be independently testable. If they share preconditions or form a sequence, either nest them or restate context.
-- ❌ "0. → When Jordan submits signup, an account is created" / "1. → Welcome email is sent" / "2. → Dashboard appears"
-- ✅ Option A: Restate context - "1. → When Jordan submits signup, a welcome email is sent"
-- ✅ Option B: Use nesting - "0. When → Jordan submits signup" / "  0.0. Then → an account is created"
-- Test: Can you understand what's being tested by reading just one requirement, or do you need to read its siblings?
-
-**9. Focus on Behavior, Not Design**: Describe what happens, not UI specifics.
-- ❌ "enters valid credentials into two single-line input fields and presses a green button"
-- ✅ "provides valid credentials"
-
-**10. Focus on Outcomes, Not Implementation**: User perspective, even for technical requirements.
-- ❌ "When the app requests that Twilio send Casey an OTP from /email/POST endpoint..."
-- ✅ "When Casey requests an email OTP..."
-- Note: Even technical requirements can be user-centric: "95 percent of users experience under 1 second of delay"
-
-**11. Decompose Large Requirements**: If it can't be validated with a single test, break it down.
-${userStyleGuidance}
-
-## Example Requirements
-
-**Unlabeled (recommended default):**
-\`\`\`dotrequirements
-AUTH-LOGIN-1: A registered user, Jamie, can log in to their account
-  0. → When Jamie provides their registered email and correct password, they are authenticated and brought to their dashboard
-  1. → When Jamie provides an incorrect password, they see an error message and remain on the login page
-  2. → When Jamie's account has been deactivated, they see a message explaining their account status
-\`\`\`
-
-**With labels (example only - DO NOT use opinionated formats like Given/When/Then without asking the user first):**
-\`\`\`dotrequirements
-PAYMENT-REFUND-1: A customer, Alex, receives a refund after returning an item
-  0. Given → Alex purchased a laptop from the store 10 days ago
-  1. Given → Alex initiates a return through their order history
-  2. When → Alex's returned laptop is received and inspected at the warehouse
-  3. Then → Alex receives a refund to their original payment method within 5 business days
-  4. Then → Alex receives an email confirmation with the refund amount and expected timeline
-\`\`\`
-
-## Referencing Requirements in Tests
-
-**Use \`requirement()\` as the test description** - it returns a string:
-
-\`\`\`typescript
-import { describe, it, expect } from 'vitest';
-import { requirement } from '@popoverai/dotrequirements/test';
-
-describe(requirement('AUTH-LOGIN-1'), () => {
-  describe(requirement('AUTH-LOGIN-1.given'), () => {
-    // Arrange: Create Jamie's account
-  });
-
-  describe(requirement('AUTH-LOGIN-1.when'), () => {
-    // Act: Submit login with valid credentials
-
-    it(requirement('AUTH-LOGIN-1.then'), () => {
-      // Assert: Jamie is authenticated
-    });
-  });
-});
-\`\`\`
-
-**Test Style Principles:**
-
-**1. Use requirement() AS the description**: Don't put requirement() inside test body or in comments.
-- ✅ \`test(requirement('AUTH-LOGIN-1'), () => { /* test code */ })\`
-- ✅ \`it(requirement('LOGIN-1.then'), () => { /* assert */ })\`
-- ❌ \`test("user can log in", () => { requirement('AUTH-LOGIN-1'); /* test code */ })\`
-- ❌ \`// LOGIN-1: User can log in\` (comment instead of using requirement() as description)
-
-**2. Comments describe the TEST, not the requirement**: Don't copy requirement text verbatim.
-- ✅ \`describe(requirement('REQ-1.0'), () => { // registered user, valid credentials\`
-- ❌ \`describe(requirement('REQ-1.0'), () => { // 0. When a registered user provides valid credentials, they are authenticated\` (verbatim copy is a red flag)
-- Note: Comments should reflect what the test actually does, not just repeat what the requirement says
-
-**3. Structure tests to match requirements**: Nest describe/it blocks for structured requirements.
-- ✅ For structured requirements: \`describe(requirement('LOGIN-1.given'))\` nested with \`describe(requirement('LOGIN-1.when'))\` and \`it(requirement('LOGIN-1.then'))\`
-- ✅ For simple requirements: \`test(requirement('AUTH-LOGIN-1'), () => { /* arrange, act, assert all in one */ })\`
-
-**Path formats:**
-- \`requirement('AUTH-LOGIN-1')\` - root requirement
-- \`requirement('AUTH-LOGIN-1.0')\` - by numeric position
-- \`requirement('AUTH-LOGIN-1.given')\` - by label (case-insensitive)
-- \`requirement('AUTH-LOGIN-1.given#1')\` - disambiguate duplicate labels`;
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `# Requirements File Template\n\nHere's a comprehensive template for \`${filePath}\` with format and style guidance:\n\n\`\`\`markdown\n${template}\`\`\`\n\n## Next Steps\n\n1. **Create file**: Use Write tool to create \`${filePath}\` based on this template\n2. **Refine style** (optional): Call \`style_check\` for AI feedback on style and best practices\n3. **Validate syntax**: Call \`validate_requirements\` to verify format is correct\n4. **Push to Convex**: Call \`push_requirements\` to sync requirements to data layer\n\n**Note**: Requirements files can be colocated with code (\`src/auth.requirements.md\`) or centralized in \`.requirements/\` directory.`,
-                        },
-                    ],
-                };
-            }
-            case 'validate_requirements': {
-                const { filePath } = args;
-                const { parseRequirementsFromFile, validateForPush } = await import('../schema/index.js');
-                const fs = await import('fs');
-                const path = await import('path');
-                const fullPath = path.resolve(WORKSPACE_ROOT, filePath);
-                if (!fs.existsSync(fullPath)) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `File not found: ${filePath}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                try {
-                    const parsed = parseRequirementsFromFile(fullPath);
-                    const reqCount = Object.keys(parsed.requirements).length;
-                    // Check push readiness
-                    const pushValidation = validateForPush(parsed.metadata);
-                    let headline;
-                    let pushDetails = '';
-                    if (!pushValidation.valid) {
-                        headline = `❌ \`${filePath}\` - Not push-ready\n- ${pushValidation.reason}`;
-                    }
-                    else {
-                        const actionLabel = pushValidation.action === 'create' ? 'Will create new document' : 'Will update existing document';
-                        headline = `✓ \`${filePath}\` - ${actionLabel}`;
-                        if (pushValidation.warning) {
-                            pushDetails = `\n- ⚠️ ${pushValidation.warning}`;
-                        }
-                    }
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `${headline}${pushDetails}\n\n**Metadata:**\n- Version: ${parsed.metadata.version ?? '(none)'}\n- Document: ${parsed.metadata.document?.title || '(none)'}\n- Document ID: ${parsed.metadata.document?.id || '(none)'}\n\n**Requirements:** ${reqCount} root requirement(s) found`,
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `✗ Validation failed for \`${filePath}\`:\n\n${error instanceof Error ? error.message : String(error)}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            }
-            case 'push_requirements': {
-                const { filePath, confirmed = false, projectId: projectIdParam } = args;
-                // Get project (credentials come from project object, works with both file and env auth)
-                const project = await getProjectFromDiscovery(projectIdParam);
-                // Determine files to push
-                let filesToPush;
-                if (filePath) {
-                    const fullPath = resolve(project.path, filePath);
-                    if (!existsSync(fullPath)) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: `File not found: ${filePath}`,
-                                },
-                            ],
-                            isError: true,
-                        };
-                    }
-                    filesToPush = [fullPath];
-                }
-                else {
-                    // Use same file discovery as CLI - searches entire workspace
-                    filesToPush = await findRequirementsFiles(project.path);
-                    if (filesToPush.length === 0) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: 'No *.requirements.md files found. Nothing to push.',
-                                },
-                            ],
-                        };
-                    }
-                }
-                // Parse files
-                const { parsedFiles, totalRequirements } = parseFilesForPush(filesToPush);
-                // Build credentials
-                const credentials = {
-                    projectId: project.projectId,
-                    projectSecret: project.projectSecret,
-                    convexUrl: CONVEX_URL,
-                };
-                // Run dry run (always, even when confirmed - ensures fresh state)
-                const dryRunResult = await dryRunPush(parsedFiles, credentials);
-                // Check if there's anything to push
-                const pushableCount = dryRunResult.updates.length +
-                    dryRunResult.creates.length +
-                    dryRunResult.notFound.length;
-                if (pushableCount === 0 && dryRunResult.invalid.length > 0) {
-                    // Only invalid files
-                    const invalidList = dryRunResult.invalid
-                        .map(({ file, result }) => `- ${basename(file.filePath)}: ${result.error}`)
-                        .join('\n');
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `✗ No valid documents to push.\n\n**Invalid files:**\n${invalidList}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                if (!confirmed) {
-                    // First call: show preview with real dry run results
-                    let summary = `# Push Preview\n\n**Files:** ${parsedFiles.length}\n**Requirements:** ${totalRequirements}\n\n`;
-                    if (dryRunResult.updates.length > 0) {
-                        summary += `## Updates (${dryRunResult.updates.length})\n`;
-                        for (const { file, result } of dryRunResult.updates) {
-                            const fileName = basename(file.filePath);
-                            const hasConflict = dryRunResult.conflicts.some((c) => c.item.file === file);
-                            const conflictNote = hasConflict ? ' ⚠️ [cloud changed since pull]' : '';
-                            const warningNote = result.warning ? ` (${result.warning})` : '';
-                            summary += `- ~ ${fileName}${conflictNote}${warningNote}\n`;
-                        }
-                        summary += '\n';
-                    }
-                    if (dryRunResult.creates.length > 0) {
-                        summary += `## New Documents (${dryRunResult.creates.length})\n`;
-                        for (const { file, result } of dryRunResult.creates) {
-                            const fileName = basename(file.filePath);
-                            const warningNote = result.warning ? ` (${result.warning})` : '';
-                            summary += `- + ${fileName}${warningNote}\n`;
-                        }
-                        summary += '\n';
-                    }
-                    if (dryRunResult.notFound.length > 0) {
-                        summary += `## Not Found in Cloud (${dryRunResult.notFound.length}) - will create new\n`;
-                        for (const { file, result } of dryRunResult.notFound) {
-                            const fileName = basename(file.filePath);
-                            summary += `- ! ${fileName} (ID: ${result.documentId})\n`;
-                        }
-                        summary += '\n';
-                    }
-                    if (dryRunResult.invalid.length > 0) {
-                        summary += `## Skipped - Invalid (${dryRunResult.invalid.length})\n`;
-                        for (const { file, result } of dryRunResult.invalid) {
-                            const fileName = basename(file.filePath);
-                            summary += `- ✗ ${fileName}: ${result.error}\n`;
-                        }
-                        summary += '\n';
-                    }
-                    if (dryRunResult.conflicts.length > 0) {
-                        summary += `⚠️ **Warning:** ${dryRunResult.conflicts.length} file(s) have cloud changes since last pull. Pushing will overwrite those changes.\n\n`;
-                    }
-                    summary += `**To proceed:** Call this tool again with \`confirmed: true\``;
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: summary,
-                            },
-                        ],
-                    };
-                }
-                // Second call: execute push
-                try {
-                    const result = await executePush(dryRunResult, credentials);
-                    let output = '✓ Push complete!\n\n';
-                    if (result.created > 0) {
-                        output += `**Created:** ${result.created} document(s)\n`;
-                    }
-                    if (result.updated > 0) {
-                        output += `**Updated:** ${result.updated} document(s)\n`;
-                    }
-                    if (result.errors.length > 0) {
-                        output += `\n**Errors:**\n`;
-                        for (const { fileName, error } of result.errors) {
-                            output += `- ${fileName}: ${error}\n`;
-                        }
-                    }
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: output,
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `✗ Push failed:\n\n${error instanceof Error ? error.message : String(error)}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            }
-            case 'style_check': {
-                const { filePath, model, requirementKeys } = args;
-                const fs = await import('fs');
-                const path = await import('path');
-                const fullPath = path.resolve(WORKSPACE_ROOT, filePath);
-                if (!fs.existsSync(fullPath)) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `File not found: ${filePath}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Read file contents
-                const fileContents = fs.readFileSync(fullPath, 'utf-8');
-                // Detect file type
-                const isRequirementsFile = filePath.endsWith('.requirements.md');
-                const isTestFile = /\.(test|spec)\.(js|jsx|ts|tsx)$/.test(filePath);
-                if (!isRequirementsFile && !isTestFile) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Unsupported file type. File must be:\n- Requirements file: *.requirements.md\n- Test file: *.test.{js,jsx,ts,tsx} or *.spec.{js,jsx,ts,tsx}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                const fileType = isRequirementsFile ? 'requirements' : 'test';
-                // If requirementKeys provided, filter the file to only those requirements
-                let fileContentsToCheck = fileContents;
-                let scopeNote = '';
-                if (requirementKeys && requirementKeys.length > 0) {
-                    if (!isRequirementsFile) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: `requirementKeys can only be used with requirements files (*.requirements.md), not test files.`,
-                                },
-                            ],
-                            isError: true,
-                        };
-                    }
-                    try {
-                        const { filteredContent, foundKeys, missingKeys } = filterRequirementsByKeys(fileContents, requirementKeys);
-                        if (foundKeys.length === 0) {
-                            return {
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: `None of the specified requirement keys were found in ${filePath}: ${requirementKeys.join(', ')}`,
-                                    },
-                                ],
-                                isError: true,
-                            };
-                        }
-                        fileContentsToCheck = filteredContent;
-                        if (missingKeys.length > 0) {
-                            scopeNote = `\n\n> **Note:** Some specified keys were not found in the file: ${missingKeys.join(', ')}`;
-                        }
-                    }
-                    catch (error) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: `Failed to filter requirements: ${error instanceof Error ? error.message : String(error)}`,
-                                },
-                            ],
-                            isError: true,
-                        };
-                    }
-                }
-                // Get Convex config for credentials - walk up from file's directory to find project
-                const fileDir = path.dirname(fullPath);
-                let project;
-                try {
-                    // If using env auth, go straight to getProjectFromDiscovery (handles env credentials)
-                    if (USE_ENV_AUTH) {
-                        project = await getProjectFromDiscovery();
-                    }
-                    else {
-                        // Try to find a project starting from the file's directory
-                        const result = await discoverProjects(fileDir);
-                        if (result.type === 'none') {
-                            // If no project found from file dir, try from WORKSPACE_ROOT
-                            project = await getProjectFromDiscovery();
-                        }
-                        else if (result.type === 'single') {
-                            project = result.project;
-                        }
-                        else {
-                            // Multiple projects - can't auto-detect which one to use
-                            throw new Error('Multiple projects found - cannot auto-detect for this file');
-                        }
-                    }
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Style check requires project credentials. Run \`dotrequirements link\` to connect to cloud.\n\nError: ${error instanceof Error ? error.message : String(error)}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Use credentials from project (works with both file-based and env-based auth)
-                const { projectId: projId, projectSecret: projSecret } = project;
-                // Call Vercel API endpoint for style checking
-                // Default to production, allow override via env var for local dev
-                const apiBaseUrl = process.env.DOTREQUIREMENTS_API_URL || 'https://app.dotrequirements.io';
-                try {
-                    const response = await fetch(`${apiBaseUrl}/api/style-check`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            projectId: projId,
-                            projectSecret: projSecret,
-                            fileContents: fileContentsToCheck,
-                            fileType,
-                            model,
-                        }),
-                    });
-                    if (!response.ok) {
-                        const errorData = await response.json();
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: `Style check failed: ${errorData.error || response.statusText}`,
-                                },
-                            ],
-                            isError: true,
-                        };
-                    }
-                    const data = await response.json();
-                    const scopeLabel = requirementKeys && requirementKeys.length > 0
-                        ? ` (${requirementKeys.join(', ')})`
-                        : '';
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `# Style Check Results for \`${filePath}\`${scopeLabel}\n\n${data.feedback}${scopeNote}${STYLE_CHECK_GUIDANCE}`,
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Style check error: ${error instanceof Error ? error.message : String(error)}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            }
-            case 'review_test': {
-                const { testFilePath, projectId } = args;
-                const fs = await import('fs');
-                const path = await import('path');
-                const fullPath = path.resolve(WORKSPACE_ROOT, testFilePath);
-                if (!fs.existsSync(fullPath)) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `File not found: ${testFilePath}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Verify it's a test file
-                const isTestFile = /\.(test|spec)\.(js|jsx|ts|tsx)$/.test(testFilePath);
-                if (!isTestFile) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `File must be a test file: *.test.{js,jsx,ts,tsx} or *.spec.{js,jsx,ts,tsx}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Read test file contents
-                const testFileContents = fs.readFileSync(fullPath, 'utf-8');
-                // Extract requirement IDs from the test file using regex
-                const requirementIdMatches = testFileContents.matchAll(/requirement\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g);
-                const requirementIds = new Set();
-                for (const match of requirementIdMatches) {
-                    requirementIds.add(match[1]);
-                }
-                // Get project
-                let project;
-                try {
-                    project = await getProjectFromDiscovery(projectId);
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Test review requires a configured dotrequirements project.\n\nError: ${error instanceof Error ? error.message : String(error)}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                // Load all requirements for this project
-                const allRequirements = await getRequirements(projectId);
-                // Group requirement IDs by their root to avoid sending duplicate trees
-                // e.g., NAV-3.0, NAV-3.1, NAV-3.2 all belong to root NAV-3
-                const rootToTestedIds = new Map();
-                for (const reqId of requirementIds) {
-                    const req = allRequirements.find(r => r.id === reqId || r.rootId === reqId);
-                    if (req) {
-                        if (!rootToTestedIds.has(req.rootId)) {
-                            rootToTestedIds.set(req.rootId, new Set());
-                        }
-                        rootToTestedIds.get(req.rootId).add(reqId);
-                    }
-                }
-                // Build requirements array with one entry per unique root tree
-                const requirements = [];
-                for (const [rootId, testedIds] of rootToTestedIds) {
-                    const tree = getRequirementTree(allRequirements, rootId);
-                    const formattedTree = formatRequirementTree(tree);
-                    requirements.push({
-                        id: rootId,
-                        content: formattedTree,
-                        testedIds: Array.from(testedIds).sort(),
-                    });
-                }
-                // Get Convex config
-                // Use credentials from project (works with both file-based and env-based auth)
-                const { projectId: projId, projectSecret: projSecret } = project;
-                // Call Vercel API endpoint for test review
-                // Default to production, allow override via env var for local dev
-                const apiBaseUrl = process.env.DOTREQUIREMENTS_API_URL || 'https://app.dotrequirements.io';
-                try {
-                    const response = await fetch(`${apiBaseUrl}/api/review-test`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            projectId: projId,
-                            projectSecret: projSecret,
-                            testFileContents,
-                            requirements,
-                        }),
-                    });
-                    if (!response.ok) {
-                        const errorData = await response.json();
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: `Test review failed: ${errorData.error || response.statusText}`,
-                                },
-                            ],
-                            isError: true,
-                        };
-                    }
-                    const data = await response.json();
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `# Test Review Results for \`${testFilePath}\`\n\n${data.feedback}`,
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Test review error: ${error instanceof Error ? error.message : String(error)}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-            }
+            case 'debug_mcp_environment':
+                return handleDebugMcpEnvironment(args, handlerContext);
+            case 'search_requirements':
+                return handleSearchRequirements(args, handlerContext);
+            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':
+                return handleGetRequirementsByTest(args, handlerContext);
+            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':
+                return handleCreateRequirementDocument(args, handlerContext);
+            case 'validate_requirements':
+                return handleValidateRequirements(args, handlerContext);
+            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':
+                return handleReviewTest(args, handlerContext, { apiBaseUrl: process.env.DOTREQUIREMENTS_API_URL });
             default:
                 return {
                     content: [
@@ -1786,5 +620,8 @@ async function main() {
     console.error('process.cwd():', process.cwd());
     console.error('REQUIREMENTS_DIR env:', process.env.REQUIREMENTS_DIR);
 }
-main().catch(console.error);
+// Only run when executed directly, not when imported (enables InMemoryTransport testing)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(console.error);
+}
 //# sourceMappingURL=index.js.map