@popoverai/dotrequirements 0.23.0 → 0.24.0

package/dist/harness/requirementsLoader.d.ts

@@ -7,8 +7,8 @@
  * 2. DOTREQUIREMENTS_PROJECT_ROOT environment variable
  * 3. Cached project root file (.requirements/.cache/project-root) written by prepare()
  */
-import { type RequirementNode } from '../schema/index.js';
-import { Requirement } from './types.js';
+import { type RequirementNode } from "../schema/index.js";
+import type { Requirement } from "./types.js";
 export declare const loadedRequirements: Map<string, RequirementNode>;
 export interface LoadOptions {
     /** Explicit project root path. Takes precedence over env var and cached file. */

package/dist/harness/requirementsLoader.js

@@ -7,11 +7,11 @@
  * 2. DOTREQUIREMENTS_PROJECT_ROOT environment variable
  * 3. Cached project root file (.requirements/.cache/project-root) written by prepare()
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import { globSync } from 'glob';
-import { parseRequirementsFromFile, resolveRequirementPath, } from '../schema/index.js';
-import { findCachedProjectRoot, readLookupCache, } from './cache.js';
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { findRequirementsFilesSync } from "../requirements/index.js";
+import { parseRequirementsFromFile, resolveRequirementPath, } from "../schema/index.js";
+import { findCachedProjectRoot, readLookupCache } from "./cache.js";
 // Cache: Maps full requirement IDs (e.g., "REQ-123.0.1") to RequirementNode
 export const loadedRequirements = new Map();
 // Cache: Maps root requirement IDs (e.g., "REQ-123") to their tree
@@ -36,34 +36,12 @@ function findProjectRoot(options = {}) {
     // Priority 3: Cached file (written by prepare())
     return findCachedProjectRoot(process.cwd());
 }
-/**
- * Find all *.requirements.md files under project root synchronously.
- */
-function findRequirementsFilesSync(projectRoot) {
-    const pattern = '**/*.requirements.md';
-    const matches = globSync(pattern, {
-        cwd: projectRoot,
-        ignore: [
-            '**/node_modules/**',
-            '**/dist/**',
-            '**/.git/**',
-            '**/build/**',
-            '**/example/**',
-            '**/examples/**',
-            '**/__tests__/**',
-            '**/fixtures/**',
-            '**/.fixtures/**',
-        ],
-        dot: true, // Include dotfiles/dotdirs like .requirements/
-    });
-    return matches.map(m => path.join(projectRoot, m));
-}
 /**
  * Try to load requirements from lookup cache (fast path).
  * Returns true if cache was loaded, false if not available.
  */
 function tryLoadFromCache(projectRoot) {
-    const requirementsDir = path.join(projectRoot, '.requirements');
+    const requirementsDir = path.join(projectRoot, ".requirements");
     if (!fs.existsSync(requirementsDir)) {
         return false;
     }
@@ -82,7 +60,7 @@ function tryLoadFromCache(projectRoot) {
         };
         loadedRequirements.set(id, node);
         // If this is a root node (no dot in ID), add to trees cache
-        if (!id.includes('.')) {
+        if (!id.includes(".")) {
             requirementTrees.set(id, node);
         }
     }
@@ -96,7 +74,7 @@ function flattenRequirementTree(node) {
     // Add this node to the flat cache
     loadedRequirements.set(node.id, node);
     // If this is a root node (no dot in ID), also add to trees cache
-    if (!node.id.includes('.')) {
+    if (!node.id.includes(".")) {
         requirementTrees.set(node.id, node);
     }
     // Recursively add children
@@ -119,8 +97,8 @@ export function loadRequirements(options = {}) {
     // Find project root
     const projectRoot = findProjectRoot(options);
     if (!projectRoot) {
-        throw new Error('Could not find project root. ' +
-            'Set DOTREQUIREMENTS_PROJECT_ROOT environment variable or run prepare() in globalSetup.');
+        throw new Error("Could not find project root. " +
+            "Set DOTREQUIREMENTS_PROJECT_ROOT environment variable or run prepare() in globalSetup.");
     }
     // Try cache first (fast path)
     if (tryLoadFromCache(projectRoot)) {
@@ -128,8 +106,8 @@ export function loadRequirements(options = {}) {
     }
     // Fallback: Parse .requirements.md files on-demand
     if (!warnedAboutFallback && !options.projectRoot) {
-        console.warn('⚠️  Performance warning: prepare() was not called. ' +
-            'Parsing requirements on-demand. Run prepare() in globalSetup for faster tests.');
+        console.warn("⚠️  Performance warning: prepare() was not called. " +
+            "Parsing requirements on-demand. Run prepare() in globalSetup for faster tests.");
         warnedAboutFallback = true;
     }
     // Find all .requirements.md files under the project root
@@ -144,7 +122,7 @@ export function loadRequirements(options = {}) {
             }
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
             console.error(`Error loading ${file}:`, errorMessage);
         }
     }

package/dist/harness/tracking.js

@@ -6,8 +6,8 @@
  *
  * HARNESS-REQUIREMENT-3: Each requirement() call is recorded for coverage reporting
  */
-import * as path from 'path';
-import { findRequirementsDir, findProjectRoot, getTestRunId, appendTrackingEntry, getCacheDir, initTestRunId, clearTrackingFile, } from './cache.js';
+import * as path from "node:path";
+import { appendTrackingEntry, clearTrackingFile, findProjectRoot, findRequirementsDir, getCacheDir, getTestRunId, initTestRunId, } from "./cache.js";
 const trackedRequirements = new Map();
 // Test run tracking
 let testRunId = null;
@@ -17,7 +17,7 @@ export function ensureTestRun() {
     if (!testRunId) {
         // Priority 1: Use environment variable (cross-process persistence from globalSetup)
         if (process.env.DOTREQUIREMENTS_PROJECT_ROOT) {
-            requirementsDirCached = path.join(process.env.DOTREQUIREMENTS_PROJECT_ROOT, '.requirements');
+            requirementsDirCached = path.join(process.env.DOTREQUIREMENTS_PROJECT_ROOT, ".requirements");
         }
         // Priority 2: Find from caller directory
         if (!requirementsDirCached) {
@@ -29,7 +29,7 @@ export function ensureTestRun() {
             }
         }
         if (!requirementsDirCached) {
-            throw new Error('Could not find .requirements directory. Please create one in your project root.');
+            throw new Error("Could not find .requirements directory. Please create one in your project root.");
         }
         // Try to read from shared test run ID file (set by prepare())
         const existingRunId = getTestRunId(requirementsDirCached);
@@ -48,14 +48,14 @@ export function ensureTestRun() {
 // Get caller location for tracking
 export function getCallerLocation() {
     const error = new Error();
-    const stack = error.stack?.split('\n') || [];
+    const stack = error.stack?.split("\n") || [];
     // Find the first stack frame that's not in our library files
     for (let i = 2; i < stack.length; i++) {
         const frame = stack[i];
-        if (!frame.includes('/harness/index.ts') &&
-            !frame.includes('/harness/index.js') &&
-            !frame.includes('/harness/tracking.ts') &&
-            !frame.includes('/harness/tracking.js')) {
+        if (!frame.includes("/harness/index.ts") &&
+            !frame.includes("/harness/index.js") &&
+            !frame.includes("/harness/tracking.ts") &&
+            !frame.includes("/harness/tracking.js")) {
             // Extract filename and line number
             const regex1 = /\((.+):(\d+):(\d+)\)/;
             const regex2 = /at (.+):(\d+):(\d+)/;
@@ -67,19 +67,19 @@ export function getCallerLocation() {
             }
         }
     }
-    return 'unknown';
+    return "unknown";
 }
 // Get caller's directory (full path) for finding .requirements
 function getCallerDirectory() {
     const error = new Error();
-    const stack = error.stack?.split('\n') || [];
+    const stack = error.stack?.split("\n") || [];
     // Find the first stack frame that's not in our library files
     for (let i = 2; i < stack.length; i++) {
         const frame = stack[i];
-        if (!frame.includes('/harness/index.ts') &&
-            !frame.includes('/harness/index.js') &&
-            !frame.includes('/harness/tracking.ts') &&
-            !frame.includes('/harness/tracking.js')) {
+        if (!frame.includes("/harness/index.ts") &&
+            !frame.includes("/harness/index.js") &&
+            !frame.includes("/harness/tracking.ts") &&
+            !frame.includes("/harness/tracking.js")) {
             // Extract filename
             const regex1 = /\((.+):(\d+):(\d+)\)/;
             const regex2 = /at (.+):(\d+):(\d+)/;
@@ -154,7 +154,7 @@ export function clearTracking() {
 export function initTestRun() {
     const projectRoot = findProjectRoot();
     if (!projectRoot) {
-        throw new Error('Could not find .requirements directory. Please create one in your project root.');
+        throw new Error("Could not find .requirements directory. Please create one in your project root.");
     }
     const reqDir = findRequirementsDir();
     // Initialize test run ID
@@ -171,9 +171,9 @@ export function initTestRun() {
 export function finalizeTestRun() {
     // Import and call the new finalize function
     // Using dynamic import to avoid circular dependencies
-    const { finalize } = require('./finalize.js');
+    const { finalize } = require("./finalize.js");
     finalize().catch((error) => {
-        console.error('Error in finalizeTestRun:', error.message);
+        console.error("Error in finalizeTestRun:", error.message);
     });
 }
 //# sourceMappingURL=tracking.js.map

package/dist/harness/types.d.ts

@@ -2,7 +2,7 @@
  * Type definitions for test harness.
  * Uses shared schema types for consistency with CLI and MCP.
  */
-import type { RequirementNode } from '../schema/index.js';
+import type { RequirementNode } from "../schema/index.js";
 export type { RequirementNode as Requirement };
 export interface CriteriaDetail {
     reqId: string;

package/dist/mcp/convexClient.d.ts

@@ -15,44 +15,5 @@ interface ConvexConfig {
  * Returns null if credentials are not configured.
  */
 export declare function loadConvexConfig(cwd?: string): ConvexConfig | null;
-/**
- * Query Convex for requirement coverage
- */
-export declare function getRequirementCoverage(requirementKey: string, projectId: string, projectSecret: string, convexUrl: string): Promise<{
-    requirementKey: string;
-    lastTestedAt: number | null;
-    branch: string | null;
-    testFile: string | null;
-    testLine: number | null;
-    allBranches: Array<{
-        branch: string;
-        lastTestedAt: number;
-        testFile?: string;
-        testLine?: number;
-    }>;
-}>;
-/**
- * Query Convex for project coverage summary
- */
-export declare function getProjectCoverage(projectId: string, projectSecret: string, convexUrl: string, options?: {
-    branch?: string;
-    sinceTimestamp?: number;
-}): Promise<{
-    tested: Array<{
-        requirementKey: string;
-        lastTestedAt: number;
-        branch: string;
-        testFile?: string;
-        testLine?: number;
-    }>;
-    untested: string[];
-}>;
-/**
- * PROJ-CONTEXT-7: Query Convex for project context (AI style guidelines)
- */
-export declare function getProjectContext(projectId: string, projectSecret: string, convexUrl: string): Promise<{
-    projectContext: string | null;
-    requirementsStyleContext: string | null;
-} | null>;
 export {};
 //# sourceMappingURL=convexClient.d.ts.map

package/dist/mcp/convexClient.js

@@ -1,8 +1,8 @@
-import { getProjectCredentials } from '../utils/project-settings.js';
+import { getProjectCredentials } from "../utils/project-settings.js";
 /**
  * Production Convex deployment URL
  */
-export const CONVEX_URL = 'https://data.dotrequirements.io';
+export const CONVEX_URL = "https://data.dotrequirements.io";
 /**
  * Load Convex configuration from project settings.
  * Returns null if credentials are not configured.
@@ -21,109 +21,4 @@ export function loadConvexConfig(cwd = process.cwd()) {
         return null;
     }
 }
-/**
- * Query Convex for requirement coverage
- */
-export async function getRequirementCoverage(requirementKey, projectId, projectSecret, convexUrl) {
-    const response = await fetch(`${convexUrl}/api/query`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            path: 'testCoverage/queries:getRequirementCoverage',
-            args: {
-                projectAuth: {
-                    projectSlug: projectId,
-                    projectSecret,
-                },
-                target: {
-                    type: 'project',
-                    slug: projectId,
-                },
-                requirementKey,
-            },
-            format: 'json',
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to query coverage: ${response.statusText}`);
-    }
-    const json = await response.json();
-    if (json.status === 'error') {
-        throw new Error(`Convex query failed: ${json.errorMessage}`);
-    }
-    return json.value;
-}
-/**
- * Query Convex for project coverage summary
- */
-export async function getProjectCoverage(projectId, projectSecret, convexUrl, options) {
-    const response = await fetch(`${convexUrl}/api/query`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            path: 'testCoverage/queries:getProjectCoverage',
-            args: {
-                projectAuth: {
-                    projectSlug: projectId,
-                    projectSecret,
-                },
-                target: {
-                    type: 'project',
-                    slug: projectId,
-                },
-                branch: options?.branch,
-                sinceTimestamp: options?.sinceTimestamp,
-            },
-            format: 'json',
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to query coverage: ${response.statusText}`);
-    }
-    const json = await response.json();
-    if (json.status === 'error') {
-        throw new Error(`Convex query failed: ${json.errorMessage}`);
-    }
-    return json.value;
-}
-/**
- * PROJ-CONTEXT-7: Query Convex for project context (AI style guidelines)
- */
-export async function getProjectContext(projectId, projectSecret, convexUrl) {
-    try {
-        const response = await fetch(`${convexUrl}/api/query`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                path: 'projects/queries:get',
-                args: {
-                    projectAuth: {
-                        projectSlug: projectId,
-                        projectSecret,
-                    },
-                    target: {
-                        type: 'project',
-                        slug: projectId,
-                    },
-                },
-                format: 'json',
-            }),
-        });
-        if (!response.ok) {
-            return null;
-        }
-        const json = await response.json();
-        if (json.status === 'error' || !json.value) {
-            return null;
-        }
-        return {
-            projectContext: json.value.projectContext ?? null,
-            requirementsStyleContext: json.value.requirementsStyleContext ?? null,
-        };
-    }
-    catch {
-        // Non-fatal: return null if query fails
-        return null;
-    }
-}
 //# sourceMappingURL=convexClient.js.map

package/dist/mcp/grep.d.ts

@@ -1,4 +1,4 @@
-import type { TestReference } from './types.js';
+import type { TestReference } from "./types.js";
 /**
  * Find all test files that reference a specific requirement ID
  *

package/dist/mcp/grep.js

@@ -1,12 +1,12 @@
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+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']);
+        await execFileAsync("rg", ["--version"]);
         return true;
     }
     catch {
@@ -21,7 +21,7 @@ async function hasRipgrep() {
 export async function findTestsForRequirement(workspaceRoot, requirementId) {
     const useRg = await hasRipgrep();
     // Escape special regex characters in the ID
-    const escapedId = requirementId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedId = requirementId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     // Pattern to match requirement('ID'), requirement("ID"), or requirement(`ID`)
     const pattern = `requirement\\s*\\(\\s*['"\`]${escapedId}`;
     try {
@@ -29,12 +29,34 @@ export async function findTestsForRequirement(workspaceRoot, requirementId) {
         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
+            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
+            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);
@@ -48,11 +70,11 @@ export async function findTestsForRequirement(workspaceRoot, requirementId) {
  * 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 { 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)
@@ -60,32 +82,34 @@ export async function findRequirementsInFile(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 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 code = fs.readFileSync(resolvedPath, "utf-8");
         const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['typescript', 'jsx'],
+            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') {
+        if (typeof traverseFunc !== "function") {
             traverseFunc = traverseFunc.default;
         }
-        if (typeof traverseFunc !== 'function') {
+        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') {
+                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)
@@ -98,7 +122,7 @@ export async function findRequirementsInFile(filePath) {
                                     line: loc.start.line,
                                     column: loc.start.column + 1, // 1-indexed
                                     requirementId,
-                                    context: code.split('\n')[loc.start.line - 1] || '',
+                                    context: code.split("\n")[loc.start.line - 1] || "",
                                 });
                             }
                         }
@@ -125,14 +149,36 @@ export async function findAllTestReferences(workspaceRoot) {
         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
+            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
+            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);
+        return parseGrepOutput(output, "", useRg);
     }
     catch {
         return [];
@@ -143,7 +189,7 @@ export async function findAllTestReferences(workspaceRoot) {
  */
 function parseGrepOutput(output, expectedId, isRipgrep, singleFilePath) {
     const results = [];
-    const lines = output.trim().split('\n').filter(Boolean);
+    const lines = output.trim().split("\n").filter(Boolean);
     for (const line of lines) {
         let match;
         let file;
@@ -200,41 +246,43 @@ function parseGrepOutput(output, expectedId, isRipgrep, singleFilePath) {
  * 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');
+    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}', {
+    const testFiles = await glob("**/*.{test,spec}.{js,jsx,ts,tsx}", {
         cwd: workspaceRoot,
         absolute: true,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+        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 code = fs.readFileSync(file, "utf-8");
             const ast = parse(code, {
-                sourceType: 'module',
-                plugins: ['typescript', 'jsx'],
+                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') {
+            if (typeof traverseFunc !== "function") {
                 traverseFunc = traverseFunc.default;
             }
-            if (typeof traverseFunc !== 'function') {
+            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') {
+                    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) {
@@ -246,14 +294,11 @@ export async function getReferencedRequirementIds(workspaceRoot) {
                 },
             });
         }
-        catch (error) {
-            // Skip unparseable files
-            continue;
-        }
+        catch (error) { }
     }
     // Extract root IDs by removing the path suffix (everything after the first dot)
-    const rootIds = allRequirementIds.map(id => {
-        const dotIndex = id.indexOf('.');
+    const rootIds = allRequirementIds.map((id) => {
+        const dotIndex = id.indexOf(".");
         return dotIndex > 0 ? id.substring(0, dotIndex) : id;
     });
     return new Set(rootIds);

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

@@ -5,7 +5,7 @@
  * - create_requirement_document: Generate requirements template with format guidance
  * - validate_requirements: Validate requirements file syntax offline
  */
-import type { HandlerContext, ToolResponse } from './types.js';
+import type { HandlerContext, ToolResponse } from "./types.js";
 /**
  * Arguments for create_requirement_document tool
  */