@popoverai/dotrequirements 0.29.0 → 0.29.2

package/dist/sync/segment.js

@@ -6,7 +6,19 @@
  * normalized text (prose has no stable id, so a reworded passage reads as a
  * removal-plus-addition — a conflict, per DIFF-4.3).
  */
-import { getAllRequirements, parseRequirementBlock } from "../schema/index.js";
+import { canonicalRequirementKey, getAllRequirements, parseRequirementBlock, splitRequirementFenceContent, } from "../schema/index.js";
+/**
+ * A node's comparison id: the canonical root key plus its position tail, so the
+ * two sides agree on identity even when they spell the key differently
+ * (DIFF-3.3). Splitting on the first "." keeps the tail untouched — position
+ * paths are already canonical.
+ */
+function canonicalNodeId(id) {
+    const dot = id.indexOf(".");
+    if (dot === -1)
+        return canonicalRequirementKey(id);
+    return `${canonicalRequirementKey(id.slice(0, dot))}${id.slice(dot)}`;
+}
 /** Matches a fenced dotrequirements block; group 1 is its inner content. */
 const FENCE = /```dotrequirements\n([\s\S]*?)```/gm;
 /**
@@ -26,8 +38,8 @@ export function normalizeProse(text) {
 }
 /**
  * Split a body into its ordered units. Prose between (and around) fences
- * becomes prose units when non-empty after normalization; each fence becomes a
- * requirement unit keyed by its first-line KEY.
+ * becomes prose units when non-empty after normalization; every root inside a
+ * fence becomes a requirement unit keyed by its KEY.
  */
 export function segmentBody(body) {
     const normalized = body.replace(/\r\n/g, "\n");
@@ -39,13 +51,35 @@ export function segmentBody(body) {
         const prose = normalizeProse(normalized.slice(lastIndex, match.index));
         if (prose)
             units.push({ kind: "prose", text: prose });
-        const blockContent = match[1].trim();
-        const keyMatch = blockContent.match(/^([\w-]+):/);
-        // A block whose first line isn't KEY: is malformed; parsing rejects it
-        // upstream, so segmentation never sees it in the compare path. Fall back to
-        // the leading text as a key so segmentation stays total regardless.
-        const key = (keyMatch ? keyMatch[1] : blockContent.slice(0, 24)).toUpperCase();
-        units.push({ kind: "requirement", key, blockContent });
+        // Segmentation must stay total. Cloud bodies arrive as stored markdown,
+        // never re-parsed, so a fence that predates today's grammar still shows up
+        // here — and a throw would take down the comparison for every document in
+        // the run. A fence we cannot split becomes one unit keyed by its leading
+        // text, so the pair still classifies (as a conflict) and `--repo-wins` can
+        // still repair it (SYNC-FAIL-4.2).
+        const fenceBlocks = (() => {
+            try {
+                return splitRequirementFenceContent(match[1]);
+            }
+            catch {
+                const blockContent = match[1].trim();
+                const leading = blockContent.match(/^([\w-]+):/)?.[1];
+                return [
+                    {
+                        key: leading ?? blockContent.slice(0, 24),
+                        blockContent,
+                        startLine: 0,
+                    },
+                ];
+            }
+        })();
+        for (const { key, blockContent } of fenceBlocks) {
+            units.push({
+                kind: "requirement",
+                key: canonicalRequirementKey(key),
+                blockContent,
+            });
+        }
         lastIndex = FENCE.lastIndex;
         match = FENCE.exec(normalized);
     }
@@ -69,7 +103,7 @@ export function requirementUnitMap(blockContent) {
     const map = new Map();
     for (const node of getAllRequirements([tree])) {
         // A NUL (\u0000) separates the label from content so a label change reads as a change.
-        map.set(node.id.toUpperCase(), `${node.label}\u0000${node.content}`);
+        map.set(canonicalNodeId(node.id), `${node.label}\u0000${node.content}`);
     }
     return map;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popoverai/dotrequirements",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "Requirements tracking CLI and test harness",
   "type": "module",
   "bin": {
@@ -56,7 +56,7 @@
     "commander": "^12.1.0",
     "convex": "^1.29.3",
     "find-up": "^8.0.0",
-    "glob": "^11.0.0",
+    "glob": "^13.0.0",
     "open": "^11.0.0",
     "prompts": "^2.4.2",
     "repomix": "^1.14.0",

package/dist/harness/convexReporting.d.ts

@@ -1,15 +0,0 @@
-import { type TrackedRequirement } from "./tracking.js";
-/**
- * Get the current git branch, or null if not in a git repo
- */
-export declare function getCurrentBranch(cwd?: string): string;
-/**
- * Report coverage to Convex (async, fire-and-forget)
- *
- * @param cwd - Working directory to find .env.local and write cache
- * @param trackedReqs - Optional tracked requirements map. If not provided, falls back to in-memory tracking.
- *                      When called from finalizeTestRun (globalTeardown), this should be passed explicitly
- *                      since the in-memory map is empty in a separate process context.
- */
-export declare function reportCoverageToConvex(cwd?: string, trackedReqs?: Map<string, TrackedRequirement>): Promise<void>;
-//# sourceMappingURL=convexReporting.d.ts.map

package/dist/harness/convexReporting.js

@@ -1,131 +0,0 @@
-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
- */
-export function getCurrentBranch(cwd = process.cwd()) {
-    try {
-        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-            cwd,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "ignore"], // Suppress stderr
-        }).trim();
-        return branch;
-    }
-    catch {
-        // Not in a git repo or git not available
-        return "unknown";
-    }
-}
-/**
- * Production Convex deployment URL
- */
-const CONVEX_URL = "https://data.dotrequirements.io";
-/**
- * Extract file path and line number from caller location string
- */
-function parseCallerLocation(location) {
-    // Location format: "filename.ts:123" or "unknown"
-    if (location === "unknown") {
-        return { testFile: undefined, testLine: undefined };
-    }
-    const match = location.match(/^(.+):(\d+)$/);
-    if (match) {
-        return {
-            testFile: match[1],
-            testLine: parseInt(match[2], 10),
-        };
-    }
-    return { testFile: location, testLine: undefined };
-}
-/**
- * Report coverage to Convex (async, fire-and-forget)
- *
- * @param cwd - Working directory to find .env.local and write cache
- * @param trackedReqs - Optional tracked requirements map. If not provided, falls back to in-memory tracking.
- *                      When called from finalizeTestRun (globalTeardown), this should be passed explicitly
- *                      since the in-memory map is empty in a separate process context.
- */
-export async function reportCoverageToConvex(cwd = process.cwd(), trackedReqs) {
-    try {
-        // 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) {
-            console.log("\nℹ️  Skipping cloud coverage reporting (project not connected to cloud)");
-            return;
-        }
-        const { projectId, projectSecret } = projectInfo.credentials;
-        // Use provided trackedReqs or fall back to in-memory tracking
-        const reqs = trackedReqs ?? getTrackedRequirements();
-        const requirementKeys = Array.from(reqs.keys());
-        // Use caching to filter out requirements that don't need reporting
-        const keysToReport = getRequirementsToReport(requirementKeys, cwd);
-        if (keysToReport.length === 0) {
-            console.log("\n✓ Coverage unchanged since last run (skipping cloud report)");
-            // Still update the cache with current timestamp
-            saveCache({
-                timestamp: Date.now(),
-                requirementKeys,
-            }, cwd);
-            return;
-        }
-        const branch = getCurrentBranch(cwd);
-        // Build coverage payload
-        const coverage = keysToReport.map((key) => {
-            const tracked = reqs.get(key);
-            // Use the first access location (most likely the test that called requirement())
-            const firstAccess = tracked.accessedAt[0] || "unknown";
-            const { testFile, testLine } = parseCallerLocation(firstAccess);
-            return {
-                requirementKey: key,
-                testFile,
-                testLine,
-            };
-        });
-        // Send to Convex
-        const response = await fetch(`${CONVEX_URL}/api/mutation`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                path: "testCoverage/mutations:recordCoverage",
-                args: {
-                    projectAuth: {
-                        projectSlug: projectId,
-                        projectSecret,
-                    },
-                    target: {
-                        type: "project",
-                        slug: projectId,
-                    },
-                    branch,
-                    coverage,
-                },
-                format: "json",
-            }),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            console.warn(`\n⚠️  Failed to report coverage to cloud: ${response.status} ${error}`);
-            return;
-        }
-        await response.json();
-        console.log(`\n✓ Reported ${keysToReport.length} requirement(s) to cloud (branch: ${branch})`);
-        // Update cache with current test run
-        saveCache({
-            timestamp: Date.now(),
-            requirementKeys,
-        }, cwd);
-    }
-    catch (error) {
-        // Don't throw - reporting failures shouldn't break tests
-        console.warn(`\n⚠️  Error reporting coverage to cloud: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-//# sourceMappingURL=convexReporting.js.map

package/dist/harness/coverageCache.d.ts

@@ -1,30 +0,0 @@
-export interface TestRun {
-    testRunId: string;
-    timestamp: number;
-    requirementKeys: string[];
-}
-export interface CoverageCache {
-    current: TestRun | null;
-    previous: TestRun | null;
-}
-/**
- * Load the coverage cache from disk
- */
-export declare function loadCache(cwd?: string): CoverageCache;
-/**
- * Save a new test run to the cache, rotating current → previous
- */
-export declare function saveCache(testRun: Omit<TestRun, "testRunId">, cwd?: string): void;
-/**
- * Check if a requirement needs reporting based on cache state
- * Returns true if:
- * - Requirement was not covered in previous run, OR
- * - Previous run was more than 4 hours ago
- */
-export declare function needsReporting(requirementKey: string, cache: CoverageCache): boolean;
-/**
- * Get the list of requirements that need reporting
- * (new or changed since last run, or stale)
- */
-export declare function getRequirementsToReport(currentRequirementKeys: string[], cwd?: string): string[];
-//# sourceMappingURL=coverageCache.d.ts.map

package/dist/harness/coverageCache.js

@@ -1,70 +0,0 @@
-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
-/**
- * Load the coverage cache from disk
- */
-export function loadCache(cwd = process.cwd()) {
-    const cachePath = join(cwd, CACHE_FILE);
-    if (!existsSync(cachePath)) {
-        return { current: null, previous: null };
-    }
-    try {
-        const content = readFileSync(cachePath, "utf-8");
-        return JSON.parse(content);
-    }
-    catch {
-        // If cache is corrupt, start fresh
-        console.warn("Warning: Coverage cache is corrupt, starting fresh");
-        return { current: null, previous: null };
-    }
-}
-/**
- * Save a new test run to the cache, rotating current → previous
- */
-export function saveCache(testRun, cwd = process.cwd()) {
-    const cache = loadCache(cwd);
-    const cachePath = join(cwd, CACHE_FILE);
-    const newCache = {
-        current: {
-            testRunId: uuidv4(),
-            ...testRun,
-        },
-        previous: cache.current,
-    };
-    writeFileSync(cachePath, JSON.stringify(newCache, null, 2), "utf-8");
-}
-/**
- * Check if a requirement needs reporting based on cache state
- * Returns true if:
- * - Requirement was not covered in previous run, OR
- * - Previous run was more than 4 hours ago
- */
-export function needsReporting(requirementKey, cache) {
-    // If no previous run, everything needs reporting
-    if (!cache.current) {
-        return true;
-    }
-    // If requirement wasn't in current run, it needs reporting
-    if (!cache.current.requirementKeys.includes(requirementKey)) {
-        return true;
-    }
-    // If current run is stale (>4 hours old), needs reporting
-    const age = Date.now() - cache.current.timestamp;
-    if (age > STALENESS_THRESHOLD_MS) {
-        return true;
-    }
-    // Otherwise, skip reporting (already reported recently)
-    return false;
-}
-/**
- * Get the list of requirements that need reporting
- * (new or changed since last run, or stale)
- */
-export function getRequirementsToReport(currentRequirementKeys, cwd = process.cwd()) {
-    const cache = loadCache(cwd);
-    return currentRequirementKeys.filter((key) => needsReporting(key, cache));
-}
-//# sourceMappingURL=coverageCache.js.map