specweave 0.21.2 → 0.21.3

package/plugins/specweave/lib/hooks/update-ac-status.js

@@ -1,88 +1,37 @@
 #!/usr/bin/env node
-import * as fs from "fs/promises";
-import * as path from "path";
+import { ACStatusManager } from "../../../../dist/src/core/increment/ac-status-manager.js";
 async function updateACStatus(incrementId) {
   try {
     const projectRoot = process.cwd();
-    const incrementPath = path.join(projectRoot, ".specweave/increments", incrementId);
-    try {
-      await fs.access(incrementPath);
-    } catch {
-      console.error(`\u274C Increment ${incrementId} not found at ${incrementPath}`);
+    if (process.env.SKIP_AC_SYNC === "true") {
+      console.log("\u2139\uFE0F  AC sync skipped (SKIP_AC_SYNC=true)");
       return;
     }
-    console.log(`\u{1F504} Updating AC status for increment ${incrementId}...`);
-    const completedACs = await extractCompletedACsFromTasks(incrementPath);
-    if (completedACs.size === 0) {
-      console.log(`\u2139\uFE0F  No completed tasks with AC-IDs found in tasks.md`);
-      return;
-    }
-    console.log(`\u2713 Found ${completedACs.size} completed AC-IDs from tasks.md`);
-    const updatedCount = await updateSpecACCheckboxes(incrementPath, completedACs);
-    if (updatedCount > 0) {
-      console.log(`\u2705 Updated ${updatedCount} AC checkbox(es) in spec.md`);
-    } else {
-      console.log(`\u2139\uFE0F  No AC checkboxes needed updating in spec.md`);
-    }
-  } catch (error) {
-    console.error("\u274C Error updating AC status:", error);
-  }
-}
-async function extractCompletedACsFromTasks(incrementPath) {
-  const tasksPath = path.join(incrementPath, "tasks.md");
-  const completedACs = /* @__PURE__ */ new Set();
-  try {
-    const tasksContent = await fs.readFile(tasksPath, "utf-8");
-    const taskSections = tasksContent.split(/^(###+)\s+T-\d+:/gm);
-    for (let i = 1; i < taskSections.length; i += 2) {
-      const taskContent = taskSections[i + 1];
-      const statusMatch = taskContent.match(/\*\*Status\*\*:\s*\[x\]/i);
-      if (!statusMatch) continue;
-      const acMatch = taskContent.match(/\*\*AC\*\*:\s*([^\n]+)/);
-      if (!acMatch) continue;
-      const acField = acMatch[1];
-      const acIds = acField.split(",").map((id) => id.trim()).filter((id) => /^AC-[A-Z0-9]+-\d+$/.test(id));
-      acIds.forEach((acId) => completedACs.add(acId));
+    console.log(`\u{1F504} Syncing AC status for increment ${incrementId}...`);
+    const manager = new ACStatusManager(projectRoot);
+    const result = await manager.syncACStatus(incrementId);
+    if (result.warnings && result.warnings.length > 0) {
+      console.log("\n\u26A0\uFE0F  Warnings:");
+      result.warnings.forEach((warning) => console.log(`   ${warning}`));
     }
-    return completedACs;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      console.log(`\u2139\uFE0F  tasks.md not found, skipping AC update`);
-    } else {
-      console.error("Error reading tasks.md:", error);
+    if (result.conflicts && result.conflicts.length > 0) {
+      console.log("\n\u26A0\uFE0F  Conflicts detected:");
+      result.conflicts.forEach((conflict) => console.log(`   ${conflict}`));
     }
-    return completedACs;
-  }
-}
-async function updateSpecACCheckboxes(incrementPath, completedACs) {
-  const specPath = path.join(incrementPath, "spec.md");
-  try {
-    let specContent = await fs.readFile(specPath, "utf-8");
-    let updatedCount = 0;
-    const acPattern = /^(\s*)-\s+\[([ x])\]\s+\*\*([A-Z]+-[A-Z0-9]+-\d+)\*\*:(.*)$/gm;
-    specContent = specContent.replace(acPattern, (match, indent, currentState, acId, description) => {
-      const shouldBeChecked = completedACs.has(acId);
-      const isCurrentlyChecked = currentState === "x";
-      if (shouldBeChecked && !isCurrentlyChecked) {
-        updatedCount++;
-        return `${indent}- [x] **${acId}**:${description}`;
-      } else if (!shouldBeChecked && isCurrentlyChecked) {
-        updatedCount++;
-        return `${indent}- [ ] **${acId}**:${description}`;
+    if (result.updated && result.updated.length > 0) {
+      console.log("\n\u2705 Updated AC checkboxes:");
+      result.updated.forEach((acId) => console.log(`   ${acId} \u2192 [x]`));
+      if (result.changes && result.changes.length > 0) {
+        console.log("\n\u{1F4DD} Changes:");
+        result.changes.forEach((change) => console.log(`   ${change}`));
       }
-      return match;
-    });
-    if (updatedCount > 0) {
-      await fs.writeFile(specPath, specContent, "utf-8");
-    }
-    return updatedCount;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      console.log(`\u2139\uFE0F  spec.md not found, skipping AC update`);
+    } else if (result.synced) {
+      console.log("\u2705 All ACs already in sync (no changes needed)");
     } else {
-      console.error("Error updating spec.md:", error);
+      console.log("\u2139\uFE0F  No AC updates needed");
     }
-    return 0;
+  } catch (error) {
+    console.error("\u274C Error updating AC status:", error);
   }
 }
 const isMainModule = import.meta.url === `file://${process.argv[1]}`;
@@ -90,7 +39,7 @@ if (isMainModule) {
   const incrementId = process.argv[2];
   if (!incrementId) {
     console.error("Usage: node update-ac-status.js <increment-id>");
-    console.error("Example: node update-ac-status.js 0031-external-tool-status-sync");
+    console.error("Example: node update-ac-status.js 0039-ultra-smart-next-command");
     process.exit(1);
   }
   updateACStatus(incrementId).then(() => {

package/plugins/specweave/lib/hooks/update-ac-status.ts

@@ -1,171 +1,82 @@
 #!/usr/bin/env node
 
 /**
- * AC Status Update Hook
+ * AC Status Update Hook (ACStatusManager Integration)
  *
- * Updates acceptance criteria checkboxes in spec.md based on completed tasks.
+ * Uses ACStatusManager for sophisticated AC status synchronization:
+ * - Tracks completion percentage per AC (only updates at 100%)
+ * - Detects conflicts (AC checked but tasks incomplete)
+ * - Warns about orphaned ACs (no implementing tasks)
+ * - Provides detailed sync result with diff
+ * - Atomic file writes to prevent corruption
  *
  * Flow:
- * 1. Read tasks.md → Extract completed tasks
- * 2. Extract AC-IDs from **AC**: field (e.g., AC-US1-01, AC-US1-02)
- * 3. Read spec.md → Find all AC checkboxes
- * 4. Check off AC if task implementing it is complete
- * 5. Write updated spec.md
+ * 1. Parse tasks.md → Map AC-IDs to completion status
+ * 2. Parse spec.md → Extract current AC definitions
+ * 3. Compare task completion vs spec checkboxes
+ * 4. Update spec.md only for 100% complete ACs
+ * 5. Log conflicts, warnings, and changes
  *
  * Called by: plugins/specweave/hooks/post-task-completion.sh
  *
  * Example:
- * - Task T-001: [x] Completed, **AC**: AC-US1-01, AC-US1-02
- * - spec.md: - [ ] **AC-US1-01**: ... → - [x] **AC-US1-01**: ... ✅
+ * - Tasks: T-001 [x], T-002 [x] (both have AC-US1-01) → AC-US1-01 100% complete
+ * - spec.md: - [ ] AC-US1-01 → - [x] AC-US1-01 ✅
+ * - Tasks: T-003 [x], T-004 [ ] (both have AC-US1-02) → AC-US1-02 50% complete
+ * - spec.md: - [ ] AC-US1-02 → NO CHANGE (partial completion)
  */
 
-import * as fs from 'fs/promises';
-import * as path from 'path';
-
-interface ACStatus {
-  acId: string;
-  isComplete: boolean;
-  completedByTasks: string[];
-}
+import { ACStatusManager } from '../../../../dist/src/core/increment/ac-status-manager.js';
 
 /**
- * Main entry point
+ * Main entry point - uses ACStatusManager for sophisticated sync
  */
 async function updateACStatus(incrementId: string): Promise<void> {
   try {
     const projectRoot = process.cwd();
-    const incrementPath = path.join(projectRoot, '.specweave/increments', incrementId);
-
-    // Verify increment exists
-    try {
-      await fs.access(incrementPath);
-    } catch {
-      console.error(`❌ Increment ${incrementId} not found at ${incrementPath}`);
-      return;
-    }
 
-    console.log(`🔄 Updating AC status for increment ${incrementId}...`);
-
-    // Step 1: Extract completed ACs from tasks.md
-    const completedACs = await extractCompletedACsFromTasks(incrementPath);
-
-    if (completedACs.size === 0) {
-      console.log(`ℹ️  No completed tasks with AC-IDs found in tasks.md`);
+    // Check if --skip-ac-sync flag is set (allows disabling hook temporarily)
+    if (process.env.SKIP_AC_SYNC === 'true') {
+      console.log('ℹ️  AC sync skipped (SKIP_AC_SYNC=true)');
       return;
     }
 
-    console.log(`✓ Found ${completedACs.size} completed AC-IDs from tasks.md`);
-
-    // Step 2: Update spec.md checkboxes
-    const updatedCount = await updateSpecACCheckboxes(incrementPath, completedACs);
-
-    if (updatedCount > 0) {
-      console.log(`✅ Updated ${updatedCount} AC checkbox(es) in spec.md`);
-    } else {
-      console.log(`ℹ️  No AC checkboxes needed updating in spec.md`);
-    }
-  } catch (error) {
-    console.error('❌ Error updating AC status:', error);
-    // Non-blocking: Don't throw, just log
-  }
-}
-
-/**
- * Extract AC-IDs from completed tasks in tasks.md
- */
-async function extractCompletedACsFromTasks(incrementPath: string): Promise<Set<string>> {
-  const tasksPath = path.join(incrementPath, 'tasks.md');
-  const completedACs = new Set<string>();
-
-  try {
-    const tasksContent = await fs.readFile(tasksPath, 'utf-8');
-
-    // Pattern: Match tasks with completed status and AC field
-    // Example:
-    // ### T-001: Task Title
-    // **Status**: [x] (100% - Completed)
-    // **AC**: AC-US1-01, AC-US1-02, AC-US1-03
-
-    // Split by task headings (## or ###)
-    const taskSections = tasksContent.split(/^(###+)\s+T-\d+:/gm);
-
-    for (let i = 1; i < taskSections.length; i += 2) {
-      const taskContent = taskSections[i + 1];
-
-      // Check if task is completed
-      const statusMatch = taskContent.match(/\*\*Status\*\*:\s*\[x\]/i);
-      if (!statusMatch) continue;
+    console.log(`🔄 Syncing AC status for increment ${incrementId}...`);
 
-      // Extract AC-IDs from **AC**: field
-      const acMatch = taskContent.match(/\*\*AC\*\*:\s*([^\n]+)/);
-      if (!acMatch) continue;
+    // Initialize ACStatusManager with project root
+    const manager = new ACStatusManager(projectRoot);
 
-      const acField = acMatch[1]; // "AC-US1-01, AC-US1-02, AC-US1-03"
-      const acIds = acField
-        .split(',')
-        .map(id => id.trim())
-        .filter(id => /^AC-[A-Z0-9]+-\d+$/.test(id)); // Validate format
+    // Perform sophisticated sync
+    const result = await manager.syncACStatus(incrementId);
 
-      acIds.forEach(acId => completedACs.add(acId));
+    // Display results
+    if (result.warnings && result.warnings.length > 0) {
+      console.log('\n⚠️  Warnings:');
+      result.warnings.forEach((warning: string) => console.log(`   ${warning}`));
     }
 
-    return completedACs;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      console.log(`ℹ️  tasks.md not found, skipping AC update`);
-    } else {
-      console.error('Error reading tasks.md:', error);
+    if (result.conflicts && result.conflicts.length > 0) {
+      console.log('\n⚠️  Conflicts detected:');
+      result.conflicts.forEach((conflict: string) => console.log(`   ${conflict}`));
     }
-    return completedACs;
-  }
-}
 
-/**
- * Update AC checkboxes in spec.md
- */
-async function updateSpecACCheckboxes(
-  incrementPath: string,
-  completedACs: Set<string>
-): Promise<number> {
-  const specPath = path.join(incrementPath, 'spec.md');
+    if (result.updated && result.updated.length > 0) {
+      console.log('\n✅ Updated AC checkboxes:');
+      result.updated.forEach((acId: string) => console.log(`   ${acId} → [x]`));
 
-  try {
-    let specContent = await fs.readFile(specPath, 'utf-8');
-    let updatedCount = 0;
-
-    // Pattern: - [ ] **AC-US1-01**: Description
-    // Captures: indent, checkbox state, AC-ID, rest of line
-    const acPattern = /^(\s*)-\s+\[([ x])\]\s+\*\*([A-Z]+-[A-Z0-9]+-\d+)\*\*:(.*)$/gm;
-
-    specContent = specContent.replace(acPattern, (match, indent, currentState, acId, description) => {
-      const shouldBeChecked = completedACs.has(acId);
-      const isCurrentlyChecked = currentState === 'x';
-
-      if (shouldBeChecked && !isCurrentlyChecked) {
-        // Check off this AC
-        updatedCount++;
-        return `${indent}- [x] **${acId}**:${description}`;
-      } else if (!shouldBeChecked && isCurrentlyChecked) {
-        // Uncheck this AC (task was un-completed?)
-        updatedCount++;
-        return `${indent}- [ ] **${acId}**:${description}`;
+      if (result.changes && result.changes.length > 0) {
+        console.log('\n📝 Changes:');
+        result.changes.forEach((change: string) => console.log(`   ${change}`));
       }
-
-      return match; // No change needed
-    });
-
-    if (updatedCount > 0) {
-      await fs.writeFile(specPath, specContent, 'utf-8');
+    } else if (result.synced) {
+      console.log('✅ All ACs already in sync (no changes needed)');
+    } else {
+      console.log('ℹ️  No AC updates needed');
     }
 
-    return updatedCount;
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      console.log(`ℹ️  spec.md not found, skipping AC update`);
-    } else {
-      console.error('Error updating spec.md:', error);
-    }
-    return 0;
+    console.error('❌ Error updating AC status:', error);
+    // Non-blocking: Don't throw, just log
   }
 }
 
@@ -177,7 +88,7 @@ if (isMainModule) {
 
   if (!incrementId) {
     console.error('Usage: node update-ac-status.js <increment-id>');
-    console.error('Example: node update-ac-status.js 0031-external-tool-status-sync');
+    console.error('Example: node update-ac-status.js 0039-ultra-smart-next-command');
     process.exit(1);
   }
 

package/plugins/specweave/lib/hooks/update-tasks-md.js

@@ -78,8 +78,103 @@ function parseTaskStatus(lines) {
 }
 function detectCompletedTasks(lines) {
   const completedTasks = [];
+  const warnings = [];
+  const taskPattern = /^###\s+(T-\d+[-A-Z]*):?\s+(.+)/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const taskMatch = line.match(taskPattern);
+    if (!taskMatch) continue;
+    const taskId = taskMatch[1];
+    const taskTitle = taskMatch[2];
+    const hasCompleteMarker = taskTitle.includes("\u2705 COMPLETE");
+    const taskEndIndex = findNextTaskStart(lines, i + 1);
+    const implementationSection = findImplementationSection(lines, i, taskEndIndex);
+    let allCheckboxesComplete = false;
+    if (implementationSection) {
+      allCheckboxesComplete = checkAllCheckboxesComplete(implementationSection);
+    }
+    if (hasCompleteMarker && implementationSection) {
+      if (allCheckboxesComplete) {
+        if (!completedTasks.includes(taskId)) {
+          completedTasks.push(taskId);
+        }
+      } else {
+        warnings.push(`${taskId}: Header has \u2705 COMPLETE but not all checkboxes checked`);
+      }
+      continue;
+    }
+    if (hasCompleteMarker && !implementationSection) {
+      if (!completedTasks.includes(taskId)) {
+        completedTasks.push(taskId);
+      }
+      continue;
+    }
+    if (!hasCompleteMarker && implementationSection && allCheckboxesComplete) {
+      warnings.push(`${taskId}: All checkboxes checked but header missing \u2705 COMPLETE`);
+      if (!completedTasks.includes(taskId)) {
+        completedTasks.push(taskId);
+      }
+      continue;
+    }
+    for (let j = i + 1; j < Math.min(i + 10, taskEndIndex); j++) {
+      const statusLine = lines[j];
+      if (statusLine.includes("**Status**:") && statusLine.includes("[x] Completed")) {
+        if (!completedTasks.includes(taskId)) {
+          completedTasks.push(taskId);
+        }
+        break;
+      }
+    }
+  }
+  if (warnings.length > 0) {
+    console.warn("\n\u26A0\uFE0F  Task Consistency Warnings:");
+    warnings.forEach((w) => console.warn(`   ${w}`));
+    console.warn("");
+  }
   return completedTasks;
 }
+function findNextTaskStart(lines, startIndex) {
+  const taskPattern = /^###\s+T-\d+/;
+  for (let i = startIndex; i < lines.length; i++) {
+    if (taskPattern.test(lines[i])) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function findImplementationSection(lines, taskStartIndex, taskEndIndex) {
+  let inImplementation = false;
+  const implementationLines = [];
+  for (let i = taskStartIndex; i < taskEndIndex; i++) {
+    const line = lines[i];
+    if (line.includes("**Implementation**:")) {
+      inImplementation = true;
+      continue;
+    }
+    if (inImplementation) {
+      if (line.trim().startsWith("**") && !line.startsWith("- [")) {
+        break;
+      }
+      if (line.trim().startsWith("---")) {
+        break;
+      }
+      if (line.trim().startsWith("###")) {
+        break;
+      }
+      implementationLines.push(line);
+    }
+  }
+  return implementationLines.length > 0 ? implementationLines : null;
+}
+function checkAllCheckboxesComplete(implementationLines) {
+  const checkboxes = implementationLines.filter((line) => line.includes("- ["));
+  if (checkboxes.length === 0) {
+    return false;
+  }
+  const allComplete = checkboxes.every((line) => line.includes("- [x]"));
+  const noneIncomplete = checkboxes.every((line) => !line.includes("- [ ]"));
+  return allComplete && noneIncomplete;
+}
 function markTaskComplete(content, taskId) {
   let updated = content;
   const statusPattern = new RegExp(
@@ -101,17 +196,34 @@ function countTotalTasks(lines) {
 }
 function countCompletedTasks(lines) {
   let count = 0;
-  const taskPattern = /^###\s+(T-?\d+[-A-Z]*):?\s+/;
+  const taskPattern = /^###\s+(T-?\d+[-A-Z]*):?\s+(.+)/;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    if (taskPattern.test(line)) {
-      for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+    const taskMatch = line.match(taskPattern);
+    if (taskMatch) {
+      const taskTitle = taskMatch[2];
+      if (taskTitle.includes("\u2705 COMPLETE")) {
+        count++;
+        continue;
+      }
+      let found = false;
+      for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
         const nextLine = lines[j];
         if (nextLine.includes("**Status**:") && nextLine.includes("[x] Completed")) {
           count++;
+          found = true;
           break;
         }
       }
+      if (found) continue;
+      const taskEndIndex = findNextTaskStart(lines, i + 1);
+      const implementationSection = findImplementationSection(lines, i, taskEndIndex);
+      if (implementationSection) {
+        const allCheckboxesComplete = checkAllCheckboxesComplete(implementationSection);
+        if (allCheckboxesComplete) {
+          count++;
+        }
+      }
     }
   }
   return count;