@agile-vibe-coding/avc 0.1.1 → 0.3.1

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

@@ -0,0 +1,487 @@
+import express from 'express';
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import { renderMarkdown, extractDescriptionFromDoc } from '../utils/markdown.js';
+import { groupItemsByColumn, getColumnStats } from '../utils/status-grouping.js';
+
+/**
+ * Create work items router
+ * @param {object} dataStore - Data store with work items
+ * @returns {express.Router}
+ */
+export function createWorkItemsRouter(dataStore, refineService, ceremonyService) {
+  const router = express.Router();
+
+  /**
+   * GET /api/work-items
+   * Get all work items as hierarchical JSON
+   */
+  router.get('/', (req, res) => {
+    try {
+      const { items, roots } = dataStore.getHierarchy();
+
+      // Convert Map to array
+      const allItems = Array.from(items.values());
+
+      // Apply filters if provided
+      let filtered = allItems;
+
+      // Filter by type
+      if (req.query.type) {
+        const types = req.query.type.split(',');
+        filtered = filtered.filter((item) => types.includes(item._type));
+      }
+
+      // Filter by status
+      if (req.query.status) {
+        const statuses = req.query.status.split(',');
+        filtered = filtered.filter((item) => statuses.includes(item.status));
+      }
+
+      // Search query
+      if (req.query.search) {
+        const search = req.query.search.toLowerCase();
+        filtered = filtered.filter(
+          (item) =>
+            item.name.toLowerCase().includes(search) ||
+            item.id.toLowerCase().includes(search) ||
+            (item.description && item.description.toLowerCase().includes(search))
+        );
+      }
+
+      // Clean items (remove circular references for JSON serialization)
+      const cleanItems = filtered.map((item) => cleanWorkItem(item));
+
+      res.json({
+        items: cleanItems,
+        total: cleanItems.length,
+        roots: roots.map((r) => r.id),
+      });
+    } catch (error) {
+      console.error('Error getting work items:', error);
+      res.status(500).json({ error: 'Failed to get work items' });
+    }
+  });
+
+  /**
+   * GET /api/work-items/grouped
+   * Get work items grouped by column
+   */
+  router.get('/grouped', (req, res) => {
+    try {
+      const { items } = dataStore.getHierarchy();
+      const allItems = Array.from(items.values());
+
+      // Group by column
+      const grouped = groupItemsByColumn(allItems);
+
+      // Add statistics for each column
+      const result = {};
+      for (const [column, columnItems] of Object.entries(grouped)) {
+        result[column] = {
+          items: columnItems.map((item) => cleanWorkItem(item)),
+          stats: getColumnStats(columnItems),
+        };
+      }
+
+      res.json(result);
+    } catch (error) {
+      console.error('Error getting grouped work items:', error);
+      res.status(500).json({ error: 'Failed to get grouped work items' });
+    }
+  });
+
+  /**
+   * GET /api/work-items/:id
+   * Get single work item with full details
+   */
+  router.get('/:id', async (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' });
+      }
+
+      // Get full details (including doc.md and context.md)
+      const fullItem = await dataStore.getFullDetails(item);
+
+      res.json(cleanWorkItem(fullItem, true));
+    } catch (error) {
+      console.error(`Error getting work item ${req.params.id}:`, error);
+      res.status(500).json({ error: 'Failed to get work item' });
+    }
+  });
+
+  /**
+   * GET /api/work-items/:id/doc
+   * Get rendered documentation (doc.md) as HTML
+   */
+  router.get('/:id/doc', async (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' });
+      }
+
+      const fullItem = await dataStore.getFullDetails(item);
+
+      if (!fullItem.documentation) {
+        return res.status(404).json({ error: 'Documentation not found' });
+      }
+
+      const html = renderMarkdown(fullItem.documentation);
+      res.send(html);
+    } catch (error) {
+      console.error(`Error getting documentation for ${req.params.id}:`, error);
+      res.status(500).json({ error: 'Failed to get documentation' });
+    }
+  });
+
+  /**
+   * GET /api/work-items/:id/doc/raw
+   * Get raw markdown source of doc.md
+   */
+  router.get('/:id/doc/raw', async (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' });
+
+      const fullItem = await dataStore.getFullDetails(item);
+      if (!fullItem.documentation) return res.status(404).json({ error: 'Documentation not found' });
+
+      res.type('text/plain').send(fullItem.documentation);
+    } catch (error) {
+      console.error(`Error getting raw doc for ${req.params.id}:`, error);
+      res.status(500).json({ error: 'Failed to get documentation' });
+    }
+  });
+
+  /**
+   * POST /api/work-items/:id/refine
+   * Start an async refinement job for an epic or story.
+   * Body: { refinementRequest?, selectedIssues?, modelId, provider, validatorModelId, validatorProvider }
+   * Returns: { jobId }
+   */
+  router.post('/:id/refine', async (req, res) => {
+    try {
+      if (!refineService) {
+        return res.status(503).json({ error: 'Refine service not available' });
+      }
+      const { items } = dataStore.getHierarchy();
+      const item = items.get(req.params.id);
+      if (!item) return res.status(404).json({ error: 'Work item not found' });
+
+      const { refinementRequest, selectedIssues, modelId, provider, validatorModelId, validatorProvider } =
+        req.body;
+
+      if (!modelId || !provider || !validatorModelId || !validatorProvider) {
+        return res.status(400).json({
+          error: 'modelId, provider, validatorModelId and validatorProvider are required',
+        });
+      }
+
+      const fullItem = await dataStore.getFullDetails(item);
+      const cleanItem = cleanWorkItem(fullItem, true);
+
+      const jobId = await refineService.startRefine(req.params.id, cleanItem, {
+        refinementRequest: refinementRequest || '',
+        selectedIssues: selectedIssues || [],
+        modelId,
+        provider,
+        validatorModelId,
+        validatorProvider,
+        itemDirPath: item._dirPath,
+      });
+
+      res.json({ jobId });
+    } catch (err) {
+      console.error(`Error starting refine for ${req.params.id}:`, err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * PUT /api/work-items/:id
+   * Apply accepted refinement changes to work.json on disk.
+   * Body: { proposedItem, storyChanges? }
+   */
+  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' });
+      }
+      const { proposedItem, storyChanges } = req.body;
+      if (!proposedItem) return res.status(400).json({ error: 'proposedItem is required' });
+
+      // Build a dirPath map from the in-memory data store so applyChanges doesn't
+      // need to walk the filesystem (which can silently fail).
+      const { items } = dataStore.getHierarchy();
+      const item = items.get(req.params.id);
+      if (!item) return res.status(404).json({ error: 'Work item not found' });
+
+      const dirPathMap = new Map([[item.id, item._dirPath]]);
+      for (const change of (storyChanges || [])) {
+        if (change.storyId) {
+          const storyItem = items.get(change.storyId);
+          if (storyItem) dirPathMap.set(change.storyId, storyItem._dirPath);
+        }
+      }
+
+      await refineService.applyChanges(req.params.id, proposedItem, storyChanges || [], dirPathMap);
+      res.json({ status: 'ok' });
+    } catch (err) {
+      console.error(`Error applying changes for ${req.params.id}:`, err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * PUT /api/work-items/:id/doc
+   * Save updated markdown content to doc.md
+   */
+  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' });
+
+      const markdown = req.body.content;
+      if (typeof markdown !== 'string') {
+        return res.status(400).json({ error: 'content must be a string' });
+      }
+
+      const docPath = path.join(item._dirPath, 'doc.md');
+      await fs.writeFile(docPath, markdown, 'utf8');
+
+      // Sync work.json description cache so kanban cards stay in sync
+      const newDescription = extractDescriptionFromDoc(markdown);
+      if (newDescription) {
+        const workJsonPath = path.join(item._dirPath, 'work.json');
+        if (fsSync.existsSync(workJsonPath)) {
+          const workJson = JSON.parse(fsSync.readFileSync(workJsonPath, 'utf8'));
+          workJson.description = newDescription;
+          fsSync.writeFileSync(workJsonPath, JSON.stringify(workJson, null, 2), 'utf8');
+        }
+      }
+
+      res.json({ status: 'ok' });
+    } catch (error) {
+      console.error(`Error saving doc for ${req.params.id}:`, error);
+      res.status(500).json({ error: 'Failed to save documentation' });
+    }
+  });
+
+  // ---- 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;
+}
+
+/**
+ * Clean work item for JSON serialization
+ * Removes circular references and internal fields
+ * @param {object} item - Work item
+ * @param {boolean} includeFullDetails - Include documentation and context
+ * @returns {object} Cleaned work item
+ */
+function cleanWorkItem(item, includeFullDetails = false) {
+  const cleaned = {
+    id: item.id,
+    name: item.name,
+    type: item._type,
+    status: item.status,
+    description: item.description,
+    dependencies: item.dependencies || [],
+    metadata: item.metadata,
+    created: item.created,
+    updated: item.updated,
+    // Type-specific fields used for diff display in RefineWorkItemPopup
+    features: item.features,      // epics
+    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)
+  if (item._parentId) {
+    cleaned.parentId = item._parentId;
+    cleaned.parentName = item._parent?.name;
+  }
+
+  // Add children references (IDs only)
+  if (item._children && item._children.length > 0) {
+    cleaned.children = item._children.map((child) => ({
+      id: child.id,
+      name: child.name,
+      type: child._type,
+      status: child.status,
+    }));
+  }
+
+  // Add epic reference for nested items
+  if (item._type !== 'epic' && item._parent) {
+    let epic = item._parent;
+    while (epic._parent) {
+      epic = epic._parent;
+    }
+    if (epic._type === 'epic') {
+      cleaned.epicId = epic.id;
+      cleaned.epicName = epic.name;
+    }
+  }
+
+  // Include full details if requested
+  if (includeFullDetails) {
+    if (item.documentation) {
+      cleaned.documentation = item.documentation;
+    }
+    if (item.context) {
+      cleaned.context = item.context;
+    }
+  }
+
+  return cleaned;
+}