@popoverai/dotrequirements 0.23.0 → 0.24.1

package/dist/commands/tests-for.js

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { findAllTestReferences } from "../requirements/grep.js";
+import { loadAllRequirements } from "../requirements/index.js";
+export async function testsForCommand(requirementsFile) {
+    const workspaceRoot = process.cwd();
+    const fullPath = resolve(workspaceRoot, requirementsFile);
+    // CLI-FIND-MAP-2.3: missing file or wrong extension → error + non-zero exit
+    if (!existsSync(fullPath)) {
+        throw new Error(`Requirements file not found: ${requirementsFile}`);
+    }
+    if (!requirementsFile.endsWith(".requirements.md")) {
+        throw new Error(`File must be a requirements file: *.requirements.md`);
+    }
+    const { flattened } = await loadAllRequirements(workspaceRoot);
+    const fileRequirements = flattened.filter((req) => resolve(workspaceRoot, req.sourceFile) === fullPath);
+    if (fileRequirements.length === 0) {
+        console.log(`No requirements found in "${requirementsFile}".`);
+        return;
+    }
+    const rootIds = new Set(fileRequirements.map((req) => req.rootId));
+    const allTestRefs = await findAllTestReferences(workspaceRoot);
+    // Build coverage map: requirement ID → test refs
+    const coverageMap = new Map();
+    for (const ref of allTestRefs) {
+        if (!coverageMap.has(ref.requirementId)) {
+            coverageMap.set(ref.requirementId, []);
+        }
+        coverageMap.get(ref.requirementId).push(ref);
+    }
+    // CLI-FIND-MAP-2.0: group by coverage status
+    const covered = [];
+    const notCovered = [];
+    for (const rootId of rootIds) {
+        const reqAndChildren = fileRequirements.filter((r) => r.rootId === rootId);
+        const allIds = reqAndChildren.map((r) => r.id);
+        const testsForThisReq = [];
+        for (const id of allIds) {
+            const refs = coverageMap.get(id);
+            if (refs) {
+                testsForThisReq.push(...refs);
+            }
+        }
+        if (testsForThisReq.length > 0) {
+            covered.push({ id: rootId, tests: testsForThisReq });
+        }
+        else {
+            notCovered.push(rootId);
+        }
+    }
+    console.log(`Test coverage for "${requirementsFile}":\n`);
+    if (covered.length > 0) {
+        console.log(`Covered (${covered.length}):`);
+        // CLI-FIND-MAP-2.1: test file path + line numbers for each covered req
+        for (const { id, tests } of covered) {
+            const testsByFile = new Map();
+            for (const test of tests) {
+                if (!testsByFile.has(test.file)) {
+                    testsByFile.set(test.file, []);
+                }
+                testsByFile.get(test.file).push(test.line);
+            }
+            console.log(`  ${id}: ${tests.length} test${tests.length === 1 ? "" : "s"}`);
+            for (const [file, lines] of testsByFile) {
+                const relPath = relative(workspaceRoot, file);
+                const lineList = lines.sort((a, b) => a - b).join(", ");
+                console.log(`    ${relPath} (lines ${lineList})`);
+            }
+        }
+        console.log();
+    }
+    // CLI-FIND-MAP-2.2: uncovered group
+    if (notCovered.length > 0) {
+        console.log(`Not Covered (${notCovered.length}):`);
+        for (const id of notCovered) {
+            console.log(`  ${id}: No tests found`);
+        }
+    }
+}
+//# sourceMappingURL=tests-for.js.map

package/dist/commands/validate.d.ts

@@ -0,0 +1,6 @@
+interface ValidateOptions {
+    file?: string;
+}
+export declare function validateCommand(options: ValidateOptions): Promise<void>;
+export {};
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.js

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseRequirementsFromFile, } from "../schema/index.js";
+export async function validateCommand(options) {
+    console.log("Parsing and validating requirements...");
+    const requirementsDir = path.join(process.cwd(), ".requirements");
+    if (!fs.existsSync(requirementsDir)) {
+        console.error("Error: .requirements/ directory not found.");
+        console.log('Run "dotrequirements pull" first to sync requirements.');
+        process.exit(1);
+    }
+    // Get files to test
+    let files;
+    if (options.file) {
+        files = [options.file];
+    }
+    else {
+        files = fs
+            .readdirSync(requirementsDir)
+            .filter((f) => f.endsWith(".requirements.md"))
+            .map((f) => path.join(requirementsDir, f));
+    }
+    if (files.length === 0) {
+        console.log("No Markdown requirements files found to test.");
+        return;
+    }
+    let totalRequirements = 0;
+    let passCount = 0;
+    let failCount = 0;
+    for (const filePath of files) {
+        const fileName = path.basename(filePath);
+        console.log(`\nTesting: ${fileName}`);
+        try {
+            // Parse and validate using shared schema module
+            const { metadata, requirements } = parseRequirementsFromFile(filePath);
+            // Count total requirements (root + all descendants)
+            let count = 0;
+            for (const req of requirements) {
+                count += countRequirementsInTree(req);
+            }
+            totalRequirements += count;
+            console.log(`  ✓ Valid structure (${count} requirement(s))`);
+            console.log(`  ✓ Version: ${metadata.version}`);
+            console.log(`  ✓ Last sync: ${metadata.pulledAt}`);
+            passCount++;
+        }
+        catch (error) {
+            console.error(`  ✗ Validation failed:`, error);
+            failCount++;
+        }
+    }
+    console.log(`\n${"=".repeat(50)}`);
+    console.log(`Total files: ${files.length}`);
+    console.log(`Passed: ${passCount}`);
+    console.log(`Failed: ${failCount}`);
+    console.log(`Total requirements: ${totalRequirements}`);
+    if (failCount > 0) {
+        process.exit(1);
+    }
+}
+/**
+ * Recursively count requirements in a tree (1 for root + all descendants)
+ */
+function countRequirementsInTree(node) {
+    let count = 1; // Count this node
+    // Count all children
+    for (const child of node.children) {
+        count += countRequirementsInTree(child);
+    }
+    return count;
+}
+//# sourceMappingURL=validate.js.map

package/dist/config.js

@@ -2,7 +2,7 @@
  * Production Convex deployment URL
  * All users connect to the same backend
  */
-const CONVEX_URL = 'https://data.dotrequirements.io';
+const CONVEX_URL = "https://data.dotrequirements.io";
 /**
  * Get the Convex deployment URL
  */

package/dist/convex.d.ts

@@ -1,66 +1,78 @@
 /**
- * Convex API stub for CLI usage
- * This will be replaced with actual generated types when linked to the Convex backend
+ * Convex API stub for CLI usage.
+ *
+ * The CLI doesn't import generated convex types (those live in the convex
+ * package and aren't shipped to npm consumers), so we hand-roll the `api`
+ * object that gets passed into `ConvexHttpClient.query/mutation/action`.
+ *
+ * `makeFunctionReference<"query" | "mutation" | "action">("path:fn")` is the
+ * official escape hatch for this exact case — it builds a `FunctionReference`
+ * with the right shape for the convex client to consume, without us having to
+ * cast through `any`.
+ *
+ * The args/return types default to `any` inside the convex library types
+ * (that's `FunctionReference`'s public surface), but at the call site we still
+ * get a properly typed reference object — no user-authored `any` here.
  */
 export declare const api: {
     documents: {
         queries: {
-            exportForCli: any;
-            exportProjectForCli: any;
-            checkDocumentsExist: any;
-            getDocumentsMetadata: any;
+            exportForCli: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            exportProjectForCli: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            checkDocumentsExist: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getDocumentsMetadata: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
-            create: any;
-            update: any;
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            update: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
         saveWithRequirements: {
-            saveWithRequirements: any;
+            saveWithRequirements: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
     requirements: {
         queries: {
-            listByProject: any;
+            listByProject: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
-            bulkUpdate: any;
+            bulkUpdate: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
     projects: {
         mutations: {
-            create: any;
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
     teams: {
         queries: {
-            listForUserWithUsage: any;
+            listForUserWithUsage: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
-            ensureDefaultTeam: any;
+            ensureDefaultTeam: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
     teamInvites: {
         queries: {
-            getInviteInfo: any;
+            getInviteInfo: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
     };
     polar: {
-        acceptTeamInvite: any;
+        acceptTeamInvite: import("convex/server").FunctionReference<"action", "public", any, any, string | undefined>;
     };
     projectSecrets: {
         queries: {
-            getOwnSecret: any;
-            listOwnSecretsForTeam: any;
+            getOwnSecret: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            listOwnSecretsForTeam: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
-            ensureOwnSecret: any;
-            revokeOwnSecret: any;
+            ensureOwnSecret: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            revokeOwnSecret: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
     lib: {
         authActions: {
-            exchangeAuthorizationCode: any;
-            refreshAccessToken: any;
+            exchangeAuthorizationCode: import("convex/server").FunctionReference<"action", "public", any, any, string | undefined>;
+            refreshAccessToken: import("convex/server").FunctionReference<"action", "public", any, any, string | undefined>;
         };
     };
 };

package/dist/convex.js

@@ -1,68 +1,84 @@
 /**
- * Convex API stub for CLI usage
- * This will be replaced with actual generated types when linked to the Convex backend
+ * Convex API stub for CLI usage.
+ *
+ * The CLI doesn't import generated convex types (those live in the convex
+ * package and aren't shipped to npm consumers), so we hand-roll the `api`
+ * object that gets passed into `ConvexHttpClient.query/mutation/action`.
+ *
+ * `makeFunctionReference<"query" | "mutation" | "action">("path:fn")` is the
+ * official escape hatch for this exact case — it builds a `FunctionReference`
+ * with the right shape for the convex client to consume, without us having to
+ * cast through `any`.
+ *
+ * The args/return types default to `any` inside the convex library types
+ * (that's `FunctionReference`'s public surface), but at the call site we still
+ * get a properly typed reference object — no user-authored `any` here.
  */
+import { makeFunctionReference } from "convex/server";
+const query = (name) => makeFunctionReference(name);
+const mutation = (name) => makeFunctionReference(name);
+const action = (name) => makeFunctionReference(name);
 export const api = {
     documents: {
         queries: {
-            exportForCli: 'documents/queries:exportForCli',
-            exportProjectForCli: 'documents/queries:exportProjectForCli',
-            checkDocumentsExist: 'documents/queries:checkDocumentsExist',
+            exportForCli: query("documents/queries:exportForCli"),
+            exportProjectForCli: query("documents/queries:exportProjectForCli"),
+            checkDocumentsExist: query("documents/queries:checkDocumentsExist"),
             // SYNC-CLI-EDIT-2: Get document metadata for conflict detection
-            getDocumentsMetadata: 'documents/queries:getDocumentsMetadata',
+            getDocumentsMetadata: query("documents/queries:getDocumentsMetadata"),
         },
         mutations: {
-            create: 'documents/mutations:create',
-            update: 'documents/mutations:update',
+            create: mutation("documents/mutations:create"),
+            update: mutation("documents/mutations:update"),
         },
         // SYNC-ARCH-1: Save document with requirements derivation
         saveWithRequirements: {
-            saveWithRequirements: 'documents/saveWithRequirements:saveWithRequirements',
+            saveWithRequirements: mutation("documents/saveWithRequirements:saveWithRequirements"),
         },
     },
     requirements: {
         queries: {
-            listByProject: 'requirements/queries:listByProject',
+            listByProject: query("requirements/queries:listByProject"),
         },
         mutations: {
-            bulkUpdate: 'requirements/mutations:bulkUpdate',
+            bulkUpdate: mutation("requirements/mutations:bulkUpdate"),
         },
     },
     projects: {
         mutations: {
-            create: 'projects/mutations:create',
+            create: mutation("projects/mutations:create"),
         },
     },
     teams: {
         queries: {
-            listForUserWithUsage: 'teams/queries:listForUserWithUsage',
+            listForUserWithUsage: query("teams/queries:listForUserWithUsage"),
         },
         mutations: {
-            ensureDefaultTeam: 'teams/mutations:ensureDefaultTeam',
+            ensureDefaultTeam: mutation("teams/mutations:ensureDefaultTeam"),
         },
     },
     teamInvites: {
         queries: {
-            getInviteInfo: 'teamInvites/queries:getInviteInfo',
+            getInviteInfo: query("teamInvites/queries:getInviteInfo"),
         },
     },
     polar: {
-        acceptTeamInvite: 'polar:acceptTeamInvite',
+        acceptTeamInvite: action("polar:acceptTeamInvite"),
     },
     projectSecrets: {
         queries: {
-            getOwnSecret: 'projectSecrets/queries:getOwnSecret',
-            listOwnSecretsForTeam: 'projectSecrets/queries:listOwnSecretsForTeam',
+            getOwnSecret: query("projectSecrets/queries:getOwnSecret"),
+            listOwnSecretsForTeam: query("projectSecrets/queries:listOwnSecretsForTeam"),
         },
         mutations: {
-            ensureOwnSecret: 'projectSecrets/mutations:ensureOwnSecret',
-            revokeOwnSecret: 'projectSecrets/mutations:revokeOwnSecret',
+            ensureOwnSecret: mutation("projectSecrets/mutations:ensureOwnSecret"),
+            revokeOwnSecret: mutation("projectSecrets/mutations:revokeOwnSecret"),
         },
     },
     lib: {
         authActions: {
-            exchangeAuthorizationCode: 'lib/authActions:exchangeAuthorizationCode',
-            refreshAccessToken: 'lib/authActions:refreshAccessToken',
+            exchangeAuthorizationCode: action("lib/authActions:exchangeAuthorizationCode"),
+            refreshAccessToken: action("lib/authActions:refreshAccessToken"),
         },
     },
 };

package/dist/harness/cache.d.ts

@@ -6,7 +6,7 @@
  * - tracking.jsonl: Append-only tracking of requirement() calls (cross-process safe)
  * - coverage.json: Deduplication cache for cloud reporting
  */
-import { type RequirementNode } from '../schema/index.js';
+import type { RequirementNode } from "../schema/index.js";
 /**
  * Tracking entry for a single requirement() call.
  * Stored as one JSON object per line in tracking.jsonl
@@ -68,10 +68,6 @@ export declare function findProjectRoot(startDir?: string): string | null;
  * Get the cache directory path, creating it if necessary
  */
 export declare function getCacheDir(requirementsDir: string, create?: boolean): string;
-/**
- * Find all *.requirements.md files under project root
- */
-export declare function findRequirementsFiles(projectRoot: string): string[];
 /**
  * Write the lookup cache with all pre-parsed requirements
  */

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
  */