reffy-cli 1.1.1 → 1.1.2

package/dist/plan-archive.js

@@ -33,20 +33,27 @@ async function listFilesRecursive(dir) {
     }
     return files.sort();
 }
-function parseAddedRequirements(content, relPath) {
+function parseArchiveableRequirements(content, relPath) {
     const lines = content.split(/\r?\n/);
     const sectionTypes = new Set();
-    const blocks = [];
-    let inAddedSection = false;
+    const added = [];
+    const modified = [];
+    let currentSectionType = null;
     let currentTitle = null;
     let currentLines = [];
     const flush = () => {
         if (!currentTitle)
             return;
-        blocks.push({
+        const block = {
             title: currentTitle,
             content: currentLines.join("\n").trimEnd(),
-        });
+        };
+        if (currentSectionType === "ADDED") {
+            added.push(block);
+        }
+        else if (currentSectionType === "MODIFIED") {
+            modified.push(block);
+        }
         currentTitle = null;
         currentLines = [];
     };
@@ -56,7 +63,7 @@ function parseAddedRequirements(content, relPath) {
             flush();
             const sectionType = sectionMatch[1] ?? "";
             sectionTypes.add(sectionType);
-            inAddedSection = sectionType === "ADDED";
+            currentSectionType = sectionType === "ADDED" || sectionType === "MODIFIED" ? sectionType : null;
             continue;
         }
         const requirementMatch = line.match(REQUIREMENT_PATTERN);
@@ -71,17 +78,17 @@ function parseAddedRequirements(content, relPath) {
         }
     }
     flush();
-    const unsupported = Array.from(sectionTypes).filter((sectionType) => sectionType !== "ADDED");
+    const unsupported = Array.from(sectionTypes).filter((sectionType) => sectionType !== "ADDED" && sectionType !== "MODIFIED");
     if (unsupported.length > 0) {
         throw new Error(`${relPath}: unsupported delta sections for archive: ${unsupported.join(", ")}`);
     }
-    if (!inAddedSection && sectionTypes.size === 0) {
+    if (sectionTypes.size === 0) {
         throw new Error(`${relPath}: no supported archiveable requirements found`);
     }
-    if (blocks.length === 0) {
-        throw new Error(`${relPath}: no ADDED requirements found to archive`);
+    if (added.length === 0 && modified.length === 0) {
+        throw new Error(`${relPath}: no archiveable requirements found`);
     }
-    return blocks;
+    return { added, modified };
 }
 function buildNewCurrentSpec(capability, changeId, blocks) {
     return [
@@ -95,18 +102,74 @@ function buildNewCurrentSpec(capability, changeId, blocks) {
         "",
     ].join("\n");
 }
-function appendRequirementsToCurrentSpec(existing, blocks, relPath) {
+function parseCurrentSpecRequirementBlocks(existing, relPath) {
     if (!existing.includes(REQUIREMENTS_HEADING)) {
         throw new Error(`${relPath}: current spec is missing a "## Requirements" section`);
     }
-    for (const block of blocks) {
-        const escaped = block.title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const duplicatePattern = new RegExp(`^###\\s+Requirement:\\s+${escaped}\\s*$`, "m");
-        if (duplicatePattern.test(existing)) {
+    const lines = existing.split(/\r?\n/);
+    const blocks = [];
+    let inRequirements = false;
+    let currentTitle = null;
+    let currentLines = [];
+    const flush = () => {
+        if (!currentTitle)
+            return;
+        blocks.push({
+            title: currentTitle,
+            content: currentLines.join("\n").trimEnd(),
+        });
+        currentTitle = null;
+        currentLines = [];
+    };
+    for (const line of lines) {
+        if (line.trim() === REQUIREMENTS_HEADING) {
+            inRequirements = true;
+            continue;
+        }
+        if (!inRequirements) {
+            continue;
+        }
+        if (/^##\s+/.test(line) && line.trim() !== REQUIREMENTS_HEADING) {
+            flush();
+            break;
+        }
+        const requirementMatch = line.match(REQUIREMENT_PATTERN);
+        if (requirementMatch) {
+            flush();
+            currentTitle = requirementMatch[1]?.trim() ?? "unknown";
+            currentLines = [line];
+            continue;
+        }
+        if (currentTitle) {
+            currentLines.push(line);
+        }
+    }
+    flush();
+    return blocks;
+}
+function mergeRequirementsIntoCurrentSpec(existing, delta, relPath) {
+    const currentBlocks = parseCurrentSpecRequirementBlocks(existing, relPath);
+    const currentTitles = new Set(currentBlocks.map((block) => block.title));
+    for (const block of delta.added) {
+        if (currentTitles.has(block.title)) {
             throw new Error(`${relPath}: current spec already contains requirement "${block.title}"`);
         }
+        currentBlocks.push(block);
+        currentTitles.add(block.title);
+    }
+    for (const block of delta.modified) {
+        const index = currentBlocks.findIndex((currentBlock) => currentBlock.title === block.title);
+        if (index < 0) {
+            throw new Error(`${relPath}: current spec is missing requirement "${block.title}" required for MODIFIED archive`);
+        }
+        currentBlocks[index] = block;
+    }
+    const requirementsHeadingIndex = existing.indexOf(REQUIREMENTS_HEADING);
+    if (requirementsHeadingIndex < 0) {
+        throw new Error(`${relPath}: current spec is missing a "## Requirements" section`);
     }
-    return `${existing.trimEnd()}\n\n${blocks.map((block) => block.content).join("\n\n")}\n`;
+    const prefix = existing.slice(0, requirementsHeadingIndex + REQUIREMENTS_HEADING.length);
+    return `${prefix}\n${currentBlocks.map((block) => `\n${block.content}`).join("")}\n`;
 }
 async function buildSpecUpdates(repoRoot, changeId, changeDir) {
     const specsRoot = path.join(changeDir, "specs");
@@ -121,11 +184,17 @@ async function buildSpecUpdates(repoRoot, changeId, changeDir) {
             continue;
         const deltaContent = await fs.readFile(deltaPath, "utf8");
         const relDeltaPath = path.relative(repoRoot, deltaPath).split(path.sep).join("/");
-        const blocks = parseAddedRequirements(deltaContent, relDeltaPath);
+        const delta = parseArchiveableRequirements(deltaContent, relDeltaPath);
         const currentSpecPath = path.join(repoRoot, DEFAULT_PLANNING_DIRNAME, "specs", capability, "spec.md");
-        const nextContent = (await pathExists(currentSpecPath))
-            ? appendRequirementsToCurrentSpec(await fs.readFile(currentSpecPath, "utf8"), blocks, path.relative(repoRoot, currentSpecPath).split(path.sep).join("/"))
-            : buildNewCurrentSpec(capability, changeId, blocks);
+        const currentSpecExists = await pathExists(currentSpecPath);
+        const nextContent = currentSpecExists
+            ? mergeRequirementsIntoCurrentSpec(await fs.readFile(currentSpecPath, "utf8"), delta, path.relative(repoRoot, currentSpecPath).split(path.sep).join("/"))
+            : (() => {
+                if (delta.modified.length > 0) {
+                    throw new Error(`${relDeltaPath}: cannot archive MODIFIED requirements without an existing current spec`);
+                }
+                return buildNewCurrentSpec(capability, changeId, delta.added);
+            })();
         updates.set(currentSpecPath, nextContent);
     }
     return updates;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reffy-cli",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "CLI-first, framework-agnostic references workflow for any repo (TypeScript)",
   "keywords": [
     "reffy",