@popoverai/dotrequirements 0.24.0 → 0.24.2

package/dist/mcp/grep.js

@@ -1,306 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-/**
- * Check if ripgrep is available
- */
-async function hasRipgrep() {
-    try {
-        await execFileAsync("rg", ["--version"]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Find all test files that reference a specific requirement ID
- *
- * Uses execFile with array arguments to avoid command injection vulnerabilities.
- */
-export async function findTestsForRequirement(workspaceRoot, requirementId) {
-    const useRg = await hasRipgrep();
-    // Escape special regex characters in the ID
-    const escapedId = requirementId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    // Pattern to match requirement('ID'), requirement("ID"), or requirement(`ID`)
-    const pattern = `requirement\\s*\\(\\s*['"\`]${escapedId}`;
-    try {
-        let output;
-        if (useRg) {
-            // Use ripgrep for better performance
-            // Using execFile with array args to avoid shell injection
-            const { stdout } = await execFileAsync("rg", [
-                "-n",
-                "--column",
-                pattern,
-                "--type",
-                "ts",
-                "--type",
-                "js",
-                "--type",
-                "tsx",
-                "--type",
-                "jsx",
-                workspaceRoot,
-            ], { maxBuffer: 10 * 1024 * 1024 }).catch(() => ({ stdout: "" })); // ripgrep returns non-zero on no matches
-            output = stdout;
-        }
-        else {
-            // Fall back to grep using execFile
-            const { stdout } = await execFileAsync("grep", [
-                "-rn",
-                "--include=*.ts",
-                "--include=*.tsx",
-                "--include=*.js",
-                "--include=*.jsx",
-                "-E",
-                pattern,
-                workspaceRoot,
-            ], { maxBuffer: 10 * 1024 * 1024 }).catch(() => ({ stdout: "" })); // grep returns non-zero on no matches
-            output = stdout;
-        }
-        return parseGrepOutput(output, requirementId, useRg);
-    }
-    catch (error) {
-        // Grep returns exit code 1 when no matches found
-        return [];
-    }
-}
-/**
- * Find all requirement references in a specific file using AST parsing
- */
-export async function findRequirementsInFile(filePath) {
-    const { parse } = await import("@babel/parser");
-    const traverse = await import("@babel/traverse");
-    const t = await import("@babel/types");
-    const fs = await import("node:fs");
-    const pathModule = await import("node:path");
-    const results = [];
-    // Resolve relative paths from current working directory
-    let resolvedPath = pathModule.isAbsolute(filePath)
-        ? filePath
-        : pathModule.resolve(process.cwd(), filePath);
-    // If file doesn't exist and path is relative, try resolving from CLI package root
-    if (!pathModule.isAbsolute(filePath) && !fs.existsSync(resolvedPath)) {
-        const cliPackageRoot = pathModule.resolve(__dirname, "../..");
-        const alternativePath = pathModule.resolve(cliPackageRoot, filePath);
-        if (fs.existsSync(alternativePath)) {
-            resolvedPath = alternativePath;
-        }
-    }
-    try {
-        const code = fs.readFileSync(resolvedPath, "utf-8");
-        const ast = parse(code, {
-            sourceType: "module",
-            plugins: ["typescript", "jsx"],
-            errorRecovery: true,
-        });
-        // Handle both ES module and CommonJS exports for traverse
-        // biome-ignore lint/suspicious/noExplicitAny: @babel/traverse ships a CJS default-export that's a callable, with .default property nested 1-2 levels. The interop dance requires escaping the function-vs-namespace type wall.
-        let traverseFunc = traverse;
-        if (typeof traverseFunc !== "function") {
-            traverseFunc = traverseFunc.default;
-        }
-        if (typeof traverseFunc !== "function") {
-            traverseFunc = traverseFunc.default;
-        }
-        traverseFunc(ast, {
-            // biome-ignore lint/suspicious/noExplicitAny: babel-traverse visitor `path` is a deeply-generic NodePath whose precise type depends on what handler you're inside; `any` is the documented practice for plugin code.
-            CallExpression(path) {
-                const callee = path.node.callee;
-                // Check if this is a requirement() call
-                if (t.isIdentifier(callee) && callee.name === "requirement") {
-                    const args = path.node.arguments;
-                    const loc = path.node.loc;
-                    // Extract all string literal arguments (supports multi-requirement calls)
-                    for (const arg of args) {
-                        if (t.isStringLiteral(arg)) {
-                            const requirementId = arg.value;
-                            if (loc) {
-                                results.push({
-                                    file: resolvedPath,
-                                    line: loc.start.line,
-                                    column: loc.start.column + 1, // 1-indexed
-                                    requirementId,
-                                    context: code.split("\n")[loc.start.line - 1] || "",
-                                });
-                            }
-                        }
-                    }
-                }
-            },
-        });
-        return results;
-    }
-    catch (error) {
-        return [];
-    }
-}
-/**
- * Find all requirement references in the entire workspace
- *
- * Uses execFile with array arguments to avoid command injection vulnerabilities.
- */
-export async function findAllTestReferences(workspaceRoot) {
-    const useRg = await hasRipgrep();
-    // Pattern to match any requirement() call
-    const pattern = `requirement\\s*\\(\\s*['"\`][^'"\`]+`;
-    try {
-        let output;
-        if (useRg) {
-            // Using execFile with array args to avoid shell injection
-            const { stdout } = await execFileAsync("rg", [
-                "-n",
-                "--column",
-                pattern,
-                "--type",
-                "ts",
-                "--type",
-                "js",
-                "--type",
-                "tsx",
-                "--type",
-                "jsx",
-                workspaceRoot,
-            ], { maxBuffer: 10 * 1024 * 1024 }).catch(() => ({ stdout: "" })); // ripgrep returns non-zero on no matches
-            output = stdout;
-        }
-        else {
-            const { stdout } = await execFileAsync("grep", [
-                "-rn",
-                "--include=*.ts",
-                "--include=*.tsx",
-                "--include=*.js",
-                "--include=*.jsx",
-                "-E",
-                pattern,
-                workspaceRoot,
-            ], { maxBuffer: 10 * 1024 * 1024 }).catch(() => ({ stdout: "" })); // grep returns non-zero on no matches
-            output = stdout;
-        }
-        return parseGrepOutput(output, "", useRg);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Parse grep/ripgrep output into TestReference objects
- */
-function parseGrepOutput(output, expectedId, isRipgrep, singleFilePath) {
-    const results = [];
-    const lines = output.trim().split("\n").filter(Boolean);
-    for (const line of lines) {
-        let match;
-        let file;
-        let lineNum;
-        let column;
-        let context;
-        if (isRipgrep) {
-            // ripgrep format: file:line:column:content
-            match = line.match(/^(.+?):(\d+):(\d+):(.*)$/);
-            if (!match)
-                continue;
-            file = match[1];
-            lineNum = parseInt(match[2], 10);
-            column = parseInt(match[3], 10);
-            context = match[4];
-        }
-        else {
-            // grep format: file:line:content (no column)
-            if (singleFilePath) {
-                match = line.match(/^(\d+):(.*)$/);
-                if (!match)
-                    continue;
-                file = singleFilePath;
-                lineNum = parseInt(match[1], 10);
-                context = match[2];
-                column = 1;
-            }
-            else {
-                match = line.match(/^(.+?):(\d+):(.*)$/);
-                if (!match)
-                    continue;
-                file = match[1];
-                lineNum = parseInt(match[2], 10);
-                context = match[3];
-                column = 1;
-            }
-        }
-        // Extract the requirement ID from the context
-        const idMatch = context.match(/requirement\s*\(\s*['"`]([^'"`]+)/);
-        const requirementId = idMatch ? idMatch[1] : expectedId;
-        results.push({
-            file,
-            line: lineNum,
-            column,
-            requirementId,
-            context: context.trim(),
-        });
-    }
-    return results;
-}
-/**
- * Get all unique requirement IDs referenced in tests
- * Normalizes child IDs (e.g., AUTH-VALID-LOGIN.0) to root IDs (e.g., AUTH-VALID-LOGIN)
- * Uses AST parsing instead of grep for reliability across environments
- */
-export async function getReferencedRequirementIds(workspaceRoot) {
-    const { glob } = await import("glob");
-    const { parse } = await import("@babel/parser");
-    const traverse = await import("@babel/traverse");
-    const t = await import("@babel/types");
-    const fs = await import("node:fs");
-    // Find all test files using glob (same pattern as get_requirement tool)
-    const testFiles = await glob("**/*.{test,spec}.{js,jsx,ts,tsx}", {
-        cwd: workspaceRoot,
-        absolute: true,
-        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
-    });
-    const allRequirementIds = [];
-    // For each test file, parse AST and extract requirement IDs
-    for (const file of testFiles) {
-        try {
-            const code = fs.readFileSync(file, "utf-8");
-            const ast = parse(code, {
-                sourceType: "module",
-                plugins: ["typescript", "jsx"],
-                errorRecovery: true,
-            });
-            // Handle both ES module and CommonJS exports for traverse
-            // @babel/traverse can be imported as: traverse.default.default in compiled code
-            // biome-ignore lint/suspicious/noExplicitAny: see earlier comment on babel/traverse CJS/ESM interop
-            let traverseFunc = traverse;
-            if (typeof traverseFunc !== "function") {
-                traverseFunc = traverseFunc.default;
-            }
-            if (typeof traverseFunc !== "function") {
-                traverseFunc = traverseFunc.default;
-            }
-            traverseFunc(ast, {
-                // biome-ignore lint/suspicious/noExplicitAny: babel-traverse visitor `path` is a deeply-generic NodePath whose precise type depends on what handler you're inside; `any` is the documented practice for plugin code.
-                CallExpression(path) {
-                    const callee = path.node.callee;
-                    // Check if this is a requirement() call
-                    if (t.isIdentifier(callee) && callee.name === "requirement") {
-                        const args = path.node.arguments;
-                        // Extract all string literal arguments (supports multi-requirement calls)
-                        for (const arg of args) {
-                            if (t.isStringLiteral(arg)) {
-                                allRequirementIds.push(arg.value);
-                            }
-                        }
-                    }
-                },
-            });
-        }
-        catch (error) { }
-    }
-    // Extract root IDs by removing the path suffix (everything after the first dot)
-    const rootIds = allRequirementIds.map((id) => {
-        const dotIndex = id.indexOf(".");
-        return dotIndex > 0 ? id.substring(0, dotIndex) : id;
-    });
-    return new Set(rootIds);
-}
-//# sourceMappingURL=grep.js.map

package/dist/mcp/handlers/coverage.d.ts

@@ -1,44 +0,0 @@
-/**
- * Coverage handlers for MCP tools
- *
- * Provides cloud coverage query functionality:
- * - get_requirement_coverage: Coverage for a specific requirement
- * - get_project_coverage_summary: Project-wide coverage summary
- */
-import type { HandlerContext, ToolResponse } from "./types.js";
-/**
- * Arguments for get_requirement_coverage tool
- */
-export interface GetRequirementCoverageArgs {
-    requirementKey: string;
-    projectId?: string;
-}
-/**
- * Arguments for get_project_coverage_summary tool
- */
-export interface GetProjectCoverageSummaryArgs {
-    branch?: string;
-    sinceTimestamp?: number;
-    projectId?: string;
-}
-/**
- * Handler for get_requirement_coverage tool
- *
- * Requirements covered:
- * - MCP-COVERAGE-1.0: When credentials are valid, the response shows when the requirement was last tested
- * - MCP-COVERAGE-1.1: The response includes the most recent branch and test file where coverage was recorded
- * - MCP-COVERAGE-1.2: When the requirement has no coverage records, the response indicates this
- * - MCP-COVERAGE-1.3: When credentials are missing or invalid, an error explains how to authenticate
- */
-export declare function handleGetRequirementCoverage(args: GetRequirementCoverageArgs, context: HandlerContext): Promise<ToolResponse>;
-/**
- * Handler for get_project_coverage_summary tool
- *
- * Requirements covered:
- * - MCP-COVERAGE-2.0: The response summarizes which requirements have been tested and which have not
- * - MCP-COVERAGE-2.1: When a branch filter is provided, coverage results include only records from that branch
- * - MCP-COVERAGE-2.2: When sinceTimestamp is provided, only coverage recorded after that time is included
- * - MCP-COVERAGE-2.3: When credentials are missing or invalid, an error explains how to authenticate
- */
-export declare function handleGetProjectCoverageSummary(args: GetProjectCoverageSummaryArgs, context: HandlerContext): Promise<ToolResponse>;
-//# sourceMappingURL=coverage.d.ts.map

package/dist/mcp/handlers/coverage.js

@@ -1,103 +0,0 @@
-/**
- * Coverage handlers for MCP tools
- *
- * Provides cloud coverage query functionality:
- * - get_requirement_coverage: Coverage for a specific requirement
- * - get_project_coverage_summary: Project-wide coverage summary
- */
-import { CONVEX_URL, getProjectCoverage as queryProjectCoverage, getRequirementCoverage as queryRequirementCoverage, } from "../convexClient.js";
-import { errorResponse, textResponse } from "./types.js";
-/**
- * Handler for get_requirement_coverage tool
- *
- * Requirements covered:
- * - MCP-COVERAGE-1.0: When credentials are valid, the response shows when the requirement was last tested
- * - MCP-COVERAGE-1.1: The response includes the most recent branch and test file where coverage was recorded
- * - MCP-COVERAGE-1.2: When the requirement has no coverage records, the response indicates this
- * - MCP-COVERAGE-1.3: When credentials are missing or invalid, an error explains how to authenticate
- */
-export async function handleGetRequirementCoverage(args, context) {
-    const { requirementKey, projectId } = args;
-    // MCP-COVERAGE-1.3: Get project credentials (throws if not configured)
-    let project;
-    try {
-        project = await context.getProjectFromDiscovery(projectId);
-    }
-    catch (error) {
-        return errorResponse(`Coverage query requires project credentials. Run \`dotrequirements link\` to connect to cloud.\n\nError: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    // Query cloud for coverage
-    const coverage = await queryRequirementCoverage(requirementKey, project.projectId, project.projectSecret, CONVEX_URL);
-    // MCP-COVERAGE-1.2: No coverage records
-    if (!coverage.lastTestedAt) {
-        return textResponse(`**${requirementKey}** has not been tested yet.`);
-    }
-    // MCP-COVERAGE-1.0: Show when requirement was last tested
-    const lastTested = new Date(coverage.lastTestedAt);
-    // MCP-COVERAGE-1.1: Include branch and test file
-    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 textResponse(`# Coverage for ${requirementKey}\n\n**Last Tested:** ${lastTested.toISOString()}${branchInfo}${testLocation}`);
-}
-/**
- * Handler for get_project_coverage_summary tool
- *
- * Requirements covered:
- * - MCP-COVERAGE-2.0: The response summarizes which requirements have been tested and which have not
- * - MCP-COVERAGE-2.1: When a branch filter is provided, coverage results include only records from that branch
- * - MCP-COVERAGE-2.2: When sinceTimestamp is provided, only coverage recorded after that time is included
- * - MCP-COVERAGE-2.3: When credentials are missing or invalid, an error explains how to authenticate
- */
-export async function handleGetProjectCoverageSummary(args, context) {
-    const { branch, sinceTimestamp, projectId } = args;
-    // MCP-COVERAGE-2.3: Get project credentials (throws if not configured)
-    let project;
-    try {
-        project = await context.getProjectFromDiscovery(projectId);
-    }
-    catch (error) {
-        return errorResponse(`Coverage query requires project credentials. Run \`dotrequirements link\` to connect to cloud.\n\nError: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    // Query cloud for project coverage with optional filters
-    const coverage = await queryProjectCoverage(project.projectId, project.projectSecret, CONVEX_URL, { branch, sinceTimestamp });
-    // MCP-COVERAGE-2.0: Calculate and display coverage summary
-    const total = coverage.tested.length + coverage.untested.length;
-    const percentage = total > 0 ? ((coverage.tested.length / total) * 100).toFixed(1) : "0.0";
-    // MCP-COVERAGE-2.1 & MCP-COVERAGE-2.2: Show filter info if provided
-    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 textResponse(`# Project Coverage Summary\n\n**Total Requirements:** ${total}\n**Coverage:** ${percentage}%${filterInfo}${testedSection}${untestedSection}`);
-}
-//# sourceMappingURL=coverage.js.map

package/dist/mcp/requirements.d.ts

@@ -1,57 +0,0 @@
-import { type Metadata, type RequirementNode } from "../schema/index.js";
-import type { FlattenedRequirement } from "./types.js";
-/**
- * Parsed requirements file
- */
-export interface ParsedRequirementsFile {
-    metadata: Metadata;
-    requirements: RequirementNode[];
-}
-/**
- * Find all *.requirements.md files in the workspace.
- * Supports both .requirements/ directories and colocated files.
- * Excludes example files, test fixtures, and build artifacts.
- */
-export declare function findRequirementsFiles(workspaceRoot: string): Promise<string[]>;
-/**
- * Load all requirements from the workspace
- */
-export declare function loadAllRequirements(workspaceRoot: string): Promise<{
-    files: ParsedRequirementsFile[];
-    flattened: FlattenedRequirement[];
-}>;
-/**
- * Flatten a requirements file into searchable requirements
- */
-export declare function flattenRequirementsFile(file: ParsedRequirementsFile, sourceFile: string): FlattenedRequirement[];
-/**
- * Search requirements by text query
- */
-export declare function searchRequirements(requirements: FlattenedRequirement[], query: string): FlattenedRequirement[];
-/**
- * Get a specific requirement by ID (supports partial matching)
- */
-export declare function getRequirementById(requirements: FlattenedRequirement[], id: string): FlattenedRequirement | undefined;
-/**
- * Get a requirement and all its children
- */
-export declare function getRequirementTree(requirements: FlattenedRequirement[], rootId: string): FlattenedRequirement[];
-/**
- * Format a requirement for display
- */
-export declare function formatRequirement(req: FlattenedRequirement): string;
-/**
- * Filter a requirements file's content to only include specified requirement keys.
- * Parses the file content, filters top-level requirements by key, and rebuilds as
- * markdown requirement blocks (without frontmatter).
- */
-export declare function filterRequirementsByKeys(fileContents: string, keys: string[]): {
-    filteredContent: string;
-    foundKeys: string[];
-    missingKeys: string[];
-};
-/**
- * Format a requirement tree for display
- */
-export declare function formatRequirementTree(requirements: FlattenedRequirement[]): string;
-//# sourceMappingURL=requirements.d.ts.map

package/dist/mcp/requirements.js

@@ -1,155 +0,0 @@
-import * as path from "node:path";
-import { glob } from "glob";
-import { buildRequirementMarkdown, getAllRequirements, parseRequirementsFile, parseRequirementsFromFile, } from "../schema/index.js";
-/**
- * Find all *.requirements.md files in the workspace.
- * Supports both .requirements/ directories and colocated files.
- * Excludes example files, test fixtures, and build artifacts.
- */
-export async function findRequirementsFiles(workspaceRoot) {
-    const pattern = "**/*.requirements.md";
-    const matches = await glob(pattern, {
-        cwd: workspaceRoot,
-        ignore: [
-            "**/node_modules/**",
-            "**/dist/**",
-            "**/.git/**",
-            "**/build/**",
-            // Exclude example and test fixture directories
-            "**/example/**",
-            "**/examples/**",
-            "**/__tests__/**",
-            "**/fixtures/**",
-            "**/.fixtures/**",
-        ],
-        dot: true, // Include dotfiles/dotdirs like .requirements/
-    });
-    return matches.map((m) => path.join(workspaceRoot, m));
-}
-/**
- * Load all requirements from the workspace
- */
-export async function loadAllRequirements(workspaceRoot) {
-    const filePaths = await findRequirementsFiles(workspaceRoot);
-    const allFiles = [];
-    const allFlattened = [];
-    for (const filePath of filePaths) {
-        try {
-            const parsed = parseRequirementsFromFile(filePath);
-            allFiles.push(parsed);
-            const flattened = flattenRequirementsFile(parsed, filePath);
-            allFlattened.push(...flattened);
-        }
-        catch (error) {
-            // Skip invalid files
-            console.error(`Failed to parse ${filePath}:`, error);
-        }
-    }
-    return { files: allFiles, flattened: allFlattened };
-}
-/**
- * Flatten a requirements file into searchable requirements
- */
-export function flattenRequirementsFile(file, sourceFile) {
-    const results = [];
-    // Use shared utility to get all requirements (flattened)
-    const allReqs = getAllRequirements(file.requirements);
-    for (const req of allReqs) {
-        // Extract position from ID (e.g., "REQ123.0.1" -> "0.1")
-        const idParts = req.id.split(".");
-        const rootId = idParts[0];
-        const position = idParts.slice(1).join(".");
-        results.push({
-            id: req.id,
-            rootId: rootId,
-            label: req.label,
-            content: req.content,
-            path: idParts.slice(1), // ["0", "1"] for "REQ123.0.1"
-            sourceFile: sourceFile,
-            documentTitle: file.metadata.document?.title || rootId,
-        });
-    }
-    return results;
-}
-/**
- * Search requirements by text query
- */
-export function searchRequirements(requirements, query) {
-    const lowerQuery = query.toLowerCase();
-    return requirements.filter((req) => {
-        // Search in ID
-        if (req.id.toLowerCase().includes(lowerQuery))
-            return true;
-        // Search in content
-        if (req.content.toLowerCase().includes(lowerQuery))
-            return true;
-        // Search in label
-        if (req.label.toLowerCase().includes(lowerQuery))
-            return true;
-        return false;
-    });
-}
-/**
- * Get a specific requirement by ID (supports partial matching)
- */
-export function getRequirementById(requirements, id) {
-    // Exact match first
-    const exact = requirements.find((r) => r.id === id);
-    if (exact)
-        return exact;
-    // Try partial match (just the root ID)
-    return requirements.find((r) => r.rootId === id || r.id.startsWith(`${id}.`));
-}
-/**
- * Get a requirement and all its children
- */
-export function getRequirementTree(requirements, rootId) {
-    return requirements.filter((r) => r.rootId === rootId || r.id === rootId);
-}
-/**
- * Format a requirement for display
- */
-export function formatRequirement(req) {
-    const indent = "  ".repeat(req.path.length);
-    const label = req.label ? ` (${req.label})` : "";
-    return `${indent}${req.id}${label}: ${req.content}`;
-}
-/**
- * Filter a requirements file's content to only include specified requirement keys.
- * Parses the file content, filters top-level requirements by key, and rebuilds as
- * markdown requirement blocks (without frontmatter).
- */
-export function filterRequirementsByKeys(fileContents, keys) {
-    const { requirements } = parseRequirementsFile(fileContents);
-    const upperKeys = keys.map((k) => k.toUpperCase());
-    const filtered = requirements.filter((r) => upperKeys.includes(r.id.toUpperCase()));
-    const foundKeys = filtered.map((r) => r.id);
-    const missingKeys = upperKeys.filter((k) => !foundKeys.map((f) => f.toUpperCase()).includes(k));
-    const filteredContent = filtered.map(buildRequirementMarkdown).join("\n");
-    return { filteredContent, foundKeys, missingKeys };
-}
-/**
- * Format a requirement tree for display
- */
-export function formatRequirementTree(requirements) {
-    // Sort by path to maintain hierarchy - children appear immediately after parent
-    const sorted = [...requirements].sort((a, b) => {
-        // Compare paths element by element for proper tree order
-        const maxLen = Math.max(a.path.length, b.path.length);
-        for (let i = 0; i < maxLen; i++) {
-            const aVal = i < a.path.length ? parseInt(a.path[i], 10) : -1;
-            const bVal = i < b.path.length ? parseInt(b.path[i], 10) : -1;
-            // If one path is a prefix of the other, the shorter one comes first
-            if (aVal === -1)
-                return -1;
-            if (bVal === -1)
-                return 1;
-            if (aVal !== bVal) {
-                return aVal - bVal;
-            }
-        }
-        return 0;
-    });
-    return sorted.map(formatRequirement).join("\n");
-}
-//# sourceMappingURL=requirements.js.map

package/dist/mcp/testCodeExtractor.d.ts

@@ -1,22 +0,0 @@
-/**
- * Extract test code context using @babel/parser AST traversal.
- *
- * Finds requirement() call references and extracts the enclosing
- * meaningful code block (function, describe, test, etc.)
- */
-export interface TestCodeReference {
-    file: string;
-    startLine: number;
-    endLine: number;
-    code: string;
-    requirementId: string;
-}
-/**
- * Find all test code blocks that reference a specific requirement
- */
-export declare function findTestCodeForRequirement(filePath: string, requirementId: string): TestCodeReference[];
-/**
- * Find all files that reference a requirement
- */
-export declare function findFilesWithRequirement(files: string[], requirementId: string): string[];
-//# sourceMappingURL=testCodeExtractor.d.ts.map