@agile-vibe-coding/avc 0.3.4 → 0.4.0

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

@@ -289,8 +289,9 @@ export function createWorkItemsRouter(dataStore, refineService, ceremonyService)
   const VALID_TRANSITIONS = {
     'planned': ['ready', 'implementing'],
     'ready': ['implementing'],
-    'implementing': ['completed', 'failed'],
-    'failed': ['implementing'],
+    'implementing': ['implemented', 'completed', 'failed'],
+    'implemented': ['completed', 'failed'],  // review → approve (merge) or reject
+    'failed': ['implementing', 'ready'],
     'completed': [],
   };
 
@@ -328,6 +329,20 @@ export function createWorkItemsRouter(dataStore, refineService, ceremonyService)
         fsSync.writeFileSync(workJsonPath, JSON.stringify(workJson, null, 2), 'utf8');
       }
 
+      // When a task moves from 'implemented' to 'completed' (review approved),
+      // merge its worktree branch into main and clean up.
+      if (status === 'completed' && currentStatus === 'implemented' && (item._type === 'task' || item.type === 'task')) {
+        try {
+          const { WorktreeRunner } = await import('../../../cli/worktree-runner.js');
+          const runner = new WorktreeRunner(req.params.id, path.resolve(item._dirPath, '..', '..', '..', '..'));
+          runner.mergeAndCleanup();
+          console.log(`[review-merge] Merged worktree for ${req.params.id}`);
+        } catch (mergeErr) {
+          console.error(`[review-merge] Failed to merge ${req.params.id}: ${mergeErr.message}`);
+          // Non-fatal — the status is already set to completed
+        }
+      }
+
       // Reload hierarchy so in-memory state reflects the change
       await dataStore.reload();
 
@@ -376,6 +391,52 @@ export function createWorkItemsRouter(dataStore, refineService, ceremonyService)
         }
       }
 
+      // Upward cascade: propagate status to parent items
+      try {
+        const { items: freshItems } = dataStore.getHierarchy();
+        const updatedItem = freshItems.get(req.params.id);
+        let parentId = updatedItem?._parentId || null;
+        let needsReload = false;
+
+        while (parentId) {
+          const parent = freshItems.get(parentId);
+          if (!parent) break;
+
+          const children = [...freshItems.values()].filter(c => c._parentId === parentId);
+          if (children.length === 0) break;
+
+          let newParentStatus = null;
+          const allCompleted = children.every(c => c.status === 'completed');
+          const anyImplementing = children.some(c =>
+            c.status === 'implementing' || c.status === 'completed'
+          );
+
+          if (allCompleted && parent.status !== 'completed') {
+            newParentStatus = 'completed';
+          } else if (anyImplementing && parent.status !== 'implementing' && parent.status !== 'completed') {
+            newParentStatus = 'implementing';
+          }
+
+          if (newParentStatus) {
+            const parentWjPath = path.join(parent._dirPath, 'work.json');
+            if (fsSync.existsSync(parentWjPath)) {
+              const wj = JSON.parse(fsSync.readFileSync(parentWjPath, 'utf8'));
+              wj.status = newParentStatus;
+              wj.updated = new Date().toISOString();
+              fsSync.writeFileSync(parentWjPath, JSON.stringify(wj, null, 2), 'utf8');
+              needsReload = true;
+              console.log(`[status-cascade-up] ${parentId}: ${parent.status} → ${newParentStatus}`);
+            }
+          }
+
+          parentId = parent._parentId || null;
+        }
+
+        if (needsReload) await dataStore.reload();
+      } catch (upErr) {
+        console.error('Upward status cascade error (non-critical):', upErr.message);
+      }
+
       res.json({ status: 'ok', item: cleanWorkItem(item) });
     } catch (error) {
       console.error(`Error updating status for ${req.params.id}:`, error);
@@ -416,6 +477,40 @@ export function createWorkItemsRouter(dataStore, refineService, ceremonyService)
     }
   });
 
+  /**
+   * GET /api/work-items/:id/worktree-file?path=relative/path
+   * Read a file from the task's worktree (for reviewing generated code).
+   */
+  router.get('/:id/worktree-file', async (req, res) => {
+    try {
+      const filePath = req.query.path;
+      if (!filePath) return res.status(400).json({ error: 'path query parameter required' });
+
+      const projectRoot = dataStore.projectRoot;
+      const worktreePath = path.join(projectRoot, '.avc', 'worktrees', req.params.id);
+
+      if (!fsSync.existsSync(worktreePath)) {
+        return res.status(404).json({ error: 'Worktree not found — task may not have been run yet' });
+      }
+
+      // Safety: resolve and ensure path stays within worktree
+      const resolved = path.resolve(worktreePath, filePath);
+      if (!resolved.startsWith(path.resolve(worktreePath) + path.sep) && resolved !== path.resolve(worktreePath)) {
+        return res.status(403).json({ error: 'Path escapes worktree boundary' });
+      }
+
+      if (!fsSync.existsSync(resolved)) {
+        return res.status(404).json({ error: `File not found: ${filePath}` });
+      }
+
+      const content = fsSync.readFileSync(resolved, 'utf8');
+      res.json({ path: filePath, content, size: content.length });
+    } catch (error) {
+      console.error(`Error reading worktree file for ${req.params.id}:`, error);
+      res.status(500).json({ error: 'Failed to read file' });
+    }
+  });
+
   return router;
 }
 
@@ -443,6 +538,9 @@ function cleanWorkItem(item, includeFullDetails = false) {
     userType: item.userType,      // stories
     domain: item.domain,          // epics
     functions: item.functions,     // code traceability registry
+    files: item.files,             // files created/edited/deleted by Run ceremony
+    testResults: item.testResults, // test output from Run ceremony
+    acceptanceStatus: item.acceptanceStatus, // per-AC pass/fail from Run ceremony
   };
 
   // Add parent reference (ID only, not full object)
@@ -458,6 +556,7 @@ function cleanWorkItem(item, includeFullDetails = false) {
       name: child.name,
       type: child._type,
       status: child.status,
+      acceptance: child.acceptance,
     }));
   }
 

package/kanban/server/workers/run-task-worker.js

@@ -38,16 +38,22 @@ process.on('message', async (msg) => {
  */
 function updateStatus(taskId, status) {
   const projectRoot = process.cwd();
-  // Find the work.json by walking the hierarchy
-  // Task ID: context-0001-0001-0001 → path: .avc/project/context-0001/context-0001-0001/context-0001-0001-0001/work.json
-  const idParts = taskId.replace('context-', '').split('-');
-  let dir = join(projectRoot, '.avc', 'project');
-  let current = 'context';
-  for (const part of idParts) {
-    current += `-${part}`;
-    dir = join(dir, current);
+  const projectDir = join(projectRoot, '.avc', 'project');
+
+  // Try flat path first (tasks/subtasks written by seed-processor are flat)
+  let workJsonPath = join(projectDir, taskId, 'work.json');
+
+  // Fall back to nested path (epics/stories are nested)
+  if (!existsSync(workJsonPath)) {
+    const idParts = taskId.replace('context-', '').split('-');
+    let dir = projectDir;
+    let current = 'context';
+    for (const part of idParts) {
+      current += `-${part}`;
+      dir = join(dir, current);
+    }
+    workJsonPath = join(dir, 'work.json');
   }
-  const workJsonPath = join(dir, 'work.json');
 
   if (existsSync(workJsonPath)) {
     try {
@@ -59,6 +65,39 @@ function updateStatus(taskId, status) {
   }
 }
 
+/**
+ * Auto-complete all subtasks of a task.
+ * Subtasks are documentation artifacts — the task's agent loop implements everything.
+ */
+function autoCompleteSubtasks(taskId) {
+  const projectDir = join(process.cwd(), '.avc', 'project');
+
+  // Read the task's work.json to get children
+  const taskWorkJsonPath = join(projectDir, taskId, 'work.json');
+  if (!existsSync(taskWorkJsonPath)) return;
+
+  try {
+    const taskWork = JSON.parse(readFileSync(taskWorkJsonPath, 'utf8'));
+    const children = taskWork.children || [];
+
+    for (const childId of children) {
+      // Try flat path first
+      let childPath = join(projectDir, childId, 'work.json');
+      if (!existsSync(childPath)) continue;
+
+      try {
+        const childWork = JSON.parse(readFileSync(childPath, 'utf8'));
+        if (childWork.type === 'subtask' && childWork.status !== 'completed') {
+          childWork.status = 'completed';
+          childWork.updated = new Date().toISOString();
+          childWork.metadata = { ...childWork.metadata, completedBy: taskId };
+          writeFileSync(childPath, JSON.stringify(childWork, null, 2), 'utf8');
+        }
+      } catch {}
+    }
+  } catch {}
+}
+
 async function run(taskId) {
   const logger = new CommandLogger('run-task', process.cwd());
   logger.start();
@@ -85,11 +124,21 @@ async function run(taskId) {
       updateStatus(taskId, 'planned'); // Reset on cancel
       try { process.send({ type: 'cancelled' }); } catch {}
     } else if (result.success) {
-      updateStatus(taskId, 'completed');
+      // Tests passed — move to review (not completed). Human must approve before merge.
+      updateStatus(taskId, 'implemented');
+      // Auto-complete subtasks — they are documentation artifacts, not separate implementation units.
+      // The task's agent loop implements everything including subtask ACs.
+      autoCompleteSubtasks(taskId);
       try {
         process.send({
           type: 'complete',
-          result: { success: true, taskId },
+          result: {
+            success: true,
+            taskId,
+            review: true,
+            worktreePath: result.worktreePath,
+            branchName: result.branchName,
+          },
         });
       } catch {}
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agile-vibe-coding/avc",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Agile Vibe Coding (AVC) - Framework for managing AI agent-based software development projects",
   "type": "module",
   "main": "cli/index.js",