@popoverai/dotrequirements 0.23.0 → 0.24.0

package/dist/commands/test.js

@@ -1,67 +1,61 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { parseRequirementsFromFile } from '../schema/index.js';
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseRequirementsFromFile, } from "../schema/index.js";
 export async function testCommand(options) {
-    try {
-        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("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++;
         }
-        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);
+        catch (error) {
+            console.error(`  ✗ Validation failed:`, error);
+            failCount++;
         }
     }
-    catch (error) {
-        // Re-throw to let the CLI error handler display it cleanly
-        throw error;
+    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);
     }
 }
 /**

package/dist/commands/tests-for.d.ts

@@ -0,0 +1,2 @@
+export declare function testsForCommand(requirementsFile: string): Promise<void>;
+//# sourceMappingURL=tests-for.d.ts.map

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