@popoverai/dotrequirements 0.23.0 → 0.24.0

package/dist/harness/cache.js

@@ -6,25 +6,26 @@
  * - tracking.jsonl: Append-only tracking of requirement() calls (cross-process safe)
  * - coverage.json: Deduplication cache for cloud reporting
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import { globSync } from 'glob';
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { findRequirementsFilesSync } from "../requirements/index.js";
 // Cache directory structure
-const CACHE_DIR = '.cache';
-const LOOKUP_FILE = 'lookup.json';
-const TRACKING_FILE = 'tracking.jsonl';
-const COVERAGE_FILE = 'coverage.json';
-const PROJECT_ROOT_FILE = 'project-root';
+const CACHE_DIR = ".cache";
+const LOOKUP_FILE = "lookup.json";
+const TRACKING_FILE = "tracking.jsonl";
+const COVERAGE_FILE = "coverage.json";
+const PROJECT_ROOT_FILE = "project-root";
 // Test run ID file (outside cache, in .requirements/)
-const TEST_RUN_ID_FILE = '.test-run-id';
+const TEST_RUN_ID_FILE = ".test-run-id";
 /**
  * Find the nearest .requirements directory by walking up from startDir
  */
 export function findRequirementsDir(startDir = process.cwd()) {
     let currentDir = path.resolve(startDir);
     while (true) {
-        const requirementsDir = path.join(currentDir, '.requirements');
-        if (fs.existsSync(requirementsDir) && fs.statSync(requirementsDir).isDirectory()) {
+        const requirementsDir = path.join(currentDir, ".requirements");
+        if (fs.existsSync(requirementsDir) &&
+            fs.statSync(requirementsDir).isDirectory()) {
             return requirementsDir;
         }
         const parentDir = path.dirname(currentDir);
@@ -52,28 +53,6 @@ export function getCacheDir(requirementsDir, create = false) {
     }
     return cacheDir;
 }
-/**
- * Find all *.requirements.md files under project root
- */
-export function findRequirementsFiles(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));
-}
 /**
  * Write the lookup cache with all pre-parsed requirements
  */
@@ -101,14 +80,15 @@ export function writeLookupCache(requirementsDir, requirements) {
         const labelCounts = new Map();
         for (const child of node.children) {
             let childLabelPath = null;
-            if (child.label && child.label !== 'requirementHeader') {
-                const normalizedLabel = child.label.toLowerCase().replace(/\s+/g, '-');
+            if (child.label && child.label !== "requirementHeader") {
+                const normalizedLabel = child.label.toLowerCase().replace(/\s+/g, "-");
                 const count = labelCounts.get(normalizedLabel) || 0;
                 labelCounts.set(normalizedLabel, count + 1);
                 const parentPath = labelPath || node.id;
-                childLabelPath = count === 0
-                    ? `${parentPath}.${normalizedLabel}`
-                    : `${parentPath}.${normalizedLabel}#${count}`;
+                childLabelPath =
+                    count === 0
+                        ? `${parentPath}.${normalizedLabel}`
+                        : `${parentPath}.${normalizedLabel}#${count}`;
             }
             flatten(child, childLabelPath);
         }
@@ -124,7 +104,7 @@ export function writeLookupCache(requirementsDir, requirements) {
  */
 export function isCacheStale(requirementsDir, cacheMtime) {
     const projectRoot = path.dirname(requirementsDir);
-    const sourceFiles = findRequirementsFiles(projectRoot);
+    const sourceFiles = findRequirementsFilesSync(projectRoot);
     for (const file of sourceFiles) {
         try {
             const stat = fs.statSync(file);
@@ -159,7 +139,7 @@ export function readLookupCache(requirementsDir) {
         return null;
     }
     try {
-        const content = fs.readFileSync(lookupPath, 'utf-8');
+        const content = fs.readFileSync(lookupPath, "utf-8");
         return JSON.parse(content);
     }
     catch {
@@ -183,7 +163,7 @@ export function getTestRunId(requirementsDir) {
     if (!fs.existsSync(testRunIdPath)) {
         return null;
     }
-    return fs.readFileSync(testRunIdPath, 'utf-8').trim();
+    return fs.readFileSync(testRunIdPath, "utf-8").trim();
 }
 /**
  * Clean up the test run ID file
@@ -212,7 +192,7 @@ export function readProjectRoot(requirementsDir) {
     if (!fs.existsSync(projectRootPath)) {
         return null;
     }
-    return fs.readFileSync(projectRootPath, 'utf-8').trim();
+    return fs.readFileSync(projectRootPath, "utf-8").trim();
 }
 /**
  * Try to find the project root from any known .requirements cache directory.
@@ -221,10 +201,10 @@ export function readProjectRoot(requirementsDir) {
 export function findCachedProjectRoot(startDir = process.cwd()) {
     let currentDir = path.resolve(startDir);
     while (true) {
-        const requirementsDir = path.join(currentDir, '.requirements');
+        const requirementsDir = path.join(currentDir, ".requirements");
         const projectRootPath = path.join(requirementsDir, CACHE_DIR, PROJECT_ROOT_FILE);
         if (fs.existsSync(projectRootPath)) {
-            return fs.readFileSync(projectRootPath, 'utf-8').trim();
+            return fs.readFileSync(projectRootPath, "utf-8").trim();
         }
         const parentDir = path.dirname(currentDir);
         if (parentDir === currentDir) {
@@ -249,7 +229,7 @@ export function clearTrackingFile(requirementsDir) {
 export function appendTrackingEntry(requirementsDir, entry) {
     const cacheDir = getCacheDir(requirementsDir, true);
     const trackingPath = path.join(cacheDir, TRACKING_FILE);
-    const line = JSON.stringify(entry) + '\n';
+    const line = `${JSON.stringify(entry)}\n`;
     fs.appendFileSync(trackingPath, line);
 }
 /**
@@ -261,9 +241,9 @@ export function readTrackingEntries(requirementsDir) {
     if (!fs.existsSync(trackingPath)) {
         return [];
     }
-    const content = fs.readFileSync(trackingPath, 'utf-8');
+    const content = fs.readFileSync(trackingPath, "utf-8");
     const entries = [];
-    for (const line of content.split('\n')) {
+    for (const line of content.split("\n")) {
         if (line.trim()) {
             try {
                 entries.push(JSON.parse(line));
@@ -294,20 +274,28 @@ export function deleteTrackingFile(requirementsDir) {
  * can treat both shapes uniformly.
  */
 function normalizeEntry(raw) {
-    if (!raw || typeof raw !== 'object')
+    if (!raw || typeof raw !== "object")
+        return null;
+    // Cache entry shape from disk; the guards below check each field at runtime.
+    const entry = raw;
+    if (typeof entry.testRunId !== "string")
+        return null;
+    if (typeof entry.timestamp !== "number")
         return null;
-    if (Array.isArray(raw.tuples)) {
+    if (Array.isArray(entry.tuples)) {
         return {
-            testRunId: raw.testRunId,
-            timestamp: raw.timestamp,
-            tuples: raw.tuples,
+            testRunId: entry.testRunId,
+            timestamp: entry.timestamp,
+            tuples: entry.tuples,
         };
     }
-    if (Array.isArray(raw.requirementKeys)) {
+    if (Array.isArray(entry.requirementKeys)) {
         return {
-            testRunId: raw.testRunId,
-            timestamp: raw.timestamp,
-            tuples: raw.requirementKeys.map((requirementKey) => ({ requirementKey })),
+            testRunId: entry.testRunId,
+            timestamp: entry.timestamp,
+            tuples: entry.requirementKeys.map((requirementKey) => ({
+                requirementKey,
+            })),
         };
     }
     return null;
@@ -319,7 +307,7 @@ export function readCoverageCache(requirementsDir) {
         return { current: null, previous: null };
     }
     try {
-        const content = fs.readFileSync(coveragePath, 'utf-8');
+        const content = fs.readFileSync(coveragePath, "utf-8");
         const raw = JSON.parse(content);
         return {
             current: normalizeEntry(raw?.current),
@@ -337,7 +325,7 @@ export function readCoverageCache(requirementsDir) {
 export function updateCoverageCache(requirementsDir, testRunId, tuples) {
     const cacheDir = getCacheDir(requirementsDir, true);
     const coveragePath = path.join(cacheDir, COVERAGE_FILE);
-    const normalized = tuples.map((t) => typeof t === 'string' ? { requirementKey: t } : t);
+    const normalized = tuples.map((t) => typeof t === "string" ? { requirementKey: t } : t);
     const existing = readCoverageCache(requirementsDir);
     const newCache = {
         current: {
@@ -360,7 +348,9 @@ function tuplesMatch(a, b) {
  * Returns true if no matching tuple was reported within the debounce window.
  */
 export function needsReporting(tupleOrKey, cache) {
-    const tuple = typeof tupleOrKey === 'string' ? { requirementKey: tupleOrKey } : tupleOrKey;
+    const tuple = typeof tupleOrKey === "string"
+        ? { requirementKey: tupleOrKey }
+        : tupleOrKey;
     // If no current run, everything needs reporting
     if (!cache.current) {
         return true;

package/dist/harness/convexReporting.d.ts

@@ -1,4 +1,4 @@
-import { TrackedRequirement } from "./tracking.js";
+import { type TrackedRequirement } from "./tracking.js";
 /**
  * Get the current git branch, or null if not in a git repo
  */

package/dist/harness/convexReporting.js

@@ -1,7 +1,7 @@
-import { execSync } from "child_process";
-import { getTrackedRequirements } from "./tracking.js";
-import { saveCache, getRequirementsToReport } from "./coverageCache.js";
+import { execSync } from "node:child_process";
 import { getProjectInfo } from "../utils/project-settings.js";
+import { getRequirementsToReport, saveCache } from "./coverageCache.js";
+import { getTrackedRequirements } from "./tracking.js";
 /**
  * Get the current git branch, or null if not in a git repo
  */
@@ -14,7 +14,7 @@ export function getCurrentBranch(cwd = process.cwd()) {
         }).trim();
         return branch;
     }
-    catch (error) {
+    catch {
         // Not in a git repo or git not available
         return "unknown";
     }
@@ -22,7 +22,7 @@ export function getCurrentBranch(cwd = process.cwd()) {
 /**
  * Production Convex deployment URL
  */
-const CONVEX_URL = 'https://data.dotrequirements.io';
+const CONVEX_URL = "https://data.dotrequirements.io";
 /**
  * Extract file path and line number from caller location string
  */
@@ -53,7 +53,9 @@ export async function reportCoverageToConvex(cwd = process.cwd(), trackedReqs) {
         // Get project info from .requirements/project-settings.json
         const projectInfo = getProjectInfo(cwd);
         // Skip if no project found or not connected to cloud
-        if (!projectInfo || projectInfo.status !== 'cloud-connected' || !projectInfo.credentials) {
+        if (!projectInfo ||
+            projectInfo.status !== "cloud-connected" ||
+            !projectInfo.credentials) {
             console.log("\nℹ️  Skipping cloud coverage reporting (project not connected to cloud)");
             return;
         }
@@ -113,7 +115,7 @@ export async function reportCoverageToConvex(cwd = process.cwd(), trackedReqs) {
             console.warn(`\n⚠️  Failed to report coverage to cloud: ${response.status} ${error}`);
             return;
         }
-        const result = await response.json();
+        await response.json();
         console.log(`\n✓ Reported ${keysToReport.length} requirement(s) to cloud (branch: ${branch})`);
         // Update cache with current test run
         saveCache({

package/dist/harness/coverageCache.js

@@ -1,5 +1,5 @@
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { v4 as uuidv4 } from "uuid";
 const CACHE_FILE = ".requirements/.coverage-cache.json";
 const STALENESS_THRESHOLD_MS = 4 * 60 * 60 * 1000; // 4 hours
@@ -15,7 +15,7 @@ export function loadCache(cwd = process.cwd()) {
         const content = readFileSync(cachePath, "utf-8");
         return JSON.parse(content);
     }
-    catch (error) {
+    catch {
         // If cache is corrupt, start fresh
         console.warn("Warning: Coverage cache is corrupt, starting fresh");
         return { current: null, previous: null };

package/dist/harness/finalize.js

@@ -9,10 +9,10 @@
  *
  * Implements: HARNESS-FINALIZE-1, HARNESS-FINALIZE-2, HARNESS-FINALIZE-3, HARNESS-FINALIZE-4
  */
-import { execSync } from 'child_process';
-import { randomUUID } from 'crypto';
-import { findRequirementsDir, findProjectRoot, getTestRunId, cleanupTestRunId, readTrackingEntries, deleteTrackingFile, readLookupCache, readCoverageCache, updateCoverageCache, needsReporting, } from './cache.js';
-import { getProjectInfo } from '../utils/project-settings.js';
+import { execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { getProjectInfo } from "../utils/project-settings.js";
+import { cleanupTestRunId, deleteTrackingFile, findProjectRoot, findRequirementsDir, getTestRunId, needsReporting, readCoverageCache, readLookupCache, readTrackingEntries, updateCoverageCache, } from "./cache.js";
 /**
  * Aggregate tracking entries by requirement key
  */
@@ -30,15 +30,15 @@ function aggregateEntries(entries) {
  */
 function getCurrentBranch(cwd) {
     try {
-        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
             cwd,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'ignore'],
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
         }).trim();
         return branch;
     }
     catch {
-        return 'unknown';
+        return "unknown";
     }
 }
 /**
@@ -51,8 +51,8 @@ function getLineAuthor(cwd, file, line) {
     try {
         const output = execSync(`git blame -L ${line},${line} --porcelain -- "${file}"`, {
             cwd,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'ignore'],
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
         });
         const match = output.match(/^author-mail\s+<([^>]+)>/m);
         return match?.[1];
@@ -68,15 +68,17 @@ function getLineAuthor(cwd, file, line) {
  */
 function printLocalReport(testedKeys, lookup, options) {
     const { showSummary, showTestedList, showUntestedList } = options;
-    const allKeys = lookup ? Object.keys(lookup.requirements).filter(k => !lookup.requirements[k].isAlias) : [];
-    const untestedKeys = allKeys.filter(key => !testedKeys.includes(key));
+    const allKeys = lookup
+        ? Object.keys(lookup.requirements).filter((k) => !lookup.requirements[k].isAlias)
+        : [];
+    const untestedKeys = allKeys.filter((key) => !testedKeys.includes(key));
     const total = allKeys.length;
     const tested = testedKeys.length;
-    const coverage = total > 0 ? ((tested / total) * 100).toFixed(1) : '0.0';
-    let report = '';
+    const coverage = total > 0 ? ((tested / total) * 100).toFixed(1) : "0.0";
+    let report = "";
     // Show summary stats
     if (showSummary) {
-        report += '\n=== Requirements Coverage Report ===\n';
+        report += "\n=== Requirements Coverage Report ===\n";
         report += `\nTotal Requirements: ${total}\n`;
         report += `Tested Requirements: ${tested}\n`;
         report += `Untested Requirements: ${untestedKeys.length}\n`;
@@ -84,14 +86,14 @@ function printLocalReport(testedKeys, lookup, options) {
     }
     // Show tested requirements
     if (showTestedList && testedKeys.length > 0) {
-        report += '\n✓ Tested Requirements:\n';
+        report += "\n✓ Tested Requirements:\n";
         for (const key of testedKeys) {
             const req = lookup?.requirements[key];
             if (req) {
-                const label = req.label || '';
-                const content = req.content || '';
-                const preview = content.length > 60 ? content.substring(0, 60) + '...' : content;
-                const labelPart = label ? ` (${label})` : '';
+                const label = req.label || "";
+                const content = req.content || "";
+                const preview = content.length > 60 ? `${content.substring(0, 60)}...` : content;
+                const labelPart = label ? ` (${label})` : "";
                 report += `  - ${key}${labelPart}: ${preview}\n`;
             }
             else {
@@ -101,14 +103,14 @@ function printLocalReport(testedKeys, lookup, options) {
     }
     // Show untested requirements
     if (showUntestedList && untestedKeys.length > 0) {
-        report += '\n✗ Untested Requirements:\n';
+        report += "\n✗ Untested Requirements:\n";
         for (const key of untestedKeys) {
             const req = lookup?.requirements[key];
             if (req) {
-                const label = req.label || '';
-                const content = req.content || '';
-                const preview = content.length > 60 ? content.substring(0, 60) + '...' : content;
-                const labelPart = label ? ` (${label})` : '';
+                const label = req.label || "";
+                const content = req.content || "";
+                const preview = content.length > 60 ? `${content.substring(0, 60)}...` : content;
+                const labelPart = label ? ` (${label})` : "";
                 report += `  - ${key}${labelPart}: ${preview}\n`;
             }
             else {
@@ -117,7 +119,7 @@ function printLocalReport(testedKeys, lookup, options) {
         }
     }
     if (showSummary) {
-        report += '\n====================================\n';
+        report += "\n====================================\n";
     }
     if (report) {
         console.log(report);
@@ -126,7 +128,7 @@ function printLocalReport(testedKeys, lookup, options) {
 /**
  * Production Convex deployment URL
  */
-const CONVEX_URL = 'https://data.dotrequirements.io';
+const CONVEX_URL = "https://data.dotrequirements.io";
 /**
  * Report coverage to Convex cloud
  *
@@ -138,9 +140,11 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
         // Get project info from .requirements/project-settings.json
         const projectInfo = getProjectInfo(projectRoot);
         // Skip if no project found or not connected to cloud
-        if (!projectInfo || projectInfo.status !== 'cloud-connected' || !projectInfo.credentials) {
+        if (!projectInfo ||
+            projectInfo.status !== "cloud-connected" ||
+            !projectInfo.credentials) {
             if (showCloudStatus) {
-                console.log('\nℹ️  Skipping cloud coverage reporting (project not connected to cloud)');
+                console.log("\nℹ️  Skipping cloud coverage reporting (project not connected to cloud)");
             }
             return { sent: false, count: 0 };
         }
@@ -161,7 +165,7 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
         const tuplesToReport = allTuples.filter((tuple) => needsReporting(tuple, coverageCache));
         if (tuplesToReport.length === 0) {
             if (showCloudStatus) {
-                console.log('\n✓ Coverage unchanged since last run (skipping cloud report)');
+                console.log("\n✓ Coverage unchanged since last run (skipping cloud report)");
             }
             // Still update the cache so the window continues tracking
             updateCoverageCache(requirementsDir, testRunId, allTuples);
@@ -180,7 +184,7 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
             // Parse "filename.ts:42" format
             let testFile;
             let testLine;
-            if (location !== 'unknown') {
+            if (location !== "unknown") {
                 const match = location.match(/^(.+):(\d+)$/);
                 if (match) {
                     testFile = match[1];
@@ -213,19 +217,19 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
         // Note: projectId from env is always a slug (e.g., "reduced-cephalopod-288"),
         // not a Convex ID. Use projectSlug field for authentication and slug for target.
         const response = await fetch(`${CONVEX_URL}/api/mutation`, {
-            method: 'POST',
+            method: "POST",
             headers: {
-                'Content-Type': 'application/json',
+                "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                path: 'testCoverage/mutations:recordCoverage',
+                path: "testCoverage/mutations:recordCoverage",
                 args: {
                     projectAuth: {
                         projectSlug: projectId,
                         projectSecret,
                     },
                     target: {
-                        type: 'project',
+                        type: "project",
                         slug: projectId,
                     },
                     branch,
@@ -233,7 +237,7 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
                     runId,
                     coverage,
                 },
-                format: 'json',
+                format: "json",
             }),
         });
         if (!response.ok) {
@@ -253,10 +257,12 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
         catch {
             // Not JSON, treat as success
         }
-        if (responseData && typeof responseData === 'object' && 'status' in responseData) {
+        if (responseData &&
+            typeof responseData === "object" &&
+            "status" in responseData) {
             const convexResponse = responseData;
-            if (convexResponse.status === 'error') {
-                const errorMsg = convexResponse.errorMessage || 'Unknown Convex error';
+            if (convexResponse.status === "error") {
+                const errorMsg = convexResponse.errorMessage || "Unknown Convex error";
                 if (showCloudStatus) {
                     console.warn(`\n⚠️  Failed to report coverage to cloud: ${errorMsg}`);
                 }
@@ -298,7 +304,7 @@ export async function finalize(options = {}) {
         projectRoot = findProjectRoot(cwd);
     }
     if (!projectRoot) {
-        console.log('Could not find .requirements directory');
+        console.log("Could not find .requirements directory");
         return {
             requirementsTested: 0,
             totalRequirements: 0,
@@ -311,7 +317,7 @@ export async function finalize(options = {}) {
     // Get test run ID
     const testRunId = getTestRunId(requirementsDir);
     if (!testRunId) {
-        console.log('No test run ID found - was prepare() called?');
+        console.log("No test run ID found - was prepare() called?");
         return {
             requirementsTested: 0,
             totalRequirements: 0,
@@ -343,17 +349,24 @@ export async function finalize(options = {}) {
         }
     }
     const testedKeys = Array.from(aggregated.keys());
-    const totalRequirements = lookup ? Object.keys(lookup.requirements).filter(k => !lookup.requirements[k].isAlias).length : 0;
-    const coveragePercent = totalRequirements > 0
-        ? (testedKeys.length / totalRequirements) * 100
+    const totalRequirements = lookup
+        ? Object.keys(lookup.requirements).filter((k) => !lookup.requirements[k].isAlias).length
         : 0;
+    const coveragePercent = totalRequirements > 0 ? (testedKeys.length / totalRequirements) * 100 : 0;
     // HARNESS-FINALIZE-1: Print local report
     const shouldPrintLocal = showSummary || showTestedList || showUntestedList;
     if (shouldPrintLocal) {
-        printLocalReport(testedKeys, lookup, { showSummary, showTestedList, showUntestedList });
+        printLocalReport(testedKeys, lookup, {
+            showSummary,
+            showTestedList,
+            showUntestedList,
+        });
     }
     // HARNESS-FINALIZE-2, HARNESS-FINALIZE-3: Report to cloud
-    let cloudResult = { sent: false, count: 0 };
+    let cloudResult = {
+        sent: false,
+        count: 0,
+    };
     if (shouldReportToCloud) {
         cloudResult = await reportToConvex(projectRoot, testRunId, aggregated, showCloudStatus, context);
     }

package/dist/harness/index.d.ts

@@ -60,11 +60,10 @@ export interface RequirementOptions {
  * @returns A formatted string with the first requirement's label and content
  */
 export declare function requirement(...args: (string | RequirementOptions)[]): string;
-export { prepare } from './prepare.js';
-export type { PrepareOptions, PrepareResult } from './prepare.js';
-export { finalize } from './finalize.js';
-export type { FinalizeOptions, FinalizeResult } from './finalize.js';
-export { clearTracking } from './tracking.js';
-export { initTestRun, finalizeTestRun, } from './tracking.js';
-export type { Requirement } from './types.js';
+export type { FinalizeOptions, FinalizeResult } from "./finalize.js";
+export { finalize } from "./finalize.js";
+export type { PrepareOptions, PrepareResult } from "./prepare.js";
+export { prepare } from "./prepare.js";
+export { clearTracking, finalizeTestRun, initTestRun } from "./tracking.js";
+export type { Requirement } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/harness/index.js

@@ -27,8 +27,8 @@
  * }
  * ```
  */
-import { getRequirement, loadRequirements } from './requirementsLoader.js';
-import { ensureTestRun, trackRequirement, saveTrackingData } from './tracking.js';
+import { getRequirement, loadRequirements } from "./requirementsLoader.js";
+import { ensureTestRun, saveTrackingData, trackRequirement, } from "./tracking.js";
 /**
  * Main requirements function for test harness.
  *
@@ -56,15 +56,15 @@ import { ensureTestRun, trackRequirement, saveTrackingData } from './tracking.js
  */
 export function requirement(...args) {
     if (args.length === 0) {
-        throw new Error('requirement() requires at least one argument');
+        throw new Error("requirement() requires at least one argument");
     }
     // Check if last argument is options object
     const lastArg = args[args.length - 1];
-    const hasOptions = typeof lastArg === 'object' && lastArg !== null;
+    const hasOptions = typeof lastArg === "object" && lastArg !== null;
     const options = hasOptions ? lastArg : {};
     const requirementRefs = (hasOptions ? args.slice(0, -1) : args);
     if (requirementRefs.length === 0) {
-        throw new Error('requirement() requires at least one requirement reference');
+        throw new Error("requirement() requires at least one requirement reference");
     }
     // If projectRoot provided, reload requirements from that path
     if (options.projectRoot) {
@@ -87,17 +87,16 @@ export function requirement(...args) {
     }
     // HARNESS-REQUIREMENT-1: Format output as human-readable string
     // Root requirements use 'requirementHeader' label which should not be shown in output
-    if (!req.label || req.label === 'requirementHeader') {
+    if (!req.label || req.label === "requirementHeader") {
         return req.content;
     }
     const label = req.label.charAt(0).toUpperCase() + req.label.slice(1);
     return `${label}: ${req.content}`;
 }
+export { finalize } from "./finalize.js";
 // Export new lifecycle functions
-export { prepare } from './prepare.js';
-export { finalize } from './finalize.js';
+export { prepare } from "./prepare.js";
 // Export tracking utilities
-export { clearTracking } from './tracking.js';
 // Deprecated exports - use prepare() and finalize() instead
-export { initTestRun, finalizeTestRun, } from './tracking.js';
+export { clearTracking, finalizeTestRun, initTestRun } from "./tracking.js";
 //# sourceMappingURL=index.js.map

package/dist/harness/prepare.js

@@ -8,9 +8,10 @@
  *
  * Implements: HARNESS-PREPARE-1, HARNESS-PREPARE-2, HARNESS-PREPARE-3
  */
-import { findRequirementsDir, findRequirementsFiles, writeLookupCache, initTestRunId, clearTrackingFile, writeProjectRoot, } from './cache.js';
-import { parseRequirementsFromFile, } from '../schema/index.js';
-import { findProjectRoot } from '../utils/project-settings.js';
+import { findRequirementsFilesSync } from "../requirements/index.js";
+import { parseRequirementsFromFile, } from "../schema/index.js";
+import { findProjectRoot } from "../utils/project-settings.js";
+import { clearTrackingFile, findRequirementsDir, initTestRunId, writeLookupCache, writeProjectRoot, } from "./cache.js";
 /**
  * Prepare the test harness for a test run.
  *
@@ -26,14 +27,14 @@ export function prepare(options = {}) {
     // Find the project root by looking for .requirements directory
     const projectRoot = findProjectRoot(cwd);
     if (!projectRoot) {
-        throw new Error('Could not find .requirements directory. ' +
+        throw new Error("Could not find .requirements directory. " +
             'Please run "dotrequirements init" to initialize your project.');
     }
     // Set environment variable for cross-process persistence (globalSetup → test workers)
     process.env.DOTREQUIREMENTS_PROJECT_ROOT = projectRoot;
     const requirementsDir = findRequirementsDir(projectRoot);
     // Find all requirements files
-    const files = findRequirementsFiles(projectRoot);
+    const files = findRequirementsFilesSync(projectRoot);
     // Parse all files, collecting requirements and errors
     const allRequirements = [];
     const parseErrors = [];