@agile-vibe-coding/avc 0.2.3 → 0.3.2

package/kanban/server/routes/work-items.js

@@ -10,7 +10,7 @@ import { groupItemsByColumn, getColumnStats } from '../utils/status-grouping.js'
  * @param {object} dataStore - Data store with work items
  * @returns {express.Router}
  */
-export function createWorkItemsRouter(dataStore, refineService) {
+export function createWorkItemsRouter(dataStore, refineService, ceremonyService) {
   const router = express.Router();
 
   /**
@@ -213,6 +213,10 @@ export function createWorkItemsRouter(dataStore, refineService) {
    */
   router.put('/:id', async (req, res) => {
     try {
+      const cs = ceremonyService?.getStatus();
+      if (cs?.status === 'running' && cs?.runningType === 'sprint-planning') {
+        return res.status(423).json({ error: 'Work items are read-only while sprint planning is active' });
+      }
       if (!refineService) {
         return res.status(503).json({ error: 'Refine service not available' });
       }
@@ -247,6 +251,10 @@ export function createWorkItemsRouter(dataStore, refineService) {
    */
   router.put('/:id/doc', async (req, res) => {
     try {
+      const cs = ceremonyService?.getStatus();
+      if (cs?.status === 'running' && cs?.runningType === 'sprint-planning') {
+        return res.status(423).json({ error: 'Work items are read-only while sprint planning is active' });
+      }
       const { items } = dataStore.getHierarchy();
       const item = items.get(req.params.id);
       if (!item) return res.status(404).json({ error: 'Work item not found' });
@@ -277,6 +285,137 @@ export function createWorkItemsRouter(dataStore, refineService) {
     }
   });
 
+  // ---- Status update ----
+  const VALID_TRANSITIONS = {
+    'planned': ['ready', 'implementing'],
+    'ready': ['implementing'],
+    'implementing': ['completed', 'failed'],
+    'failed': ['implementing'],
+    'completed': [],
+  };
+
+  router.put('/:id/status', async (req, res) => {
+    try {
+      const cs = ceremonyService?.getStatus();
+      if (cs?.status === 'running' && cs?.runningType === 'sprint-planning') {
+        return res.status(423).json({ error: 'Work items are read-only while sprint planning is active' });
+      }
+
+      const { items } = dataStore.getHierarchy();
+      const item = items.get(req.params.id);
+      if (!item) return res.status(404).json({ error: 'Work item not found' });
+
+      const { status } = req.body;
+      if (!status || typeof status !== 'string') {
+        return res.status(400).json({ error: 'status is required' });
+      }
+
+      const currentStatus = item.status || 'planned';
+      const allowed = VALID_TRANSITIONS[currentStatus] || [];
+      if (!allowed.includes(status)) {
+        return res.status(422).json({
+          error: `Invalid status transition: ${currentStatus} → ${status}`,
+          allowed,
+        });
+      }
+
+      // Write to work.json
+      const workJsonPath = path.join(item._dirPath, 'work.json');
+      if (fsSync.existsSync(workJsonPath)) {
+        const workJson = JSON.parse(fsSync.readFileSync(workJsonPath, 'utf8'));
+        workJson.status = status;
+        workJson.updated = new Date().toISOString();
+        fsSync.writeFileSync(workJsonPath, JSON.stringify(workJson, null, 2), 'utf8');
+      }
+
+      // Reload hierarchy so in-memory state reflects the change
+      await dataStore.reload();
+
+      // When an item is completed, cascade: promote dependents to 'ready' if all their deps are now met
+      if (status === 'completed') {
+        try {
+          const { checkDependenciesReady } = await import('../../../cli/dependency-checker.js');
+          const { items: freshItems } = dataStore.getHierarchy();
+
+          // Build lookup from fresh hierarchy
+          const lookup = {};
+          for (const [id, wi] of freshItems) {
+            lookup[id] = {
+              id: wi.id, name: wi.name, type: wi._type || wi.type,
+              status: wi.status || 'planned', dependencies: wi.dependencies || [],
+            };
+          }
+
+          // Find items that depend on the completed item and are still 'planned'
+          let promoted = 0;
+          for (const [id, wi] of freshItems) {
+            if (wi.status !== 'planned') continue;
+            const deps = wi.dependencies || [];
+            if (!deps.includes(req.params.id)) continue;
+
+            // Check if ALL dependencies are now met
+            const result = checkDependenciesReady(id, lookup);
+            if (result.ready) {
+              const depWorkJsonPath = path.join(wi._dirPath, 'work.json');
+              if (fsSync.existsSync(depWorkJsonPath)) {
+                const wj = JSON.parse(fsSync.readFileSync(depWorkJsonPath, 'utf8'));
+                wj.status = 'ready';
+                wj.updated = new Date().toISOString();
+                fsSync.writeFileSync(depWorkJsonPath, JSON.stringify(wj, null, 2), 'utf8');
+                promoted++;
+              }
+            }
+          }
+
+          if (promoted > 0) {
+            await dataStore.reload();
+            console.log(`[status-cascade] ${promoted} item(s) promoted to 'ready' after ${req.params.id} completed`);
+          }
+        } catch (cascadeErr) {
+          console.error('Status cascade error (non-critical):', cascadeErr.message);
+        }
+      }
+
+      res.json({ status: 'ok', item: cleanWorkItem(item) });
+    } catch (error) {
+      console.error(`Error updating status for ${req.params.id}:`, error);
+      res.status(500).json({ error: 'Failed to update status' });
+    }
+  });
+
+  // ---- Dependency status check ----
+  router.get('/:id/dependency-status', (req, res) => {
+    try {
+      const { items } = dataStore.getHierarchy();
+      const item = items.get(req.params.id);
+      if (!item) return res.status(404).json({ error: 'Work item not found' });
+
+      // Build a plain lookup object from the items Map
+      const lookup = {};
+      for (const [id, wi] of items) {
+        lookup[id] = {
+          id: wi.id,
+          name: wi.name,
+          type: wi._type || wi.type,
+          status: wi.status || 'planned',
+          dependencies: wi.dependencies || [],
+        };
+      }
+
+      // Dynamic import to keep the route file sync-compatible
+      import('../../../cli/dependency-checker.js').then(({ checkDependenciesReady }) => {
+        const result = checkDependenciesReady(req.params.id, lookup);
+        res.json(result);
+      }).catch(err => {
+        console.error(`Error checking dependencies for ${req.params.id}:`, err);
+        res.status(500).json({ error: 'Failed to check dependencies' });
+      });
+    } catch (error) {
+      console.error(`Error checking dependencies for ${req.params.id}:`, error);
+      res.status(500).json({ error: 'Failed to check dependencies' });
+    }
+  });
+
   return router;
 }
 
@@ -303,6 +442,7 @@ function cleanWorkItem(item, includeFullDetails = false) {
     acceptance: item.acceptance,  // stories
     userType: item.userType,      // stories
     domain: item.domain,          // epics
+    functions: item.functions,     // code traceability registry
   };
 
   // Add parent reference (ID only, not full object)