@popoverai/dotrequirements 0.22.0 → 0.24.0

package/dist/requirements/testCodeExtractor.js

@@ -0,0 +1,150 @@
+/**
+ * Extract test code context using @babel/parser AST traversal.
+ *
+ * Finds requirement() call references and extracts the enclosing
+ * meaningful code block (function, describe, test, etc.)
+ */
+import * as fs from "node:fs";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+/**
+ * Find all test code blocks that reference a specific requirement
+ */
+export function findTestCodeForRequirement(filePath, requirementId) {
+    try {
+        const code = fs.readFileSync(filePath, "utf-8");
+        const results = [];
+        // Parse with TypeScript and JSX support
+        const ast = parse(code, {
+            sourceType: "module",
+            plugins: ["typescript", "jsx"],
+            errorRecovery: true,
+        });
+        // Handle both ES module and CommonJS exports
+        const traverseFunc = 
+        // biome-ignore lint/suspicious/noExplicitAny: @babel/traverse CJS default-export interop (callable function vs namespace import)
+        typeof traverse === "function" ? traverse : traverse.default;
+        traverseFunc(ast, {
+            CallExpression(path) {
+                // Check if this is a requirement('ID', ...) call
+                const callee = path.node.callee;
+                if (t.isIdentifier(callee) && callee.name === "requirement") {
+                    const args = path.node.arguments;
+                    // Extract all string literal arguments (supports multi-requirement calls)
+                    const refIds = [];
+                    for (const arg of args) {
+                        if (t.isStringLiteral(arg)) {
+                            refIds.push(arg.value);
+                        }
+                    }
+                    // Check if any argument matches the requirement we're looking for
+                    // Match exact ID or if it's a child (e.g., searching for REQ-123 matches REQ-123.0)
+                    for (const refId of refIds) {
+                        const isMatch = refId === requirementId || refId.startsWith(`${requirementId}.`);
+                        if (isMatch) {
+                            // Find the meaningful enclosing block
+                            const contextNode = findMeaningfulParent(path);
+                            if (contextNode?.node.loc) {
+                                const { start, end } = contextNode.node.loc;
+                                const nodeStart = contextNode.node.start ?? 0;
+                                const nodeEnd = contextNode.node.end ?? code.length;
+                                results.push({
+                                    file: filePath,
+                                    startLine: start.line,
+                                    endLine: end.line,
+                                    code: code.slice(nodeStart, nodeEnd),
+                                    requirementId: refId,
+                                });
+                            }
+                            // Only add one result per call expression, even if multiple refs match
+                            break;
+                        }
+                    }
+                }
+            },
+        });
+        return results;
+    }
+    catch (error) {
+        console.error(`Error parsing ${filePath}:`, error);
+        return [];
+    }
+}
+/**
+ * Walk up the AST to find the nearest "meaningful" parent node.
+ * This could be a function, describe/test/it call, method, etc.
+ */
+function findMeaningfulParent(path) {
+    let current = path;
+    while (current) {
+        const node = current.node;
+        // Check for various meaningful boundaries
+        if (t.isFunctionDeclaration(node) ||
+            t.isFunctionExpression(node) ||
+            t.isArrowFunctionExpression(node) ||
+            t.isClassMethod(node) ||
+            t.isObjectMethod(node)) {
+            return current;
+        }
+        // Check for call expressions (describe, test, it, etc.)
+        if (t.isCallExpression(node)) {
+            const callee = node.callee;
+            // Common test framework function names
+            const testFunctionNames = [
+                "describe",
+                "it",
+                "test",
+                "suite",
+                "context",
+                "beforeEach",
+                "afterEach",
+                "beforeAll",
+                "afterAll",
+            ];
+            if (t.isIdentifier(callee) && testFunctionNames.includes(callee.name)) {
+                return current;
+            }
+        }
+        // Check for variable declarations that might contain test functions
+        if (t.isVariableDeclarator(node)) {
+            return current;
+        }
+        // Check for export declarations (for Storybook stories, etc.)
+        if (t.isExportNamedDeclaration(node) ||
+            t.isExportDefaultDeclaration(node)) {
+            return current;
+        }
+        current = current.parentPath;
+    }
+    return null;
+}
+/**
+ * Find all files that reference a requirement
+ */
+export function findFilesWithRequirement(files, requirementId) {
+    const matchingFiles = [];
+    for (const file of files) {
+        try {
+            const code = fs.readFileSync(file, "utf-8");
+            // Check for exact match or child references (e.g., AUTH-VALID-LOGIN or AUTH-VALID-LOGIN.0)
+            // Simple string search first for performance
+            // Patterns match both single and multi-arg calls:
+            //   requirement('REQ-123')
+            //   requirement('REQ-123', 'REQ-456')
+            //   requirement('REQ-456', 'REQ-123')  <-- ID anywhere in args
+            const hasMatch = code.includes(`'${requirementId}'`) ||
+                code.includes(`"${requirementId}"`) ||
+                code.includes(`\`${requirementId}\``) ||
+                code.includes(`'${requirementId}.`) ||
+                code.includes(`"${requirementId}.`) ||
+                code.includes(`\`${requirementId}.`);
+            if (hasMatch) {
+                matchingFiles.push(file);
+            }
+        }
+        catch { }
+    }
+    return matchingFiles;
+}
+//# sourceMappingURL=testCodeExtractor.js.map

package/dist/schema/browser.d.ts

@@ -3,10 +3,12 @@
  * This file excludes Node.js-specific functionality (file I/O, fs module).
  * Use this entry point when importing from browser/web environments.
  */
-export { MetadataSchema, RequirementNodeSchema, RequirementsFileSchema, ParsedCriterionSchema, RequirementPrefixSchema, RequirementKeySchema, REQUIREMENT_PREFIX_PATTERN, REQUIREMENT_KEY_PATTERN, ValidationError, validateMetadata, validateRequirementNode, validateRequirementsFile, validatePrefix, validateKey, normalizePrefix, parseRequirementKey, buildRequirementKey, } from './schemas.js';
-export type { Metadata, RequirementNode, RequirementsFile, ParsedCriterion, RequirementPrefix, RequirementKey, } from './schemas.js';
-export { DEFAULT_DELIMITER, buildRequirementsMarkdown, buildRequirementMarkdown, } from './builder.js';
-export type { ConvexRequirement, } from './conversions.js';
-export { convexToRequirements, requirementsToConvex, buildMetadata, extractRequirementKeys, groupByRoot, constructKey, parseKey, } from './conversions.js';
-export { DELIMITER_PATTERN, parseCriterionLine, parseRootLine, parseRequirementBlock, extractRequirementBlocks, parseRequirementBlocksFromMarkdown, flattenRequirementTree, findRequirementById, getAllRequirements, } from './parser-core.js';
+export { buildRequirementMarkdown, buildRequirementsMarkdown, DEFAULT_DELIMITER, } from "./builder.js";
+export type { ConvexRequirement } from "./conversions.js";
+export { buildMetadata, constructKey, convexToRequirements, extractRequirementKeys, groupByRoot, parseKey, requirementsToConvex, } from "./conversions.js";
+export { DELIMITER_PATTERN, extractRequirementBlocks, findRequirementById, flattenRequirementTree, getAllRequirements, parseCriterionLine, parseRequirementBlock, parseRequirementBlocksFromMarkdown, parseRootLine, } from "./parser-core.js";
+export type { Metadata, ParsedCriterion, RequirementKey, RequirementNode, RequirementPrefix, RequirementsFile, } from "./schemas.js";
+export { buildRequirementKey, MetadataSchema, normalizePrefix, ParsedCriterionSchema, parseRequirementKey, REQUIREMENT_KEY_PATTERN, REQUIREMENT_PREFIX_PATTERN, RequirementKeySchema, RequirementNodeSchema, RequirementPrefixSchema, RequirementsFileSchema, ValidationError, validateKey, validateMetadata, validatePrefix, validateRequirementNode, validateRequirementsFile, } from "./schemas.js";
+export type { BuildScenarioOptions, Scenario, ScenarioAssertionSource, ScenarioStep, } from "./scenario.js";
+export { buildScenarioFromRequirements, requirementTreeToScenario, } from "./scenario.js";
 //# sourceMappingURL=browser.d.ts.map

package/dist/schema/browser.js

@@ -3,22 +3,22 @@
  * This file excludes Node.js-specific functionality (file I/O, fs module).
  * Use this entry point when importing from browser/web environments.
  */
+// Building (uses yaml package - browser-safe)
+export { buildRequirementMarkdown, buildRequirementsMarkdown, DEFAULT_DELIMITER, } from "./builder.js";
+export { buildMetadata, constructKey, convexToRequirements, extractRequirementKeys, groupByRoot, parseKey, requirementsToConvex, } from "./conversions.js";
+// Parser core (pure TypeScript - browser-safe, no fs dependency)
+// These functions parse markdown strings directly without file I/O
+export { DELIMITER_PATTERN, extractRequirementBlocks, findRequirementById, flattenRequirementTree, getAllRequirements, parseCriterionLine, parseRequirementBlock, parseRequirementBlocksFromMarkdown, parseRootLine, } from "./parser-core.js";
 // Schemas and types (uses zod - browser-safe)
-export { 
+export { buildRequirementKey, 
 // Zod schemas
-MetadataSchema, RequirementNodeSchema, RequirementsFileSchema, ParsedCriterionSchema, RequirementPrefixSchema, RequirementKeySchema, 
+MetadataSchema, 
+// Prefix/key utilities
+normalizePrefix, ParsedCriterionSchema, parseRequirementKey, REQUIREMENT_KEY_PATTERN, 
 // Patterns (for external validation)
-REQUIREMENT_PREFIX_PATTERN, REQUIREMENT_KEY_PATTERN, 
+REQUIREMENT_PREFIX_PATTERN, RequirementKeySchema, RequirementNodeSchema, RequirementPrefixSchema, RequirementsFileSchema, 
 // Validation
-ValidationError, validateMetadata, validateRequirementNode, validateRequirementsFile, validatePrefix, validateKey, 
-// Prefix/key utilities
-normalizePrefix, parseRequirementKey, buildRequirementKey, } from './schemas.js';
-// Building (uses yaml package - browser-safe)
-export { DEFAULT_DELIMITER, buildRequirementsMarkdown, buildRequirementMarkdown, } from './builder.js';
-export { convexToRequirements, requirementsToConvex, buildMetadata, extractRequirementKeys, groupByRoot, constructKey, parseKey, } from './conversions.js';
-// Parser core (pure TypeScript - browser-safe, no fs dependency)
-// These functions parse markdown strings directly without file I/O
-export { DELIMITER_PATTERN, parseCriterionLine, parseRootLine, parseRequirementBlock, extractRequirementBlocks, parseRequirementBlocksFromMarkdown, flattenRequirementTree, findRequirementById, getAllRequirements, } from './parser-core.js';
-// NOTE: parser.ts and resolver.ts are excluded because they use Node.js 'fs' module.
-// Use parser-core.ts functions above for browser/Convex environments.
+ValidationError, validateKey, validateMetadata, validatePrefix, validateRequirementNode, validateRequirementsFile, } from "./schemas.js";
+// Scenario building (pure TypeScript - browser-safe, used by Convex Node actions)
+export { buildScenarioFromRequirements, requirementTreeToScenario, } from "./scenario.js";
 //# sourceMappingURL=browser.js.map

package/dist/schema/builder.d.ts

@@ -1,7 +1,7 @@
 /**
  * Build Markdown requirements files from structured data.
  */
-import { RequirementNode, Metadata } from './schemas.js';
+import type { Metadata, RequirementNode } from "./schemas.js";
 /**
  * Default delimiter for requirements.
  * Can be overridden for organization-specific preferences.

package/dist/schema/builder.js

@@ -1,12 +1,12 @@
 /**
  * Build Markdown requirements files from structured data.
  */
-import YAML from 'yaml';
+import YAML from "yaml";
 /**
  * Default delimiter for requirements.
  * Can be overridden for organization-specific preferences.
  */
-export const DEFAULT_DELIMITER = '→';
+export const DEFAULT_DELIMITER = "→";
 /**
  * Build YAML frontmatter from metadata.
  */
@@ -17,51 +17,20 @@ function buildFrontmatter(metadata) {
     });
     return `---\n${yamlStr.trim()}\n---`;
 }
-/**
- * Build a dotrequirements block from a requirement node.
- * Formats children with explicit position paths and proper indentation.
- */
-function buildRequirementBlock(node, delimiter = DEFAULT_DELIMITER) {
-    // First line: root requirement with delimiter
-    // Include label if it's not empty (empty string means unlabeled)
-    const rootLabel = node.label
-        ? `${node.label.charAt(0).toUpperCase() + node.label.slice(1)} `
-        : '';
-    let block = `${rootLabel}${delimiter} ${node.content}\n`;
-    // Recursively build criteria lines
-    function addCriteria(children, parentPosition = '') {
-        children.forEach((child, index) => {
-            const position = parentPosition === '' ? `${index}` : `${parentPosition}.${index}`;
-            const depth = position.split('.').length - 1;
-            const indent = '  '.repeat(depth + 1); // 2 spaces per level
-            // Include label if present, otherwise just delimiter
-            const labelPart = child.label
-                ? `${child.label.charAt(0).toUpperCase() + child.label.slice(1)} `
-                : '';
-            block += `${indent}${position}. ${labelPart}${delimiter} ${child.content}\n`;
-            // Recursively add grandchildren
-            if (child.children && child.children.length > 0) {
-                addCriteria(child.children, position);
-            }
-        });
-    }
-    addCriteria(node.children);
-    return block.trimEnd();
-}
 /**
  * Build the children portion of a requirement block (without the root line).
  */
 function buildChildrenBlock(children) {
-    let block = '';
-    function addChildren(nodes, parentPosition = '') {
+    let block = "";
+    function addChildren(nodes, parentPosition = "") {
         nodes.forEach((child, index) => {
-            const position = parentPosition === '' ? `${index}` : `${parentPosition}.${index}`;
-            const depth = position.split('.').length - 1;
-            const indent = '  '.repeat(depth + 1); // 2 spaces per level
+            const position = parentPosition === "" ? `${index}` : `${parentPosition}.${index}`;
+            const depth = position.split(".").length - 1;
+            const indent = "  ".repeat(depth + 1); // 2 spaces per level
             // Include label if present, otherwise just delimiter
             const labelPart = child.label
                 ? `${child.label.charAt(0).toUpperCase() + child.label.slice(1)} `
-                : '';
+                : "";
             block += `${indent}${position}. ${labelPart}→ ${child.content}\n`;
             // Recursively add grandchildren
             if (child.children && child.children.length > 0) {
@@ -79,14 +48,14 @@ function buildRequirementSection(node, title) {
     const displayTitle = title || node.content;
     // Heading now just has the title, no key
     let section = `## ${displayTitle}\n\n`;
-    section += '```dotrequirements\n';
+    section += "```dotrequirements\n";
     // First line of block has the key
     section += `${node.id}: ${node.content}\n`;
     // Then add children
     if (node.children && node.children.length > 0) {
         section += buildChildrenBlock(node.children);
     }
-    section += '\n```\n';
+    section += "\n```\n";
     return section;
 }
 /**
@@ -94,7 +63,7 @@ function buildRequirementSection(node, title) {
  */
 export function buildRequirementsMarkdown(metadata, requirements, documentTitle) {
     let markdown = buildFrontmatter(metadata);
-    markdown += '\n\n';
+    markdown += "\n\n";
     // Add document title if provided
     if (documentTitle) {
         markdown += `# ${documentTitle}\n\n`;
@@ -102,9 +71,9 @@ export function buildRequirementsMarkdown(metadata, requirements, documentTitle)
     // Add each requirement section
     for (const req of requirements) {
         markdown += buildRequirementSection(req);
-        markdown += '\n';
+        markdown += "\n";
     }
-    return markdown.trimEnd() + '\n';
+    return `${markdown.trimEnd()}\n`;
 }
 /**
  * Build Markdown for a single requirement (for testing/debugging).

package/dist/schema/conversions.d.ts

@@ -1,7 +1,7 @@
 /**
  * Convert between Convex flat representation and hierarchical RequirementNode trees.
  */
-import { RequirementNode, Metadata } from './schemas.js';
+import type { Metadata, RequirementNode } from "./schemas.js";
 /**
  * Convex requirement type (flat structure with position paths).
  * This mirrors the Convex database schema.
@@ -16,7 +16,7 @@ export interface ConvexRequirement {
     projectId: string;
     rootId?: string;
     position?: string;
-    metadata?: any;
+    metadata?: unknown;
     externalLinks?: {
         jira?: string;
         notion?: string;

package/dist/schema/conversions.js

@@ -25,7 +25,7 @@ export function parseKey(key) {
  */
 export function convexToRequirements(convexReqs) {
     // Separate roots from children
-    const roots = convexReqs.filter(r => !r.rootId);
+    const roots = convexReqs.filter((r) => !r.rootId);
     // Build a map of all requirements by their position path for each root
     const reqsByRoot = new Map();
     for (const req of convexReqs) {
@@ -35,11 +35,11 @@ export function convexToRequirements(convexReqs) {
                 rootMap = new Map();
                 reqsByRoot.set(req.rootId, rootMap);
             }
-            rootMap.set(req.position || '', req);
+            rootMap.set(req.position || "", req);
         }
     }
     // Build trees for each root
-    return roots.map(root => buildTreeFromPositions(root, reqsByRoot.get(root._id)));
+    return roots.map((root) => buildTreeFromPositions(root, reqsByRoot.get(root._id)));
 }
 /**
  * Recursively build a RequirementNode tree from position-based flat structure.
@@ -70,9 +70,9 @@ function buildTreeFromPositions(convexReq, positionMap) {
     // Find direct children based on position paths
     // If this is a root (no position), find children at positions like ".0", ".1"
     // If this has position ".0", find children at positions like ".0.0", ".0.1"
-    const currentPosition = convexReq.position || '';
+    const currentPosition = convexReq.position || "";
     const childPositionPattern = currentPosition
-        ? new RegExp(`^${currentPosition.replace(/\./g, '\\.')}\\.\\d+$`)
+        ? new RegExp(`^${currentPosition.replace(/\./g, "\\.")}\\.\\d+$`)
         : /^\.\d+$/;
     const children = [];
     for (const [pos, req] of positionMap.entries()) {
@@ -82,10 +82,10 @@ function buildTreeFromPositions(convexReq, positionMap) {
     }
     // Sort children by position
     const sortedChildren = children.sort((a, b) => {
-        return comparePositions(a.position || '', b.position || '');
+        return comparePositions(a.position || "", b.position || "");
     });
     // Recursively build child nodes
-    node.children = sortedChildren.map(child => buildTreeFromPositions(child, positionMap));
+    node.children = sortedChildren.map((child) => buildTreeFromPositions(child, positionMap));
     return node;
 }
 /**
@@ -93,8 +93,8 @@ function buildTreeFromPositions(convexReq, positionMap) {
  * Positions are like ".0", ".1", ".0.0", ".0.1"
  */
 function comparePositions(a, b) {
-    const aParts = a.split('.').filter(Boolean).map(Number);
-    const bParts = b.split('.').filter(Boolean).map(Number);
+    const aParts = a.split(".").filter(Boolean).map(Number);
+    const bParts = b.split(".").filter(Boolean).map(Number);
     for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
         const aVal = aParts[i] ?? -1;
         const bVal = bParts[i] ?? -1;
@@ -125,7 +125,7 @@ function flattenNode(node, projectId, rootId, position, result, documentId) {
     // Get prefix/index from metadata (if from round-trip) or parse from node.id
     let prefix;
     let index;
-    if (node.metadata?.prefix && typeof node.metadata?.index === 'number') {
+    if (node.metadata?.prefix && typeof node.metadata?.index === "number") {
         // Round-trip case: use stored prefix/index
         prefix = node.metadata.prefix;
         index = node.metadata.index;
@@ -181,7 +181,7 @@ export function buildMetadata(version = 1, document) {
  * Useful for detecting duplicates or tracking which requirements exist.
  */
 export function extractRequirementKeys(convexReqs) {
-    return new Set(convexReqs.map(r => constructKey(r.prefix, r.index)));
+    return new Set(convexReqs.map((r) => constructKey(r.prefix, r.index)));
 }
 /**
  * Group Convex requirements by their root.

package/dist/schema/index.d.ts

@@ -4,11 +4,13 @@
  * This module provides types, validation, parsing, and building utilities
  * for the Markdown requirements format.
  */
-export { MetadataSchema, RequirementNodeSchema, RequirementsFileSchema, ParsedCriterionSchema, RequirementPrefixSchema, RequirementKeySchema, REQUIREMENT_PREFIX_PATTERN, REQUIREMENT_KEY_PATTERN, ValidationError, validateMetadata, validateRequirementNode, validateRequirementsFile, validatePrefix, validateKey, validateForPush, CONVEX_ID_PATTERN, normalizePrefix, parseRequirementKey, buildRequirementKey, } from './schemas.js';
-export type { Metadata, RequirementNode, RequirementsFile, ParsedCriterion, RequirementPrefix, RequirementKey, PushValidationResult, } from './schemas.js';
-export { parseCriterionLine, parseRequirementBlock, parseRequirementsFile, parseRequirementsFromFile, flattenRequirementTree, findRequirementById, getAllRequirements, } from './parser.js';
-export { buildRequirementsMarkdown, buildRequirementMarkdown, buildRequirementsFile, } from './builder.js';
-export { parseRequirementPath, parsePathSegment, findChildrenByLabel, resolvePathSegment, resolveRequirementPath, resolveToNumericPath, getAllLabelPaths, checkPathAmbiguity, } from './resolver.js';
-export type { ConvexRequirement, } from './conversions.js';
-export { convexToRequirements, requirementsToConvex, buildMetadata, extractRequirementKeys, groupByRoot, constructKey, parseKey, } from './conversions.js';
+export { buildRequirementMarkdown, buildRequirementsFile, buildRequirementsMarkdown, } from "./builder.js";
+export type { ConvexRequirement } from "./conversions.js";
+export { buildMetadata, constructKey, convexToRequirements, extractRequirementKeys, groupByRoot, parseKey, requirementsToConvex, } from "./conversions.js";
+export { findRequirementById, flattenRequirementTree, getAllRequirements, parseCriterionLine, parseRequirementBlock, parseRequirementsFile, parseRequirementsFromFile, } from "./parser.js";
+export { checkPathAmbiguity, findChildrenByLabel, getAllLabelPaths, parsePathSegment, parseRequirementPath, resolvePathSegment, resolveRequirementPath, resolveToNumericPath, } from "./resolver.js";
+export type { BuildScenarioOptions, Scenario, ScenarioAssertionSource, ScenarioStep, } from "./scenario.js";
+export { buildScenarioFromRequirements, requirementTreeToScenario, } from "./scenario.js";
+export type { Metadata, ParsedCriterion, PushValidationResult, RequirementKey, RequirementNode, RequirementPrefix, RequirementsFile, } from "./schemas.js";
+export { buildRequirementKey, CONVEX_ID_PATTERN, MetadataSchema, normalizePrefix, ParsedCriterionSchema, parseRequirementKey, REQUIREMENT_KEY_PATTERN, REQUIREMENT_PREFIX_PATTERN, RequirementKeySchema, RequirementNodeSchema, RequirementPrefixSchema, RequirementsFileSchema, ValidationError, validateForPush, validateKey, validateMetadata, validatePrefix, validateRequirementNode, validateRequirementsFile, } from "./schemas.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/schema/index.js

@@ -4,21 +4,23 @@
  * This module provides types, validation, parsing, and building utilities
  * for the Markdown requirements format.
  */
+// Building
+export { buildRequirementMarkdown, buildRequirementsFile, buildRequirementsMarkdown, } from "./builder.js";
+export { buildMetadata, constructKey, convexToRequirements, extractRequirementKeys, groupByRoot, parseKey, requirementsToConvex, } from "./conversions.js";
+// Parsing
+export { findRequirementById, flattenRequirementTree, getAllRequirements, parseCriterionLine, parseRequirementBlock, parseRequirementsFile, parseRequirementsFromFile, } from "./parser.js";
+// Path resolution
+export { checkPathAmbiguity, findChildrenByLabel, getAllLabelPaths, parsePathSegment, parseRequirementPath, resolvePathSegment, resolveRequirementPath, resolveToNumericPath, } from "./resolver.js";
+// Scenario building (for browser-automation / runScenario)
+export { buildScenarioFromRequirements, requirementTreeToScenario, } from "./scenario.js";
 // Schemas and types
-export { 
+export { buildRequirementKey, CONVEX_ID_PATTERN, 
 // Zod schemas
-MetadataSchema, RequirementNodeSchema, RequirementsFileSchema, ParsedCriterionSchema, RequirementPrefixSchema, RequirementKeySchema, 
+MetadataSchema, 
+// Prefix/key utilities
+normalizePrefix, ParsedCriterionSchema, parseRequirementKey, REQUIREMENT_KEY_PATTERN, 
 // Patterns (for external validation)
-REQUIREMENT_PREFIX_PATTERN, REQUIREMENT_KEY_PATTERN, 
+REQUIREMENT_PREFIX_PATTERN, RequirementKeySchema, RequirementNodeSchema, RequirementPrefixSchema, RequirementsFileSchema, 
 // Validation
-ValidationError, validateMetadata, validateRequirementNode, validateRequirementsFile, validatePrefix, validateKey, validateForPush, CONVEX_ID_PATTERN, 
-// Prefix/key utilities
-normalizePrefix, parseRequirementKey, buildRequirementKey, } from './schemas.js';
-// Parsing
-export { parseCriterionLine, parseRequirementBlock, parseRequirementsFile, parseRequirementsFromFile, flattenRequirementTree, findRequirementById, getAllRequirements, } from './parser.js';
-// Building
-export { buildRequirementsMarkdown, buildRequirementMarkdown, buildRequirementsFile, } from './builder.js';
-// Path resolution
-export { parseRequirementPath, parsePathSegment, findChildrenByLabel, resolvePathSegment, resolveRequirementPath, resolveToNumericPath, getAllLabelPaths, checkPathAmbiguity, } from './resolver.js';
-export { convexToRequirements, requirementsToConvex, buildMetadata, extractRequirementKeys, groupByRoot, constructKey, parseKey, } from './conversions.js';
+ValidationError, validateForPush, validateKey, validateMetadata, validatePrefix, validateRequirementNode, validateRequirementsFile, } from "./schemas.js";
 //# sourceMappingURL=index.js.map

package/dist/schema/parser-core.d.ts

@@ -4,7 +4,7 @@
  * This module contains pure parsing functions with no Node.js dependencies,
  * making it safe to import in Convex runtime or browser environments.
  */
-import { RequirementNode, ParsedCriterion } from './schemas.js';
+import { type ParsedCriterion, type RequirementNode } from "./schemas.js";
 /**
  * Default delimiter for requirements.
  * Can be overridden for organization-specific preferences.

package/dist/schema/parser-core.js

@@ -4,13 +4,13 @@
  * This module contains pure parsing functions with no Node.js dependencies,
  * making it safe to import in Convex runtime or browser environments.
  */
-import { ValidationError, } from './schemas.js';
+import { ValidationError, } from "./schemas.js";
 /**
  * Default delimiter for requirements.
  * Can be overridden for organization-specific preferences.
  */
-export const DEFAULT_DELIMITER = '→';
-export const DELIMITER_PATTERN = '(?:→|->)'; // Non-capturing group for both Unicode and ASCII
+export const DEFAULT_DELIMITER = "→";
+export const DELIMITER_PATTERN = "(?:→|->)"; // Non-capturing group for both Unicode and ASCII
 /**
  * Parse a criterion line in "position. Label → content" format.
  * Example: "0. Given → user has valid credentials"
@@ -27,7 +27,7 @@ export function parseCriterionLine(line, delimiter = DELIMITER_PATTERN) {
     }
     return {
         position: match[1],
-        label: match[2] ? match[2].trim() : '', // Preserve original case, empty if no label
+        label: match[2] ? match[2].trim() : "", // Preserve original case, empty if no label
         content: match[3].trim(),
     };
 }
@@ -43,7 +43,7 @@ export function parseRootLine(line, delimiter = DELIMITER_PATTERN) {
     if (keyMatch) {
         return {
             key: keyMatch[1],
-            label: '', // Keys use empty string for unlabeled requirements
+            label: "", // Keys use empty string for unlabeled requirements
             content: keyMatch[2].trim(),
         };
     }
@@ -53,12 +53,12 @@ export function parseRootLine(line, delimiter = DELIMITER_PATTERN) {
     if (!match) {
         // If no delimiter found, treat entire line as content with empty label
         return {
-            label: '',
+            label: "",
             content: trimmed,
         };
     }
     return {
-        label: match[1] ? match[1].trim() : '',
+        label: match[1] ? match[1].trim() : "",
         content: match[2].trim(),
     };
 }
@@ -68,20 +68,20 @@ export function parseRootLine(line, delimiter = DELIMITER_PATTERN) {
  * Subsequent lines are criteria with position paths.
  */
 export function parseRequirementBlock(key, blockContent) {
-    const lines = blockContent.trim().split('\n');
+    const lines = blockContent.trim().split("\n");
     if (lines.length === 0) {
-        throw new ValidationError('Empty requirement block', key);
+        throw new ValidationError("Empty requirement block", key);
     }
     // First line is the requirement content
     const rootParsed = parseRootLine(lines[0]);
     if (!rootParsed.content) {
-        throw new ValidationError('Requirement content (first line) cannot be empty', key);
+        throw new ValidationError("Requirement content (first line) cannot be empty", key);
     }
     const root = {
         id: key,
         // Root requirements always use "requirementHeader" label for indexing/querying
         // The markdown format doesn't preserve root labels, but we standardize on this value
-        label: 'requirementHeader',
+        label: "requirementHeader",
         content: rootParsed.content,
         children: [],
     };
@@ -90,7 +90,7 @@ export function parseRequirementBlock(key, blockContent) {
     for (let i = 1; i < lines.length; i++) {
         const line = lines[i];
         // Skip empty lines and comments
-        if (!line.trim() || line.trim().startsWith('#')) {
+        if (!line.trim() || line.trim().startsWith("#")) {
             continue;
         }
         const criterion = parseCriterionLine(line);
@@ -98,7 +98,7 @@ export function parseRequirementBlock(key, blockContent) {
             // Check if this looks like another requirement key (KEY: content format)
             const trimmedLine = line.trim();
             if (/^[\w-]+:\s*.+/.test(trimmedLine)) {
-                throw new ValidationError(`Multiple requirements in single block. Found "${trimmedLine.split(':')[0]}" at line ${i + 1}, but each requirement must have its own \`\`\`dotrequirements code block.`, key);
+                throw new ValidationError(`Multiple requirements in single block. Found "${trimmedLine.split(":")[0]}" at line ${i + 1}, but each requirement must have its own \`\`\`dotrequirements code block.`, key);
             }
             throw new ValidationError(`Invalid criterion format at line ${i + 1}: "${trimmedLine}". Expected format: "N. Label → content" (e.g., "0. Given → user is logged in")`, key);
         }
@@ -115,8 +115,8 @@ export function parseRequirementBlock(key, blockContent) {
 function buildTreeFromPositions(root, rootKey, criteriaByPosition) {
     // Get all top-level children (single digit positions: "0", "1", "2")
     const topLevelPositions = Array.from(criteriaByPosition.keys())
-        .filter(pos => !pos.includes('.'))
-        .sort((a, b) => parseInt(a) - parseInt(b));
+        .filter((pos) => !pos.includes("."))
+        .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
     for (const position of topLevelPositions) {
         const criterion = criteriaByPosition.get(position);
         const childNode = {
@@ -136,9 +136,9 @@ function buildTreeFromPositions(root, rootKey, criteriaByPosition) {
 function buildChildrenFromPositions(parent, parentPosition, rootKey, criteriaByPosition) {
     // Find direct children (e.g., if parent is "1", find "1.0", "1.1", etc.)
     const childPositions = Array.from(criteriaByPosition.keys())
-        .filter(pos => {
-        const parts = pos.split('.');
-        const parentParts = parentPosition.split('.');
+        .filter((pos) => {
+        const parts = pos.split(".");
+        const parentParts = parentPosition.split(".");
         // Must be exactly one level deeper
         if (parts.length !== parentParts.length + 1) {
             return false;
@@ -152,8 +152,8 @@ function buildChildrenFromPositions(parent, parentPosition, rootKey, criteriaByP
         return true;
     })
         .sort((a, b) => {
-        const aLast = parseInt(a.split('.').pop());
-        const bLast = parseInt(b.split('.').pop());
+        const aLast = parseInt(a.split(".").pop(), 10);
+        const bLast = parseInt(b.split(".").pop(), 10);
         return aLast - bLast;
     });
     for (const position of childPositions) {
@@ -177,8 +177,8 @@ export function extractRequirementBlocks(body) {
     const blocks = [];
     // Find all ```dotrequirements code blocks
     const blockRegex = /```dotrequirements\n([\s\S]*?)```/gm;
-    let match;
-    while ((match = blockRegex.exec(body)) !== null) {
+    let match = blockRegex.exec(body);
+    while (match !== null) {
         const blockContent = match[1];
         // Extract key from first line of block (format: "KEY: content")
         const firstLineMatch = blockContent.match(/^([\w-]+):\s*(.+)/);
@@ -187,6 +187,7 @@ export function extractRequirementBlocks(body) {
         }
         const key = firstLineMatch[1];
         blocks.push({ key, blockContent: blockContent.trim() });
+        match = blockRegex.exec(body);
     }
     return blocks;
 }