@popoverai/dotrequirements 0.11.0

package/dist/mcp/grep.js

@@ -0,0 +1,261 @@
+import { execFile } from 'child_process';
+import { promisify } from '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('fs');
+    const pathModule = await import('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
+        let traverseFunc = traverse;
+        if (typeof traverseFunc !== 'function') {
+            traverseFunc = traverseFunc.default;
+        }
+        if (typeof traverseFunc !== 'function') {
+            traverseFunc = traverseFunc.default;
+        }
+        traverseFunc(ast, {
+            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('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
+            let traverseFunc = traverse;
+            if (typeof traverseFunc !== 'function') {
+                traverseFunc = traverseFunc.default;
+            }
+            if (typeof traverseFunc !== 'function') {
+                traverseFunc = traverseFunc.default;
+            }
+            traverseFunc(ast, {
+                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) {
+            // Skip unparseable files
+            continue;
+        }
+    }
+    // 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/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map