@agile-vibe-coding/avc 0.1.1 → 0.2.3

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

@@ -0,0 +1,347 @@
+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) {
+  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 {
+      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 { 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' });
+    }
+  });
+
+  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
+  };
+
+  // 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;
+}