@bamptee/aia-code 2.0.12 → 2.0.14

package/src/ui/api/features.js

@@ -1,8 +1,25 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import Busboy from 'busboy';
-import { AIA_DIR } from '../../constants.js';
-import { loadStatus, updateStepStatus, resetStep, updateFlowType } from '../../services/status.js';
+import { AIA_DIR, DELETION_FILTER, QUICK_STEPS } from '../../constants.js';
+import { loadStatus, updateStepStatus, resetStep, updateFlowType, updateType, updateApps, softDeleteFeature, restoreFeature, isFeatureDeleted } from '../../services/status.js';
+import { FEATURE_TYPES } from '../../constants.js';
+
+/**
+ * Check if a feature is completed (all relevant steps are done)
+ * @param {Object} status - Feature status object with steps and flow
+ * @returns {boolean}
+ */
+function isFeatureCompleted(status) {
+  const steps = status.steps || {};
+  const isQuickFlow = status.flow === 'quick';
+  const relevantSteps = isQuickFlow
+    ? Object.entries(steps).filter(([k]) => QUICK_STEPS.includes(k))
+    : Object.entries(steps);
+
+  if (relevantSteps.length === 0) return false;
+  return relevantSteps.every(([_, s]) => s === 'done');
+}
 import { createFeature, validateFeatureName } from '../../services/feature.js';
 import { runStep } from '../../services/runner.js';
 import { runQuick } from '../../services/quick.js';
@@ -12,6 +29,7 @@ import { callModel } from '../../services/model-call.js';
 import { loadConfig } from '../../models.js';
 import { json, error } from '../router.js';
 import { isWtInstalled, hasWorktree, getFeatureBranch } from '../../services/worktrunk.js';
+import { getSession, isRunning, addSseClient, removeSseClient } from '../../services/agent-sessions.js';
 
 const MAX_DESCRIPTION_LENGTH = 50000; // 50KB
 
@@ -21,24 +39,15 @@ function sseHeaders(res) {
     'Cache-Control': 'no-cache',
     'Connection': 'keep-alive',
     'Access-Control-Allow-Origin': '*',
+    'X-Accel-Buffering': 'no', // Disable nginx buffering if behind proxy
   });
+  res.flushHeaders(); // Force headers to be sent immediately
 }
 
 function sseSend(res, event, data) {
   res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
-}
-
-// F6: Extracted validation helpers to avoid code duplication
-function validateHistory(rawHistory) {
-  return Array.isArray(rawHistory)
-    ? rawHistory
-        .filter(msg => msg && typeof msg === 'object' && typeof msg.content === 'string')
-        .map(msg => ({
-          role: msg.role === 'agent' ? 'agent' : 'user',
-          content: String(msg.content).slice(0, 50000),
-        }))
-        .slice(-20)
-    : [];
+  // Force flush for SSE streaming
+  if (res.flush) res.flush();
 }
 
 function validateAttachments(rawAttachments) {
@@ -51,7 +60,10 @@ function validateAttachments(rawAttachments) {
 
 export function registerFeatureRoutes(router) {
   // List all features
-  router.get('/api/features', async (req, res, { root }) => {
+  // Query params:
+  //   ?filter=active|deleted|all (default: active)
+  //   ?minimal=true - Return minimal data for faster initial load (name, type, flow, createdAt, deletedAt only)
+  router.get('/api/features', async (req, res, { root, query }) => {
     const featuresDir = path.join(root, AIA_DIR, 'features');
     if (!(await fs.pathExists(featuresDir))) {
       return json(res, []);
@@ -59,14 +71,49 @@ export function registerFeatureRoutes(router) {
     const entries = await fs.readdir(featuresDir, { withFileTypes: true });
     const features = [];
     const wtInstalled = isWtInstalled();
+
+    // Parse filter from query params (default: active, with validation)
+    const validFilters = [DELETION_FILTER.ACTIVE, DELETION_FILTER.DELETED, DELETION_FILTER.ALL];
+    const filter = validFilters.includes(query?.filter) ? query.filter : DELETION_FILTER.ACTIVE;
+
+    // Parse minimal flag for lazy loading support
+    const minimal = query?.minimal === 'true';
+
     for (const entry of entries) {
       if (entry.isDirectory()) {
         try {
           const status = await loadStatus(entry.name, root);
-          const hasWt = wtInstalled && hasWorktree(getFeatureBranch(entry.name), root);
-          features.push({ name: entry.name, ...status, hasWorktree: hasWt });
+          const deleted = isFeatureDeleted(status);
+
+          // Apply deletion filter
+          if (filter === DELETION_FILTER.ACTIVE && deleted) continue;
+          if (filter === DELETION_FILTER.DELETED && !deleted) continue;
+          // DELETION_FILTER.ALL shows everything
+
+          if (minimal) {
+            // Minimal mode: return basic info + essential computed fields for fast initial render
+            // Include hasWorktree and isCompleted since they're needed for filtering
+            const hasWt = wtInstalled && hasWorktree(getFeatureBranch(entry.name), root);
+            const completed = isFeatureCompleted(status);
+            features.push({
+              name: entry.name,
+              type: status.type,
+              flow: status.flow,
+              createdAt: status.createdAt,
+              deletedAt: status.deletedAt,
+              isDeleted: deleted,
+              hasWorktree: hasWt,
+              isCompleted: completed,
+            });
+          } else {
+            // Full mode: return all data including computed states
+            const hasWt = wtInstalled && hasWorktree(getFeatureBranch(entry.name), root);
+            const running = isRunning(entry.name);
+            const completed = isFeatureCompleted(status);
+            features.push({ name: entry.name, ...status, hasWorktree: hasWt, isDeleted: deleted, agentRunning: running, isCompleted: completed });
+          }
         } catch {
-          features.push({ name: entry.name, error: true, hasWorktree: false });
+          features.push({ name: entry.name, error: true, hasWorktree: false, isDeleted: false, agentRunning: false });
         }
       }
     }
@@ -85,6 +132,36 @@ export function registerFeatureRoutes(router) {
     }
   });
 
+  // Get agent running status for a feature
+  router.get('/api/features/:name/agent-status', (req, res, { params }) => {
+    const session = getSession(params.name);
+    if (!session) {
+      return json(res, { running: false });
+    }
+    json(res, {
+      running: true,
+      step: session.step,
+      startedAt: session.startedAt,
+      logs: session.logs,
+    });
+  });
+
+  // SSE stream for agent logs (reconnection endpoint)
+  router.get('/api/features/:name/agent-stream', (req, res, { params }) => {
+    const session = getSession(params.name);
+    if (!session) {
+      return error(res, 'No active session', 404);
+    }
+    sseHeaders(res);
+    // Replay buffered logs
+    for (const log of session.logs) {
+      sseSend(res, 'log', { text: log.text, type: log.type });
+    }
+    // Register for live updates
+    addSseClient(params.name, res);
+    req.on('close', () => removeSseClient(params.name, res));
+  });
+
   // Read a feature file
   router.get('/api/features/:name/files/:filename', async (req, res, { params, root }) => {
     const filePath = path.join(root, AIA_DIR, 'features', params.name, params.filename);
@@ -107,9 +184,10 @@ export function registerFeatureRoutes(router) {
   router.post('/api/features', async (req, res, { root, parseBody }) => {
     const body = await parseBody();
     try {
-      validateFeatureName(body.name);
-      await createFeature(body.name, root);
-      json(res, { ok: true, name: body.name }, 201);
+      const { name, type = 'feature', apps = [] } = body;
+      validateFeatureName(name);
+      await createFeature(name, root, { type, apps });
+      json(res, { ok: true, name, type, apps }, 201);
     } catch (err) {
       error(res, err.message, 400);
     }
@@ -126,12 +204,10 @@ export function registerFeatureRoutes(router) {
     };
 
     try {
-      const validatedHistory = validateHistory(body.history || []);
       const validatedAttachments = validateAttachments(body.attachments || []);
 
       const output = await runStep(params.step, params.name, {
         description: body.description,
-        history: validatedHistory,
         attachments: validatedAttachments,
         model: body.model || undefined,
         verbose: body.verbose !== undefined ? body.verbose : true,
@@ -170,30 +246,6 @@ export function registerFeatureRoutes(router) {
     res.end();
   });
 
-  // Quick ticket with SSE streaming (create + run)
-  router.post('/api/quick', async (req, res, { root, parseBody }) => {
-    const body = await parseBody();
-    sseHeaders(res);
-    sseSend(res, 'status', { status: 'started', mode: 'quick', name: body.name });
-
-    const onData = ({ type, text }) => {
-      try { sseSend(res, 'log', { type, text }); } catch {}
-    };
-
-    try {
-      await runQuick(body.name, {
-        description: body.description,
-        apply: body.apply || false,
-        root,
-        onData,
-      });
-      sseSend(res, 'done', { status: 'completed', name: body.name });
-    } catch (err) {
-      sseSend(res, 'error', { message: err.message });
-    }
-    res.end();
-  });
-
   // Iterate a step with SSE streaming (reset + re-run with instructions)
   router.post('/api/features/:name/iterate/:step', async (req, res, { params, root, parseBody }) => {
     const body = await parseBody();
@@ -207,12 +259,10 @@ export function registerFeatureRoutes(router) {
         try { sseSend(res, 'log', { type, text }); } catch {}
       };
 
-      const validatedHistory = validateHistory(body.history || []);
       const validatedAttachments = validateAttachments(body.attachments || []);
 
       await runStep(params.step, params.name, {
         instructions: body.instructions,
-        history: validatedHistory,
         attachments: validatedAttachments,
         model: body.model || undefined,
         verbose: body.verbose !== undefined ? body.verbose : true,
@@ -490,4 +540,64 @@ IMPORTANT:
       error(res, err.message, 400);
     }
   });
+
+  // Update feature type (feature/bug)
+  router.patch('/api/features/:name/type', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    const { type } = body;
+
+    if (!type || !FEATURE_TYPES.includes(type)) {
+      return error(res, `Invalid type. Must be one of: ${FEATURE_TYPES.join(', ')}`, 400);
+    }
+
+    try {
+      await updateType(params.name, type, root);
+      json(res, { ok: true, type });
+    } catch (err) {
+      error(res, err.message, 400);
+    }
+  });
+
+  // Update feature apps/scope
+  router.patch('/api/features/:name/apps', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    const { apps } = body;
+
+    if (!Array.isArray(apps)) {
+      return error(res, 'apps must be an array', 400);
+    }
+
+    // Validate all elements are non-empty strings
+    const invalidApps = apps.filter(a => typeof a !== 'string' || !a.trim());
+    if (invalidApps.length > 0) {
+      return error(res, 'apps must contain only non-empty strings', 400);
+    }
+
+    try {
+      await updateApps(params.name, apps, root);
+      json(res, { ok: true, apps });
+    } catch (err) {
+      error(res, err.message, 400);
+    }
+  });
+
+  // Soft delete a feature
+  router.delete('/api/features/:name', async (req, res, { params, root }) => {
+    try {
+      await softDeleteFeature(params.name, root);
+      json(res, { ok: true, deletedAt: new Date().toISOString() });
+    } catch (err) {
+      error(res, err.message, 400);
+    }
+  });
+
+  // Restore a deleted feature
+  router.post('/api/features/:name/restore', async (req, res, { params, root }) => {
+    try {
+      await restoreFeature(params.name, root);
+      json(res, { ok: true });
+    } catch (err) {
+      error(res, err.message, 400);
+    }
+  });
 }

package/src/ui/api/index.js

@@ -3,6 +3,7 @@ import { registerConfigRoutes } from './config.js';
 import { registerLogRoutes } from './logs.js';
 import { registerConstantsRoutes } from './constants.js';
 import { registerWorktrunkRoutes } from './worktrunk.js';
+import { registerTestQuickRoutes } from './test-quick.js';
 
 export function registerApiRoutes(router, root) {
   registerFeatureRoutes(router);
@@ -10,4 +11,5 @@ export function registerApiRoutes(router, root) {
   registerLogRoutes(router);
   registerConstantsRoutes(router);
   registerWorktrunkRoutes(router);
+  registerTestQuickRoutes(router);
 }

package/src/ui/api/test-quick.js

@@ -0,0 +1,207 @@
+/**
+ * @fileoverview API routes for test-quick feature
+ * Provides REST endpoints for managing test-quick items
+ */
+
+import { json, error } from '../router.js';
+import {
+  loadItems,
+  createItem,
+  getItem,
+  listItems,
+  updateItem,
+  deleteItem,
+  updateStatus,
+  clearCompleted,
+} from '../../services/test-quick.js';
+import { TEST_QUICK_STATUS, isValidTestQuickName } from '../../types/test-quick.js';
+
+/**
+ * Registers test-quick API routes
+ * @param {Object} router - Router instance
+ */
+export function registerTestQuickRoutes(router) {
+  /**
+   * GET /api/test-quick/statuses
+   * Get available status values
+   * Note: Must be registered before :name route to avoid conflict
+   */
+  router.get('/api/test-quick/statuses', async (req, res) => {
+    json(res, { statuses: Object.values(TEST_QUICK_STATUS) });
+  });
+
+  /**
+   * GET /api/test-quick
+   * List all test-quick items with optional status filter
+   */
+  router.get('/api/test-quick', async (req, res, { root, query }) => {
+    try {
+      const options = {};
+      if (query?.status) {
+        options.status = query.status;
+      }
+
+      const result = await listItems(options, root);
+      json(res, result);
+    } catch (err) {
+      error(res, err.message, 500);
+    }
+  });
+
+  /**
+   * GET /api/test-quick/:name
+   * Get a single test-quick item by name
+   */
+  router.get('/api/test-quick/:name', async (req, res, { params, root }) => {
+    try {
+      const result = await getItem(params.name, root);
+
+      if (!result.success) {
+        return error(res, result.error, 404);
+      }
+
+      json(res, result);
+    } catch (err) {
+      error(res, err.message, 500);
+    }
+  });
+
+  /**
+   * POST /api/test-quick
+   * Create a new test-quick item
+   */
+  router.post('/api/test-quick', async (req, res, { root, parseBody }) => {
+    try {
+      const body = await parseBody();
+
+      if (!body.name) {
+        return error(res, 'Name is required', 400);
+      }
+
+      if (!isValidTestQuickName(body.name)) {
+        return error(
+          res,
+          'Invalid name. Use lowercase alphanumeric with hyphens (e.g., my-item)',
+          400
+        );
+      }
+
+      const result = await createItem(
+        {
+          name: body.name,
+          description: body.description,
+        },
+        root
+      );
+
+      if (!result.success) {
+        return error(res, result.error, 400);
+      }
+
+      json(res, result, 201);
+    } catch (err) {
+      error(res, err.message, 500);
+    }
+  });
+
+  /**
+   * PUT /api/test-quick/:name
+   * Update a test-quick item
+   */
+  router.put('/api/test-quick/:name', async (req, res, { params, root, parseBody }) => {
+    try {
+      const body = await parseBody();
+      const updates = {};
+
+      if (body.description !== undefined) {
+        updates.description = body.description;
+      }
+
+      if (body.status !== undefined) {
+        const validStatuses = Object.values(TEST_QUICK_STATUS);
+        if (!validStatuses.includes(body.status)) {
+          return error(res, `Invalid status. Valid values: ${validStatuses.join(', ')}`, 400);
+        }
+        updates.status = body.status;
+      }
+
+      if (body.metadata !== undefined) {
+        updates.metadata = body.metadata;
+      }
+
+      if (Object.keys(updates).length === 0) {
+        return error(res, 'No valid updates provided', 400);
+      }
+
+      const result = await updateItem(params.name, updates, root);
+
+      if (!result.success) {
+        return error(res, result.error, 404);
+      }
+
+      json(res, result);
+    } catch (err) {
+      error(res, err.message, 500);
+    }
+  });
+
+  /**
+   * PATCH /api/test-quick/:name/status
+   * Update only the status of a test-quick item
+   */
+  router.patch('/api/test-quick/:name/status', async (req, res, { params, root, parseBody }) => {
+    try {
+      const body = await parseBody();
+
+      if (!body.status) {
+        return error(res, 'Status is required', 400);
+      }
+
+      const validStatuses = Object.values(TEST_QUICK_STATUS);
+      if (!validStatuses.includes(body.status)) {
+        return error(res, `Invalid status. Valid values: ${validStatuses.join(', ')}`, 400);
+      }
+
+      const result = await updateStatus(params.name, body.status, root);
+
+      if (!result.success) {
+        return error(res, result.error, 404);
+      }
+
+      json(res, result);
+    } catch (err) {
+      error(res, err.message, 500);
+    }
+  });
+
+  /**
+   * DELETE /api/test-quick/:name
+   * Delete a test-quick item
+   */
+  router.delete('/api/test-quick/:name', async (req, res, { params, root }) => {
+    try {
+      const result = await deleteItem(params.name, root);
+
+      if (!result.success) {
+        return error(res, result.error, 404);
+      }
+
+      json(res, result);
+    } catch (err) {
+      error(res, err.message, 500);
+    }
+  });
+
+  /**
+   * POST /api/test-quick/clear-completed
+   * Clear all completed items
+   */
+  router.post('/api/test-quick/clear-completed', async (req, res, { root }) => {
+    try {
+      const result = await clearCompleted(root);
+      json(res, result);
+    } catch (err) {
+      error(res, err.message, 500);
+    }
+  });
+}

package/src/ui/api/worktrunk.js

@@ -6,10 +6,13 @@ import {
   hasWorktree,
   removeWorktree,
   getFeatureBranch,
-  startServices,
-  stopServices,
   hasDockerServices,
+  isDockerRunning,
   getServicesStatus,
+  startComposeService,
+  stopComposeService,
+  startAllComposeServices,
+  stopAllComposeServices,
 } from '../../services/worktrunk.js';
 import { json, error } from '../router.js';
 
@@ -28,21 +31,25 @@ export function registerWorktrunkRoutes(router) {
         installed: false,
         hasWorktree: false,
         path: null,
-        hasServices: false,
+        docker: { available: false, hasComposeFile: false },
       });
     }
 
     const branch = getFeatureBranch(params.name);
     const wtPath = getWorktreePath(branch, root);
     const hasWt = wtPath !== null;
-    const hasServices = hasWt && hasDockerServices(wtPath);
+    const dockerRunning = isDockerRunning();
+    const hasComposeFile = hasWt && hasDockerServices(wtPath);
 
     json(res, {
       installed: true,
       hasWorktree: hasWt,
       path: wtPath,
       branch,
-      hasServices,
+      docker: {
+        available: dockerRunning,
+        hasComposeFile,
+      },
     });
   });
 
@@ -94,29 +101,45 @@ export function registerWorktrunkRoutes(router) {
     }
   });
 
-  // Start docker services in worktree
-  router.post('/api/features/:name/wt/services/start', async (req, res, { params, root }) => {
+  // Get services status (from docker-compose.wt.yml)
+  router.get('/api/features/:name/wt/services', async (req, res, { params, root }) => {
     const branch = getFeatureBranch(params.name);
     const wtPath = getWorktreePath(branch, root);
 
     if (!wtPath) {
-      return error(res, 'No worktree found for this feature', 404);
+      return json(res, { services: [], hasComposeFile: false, dockerAvailable: false });
     }
 
-    if (!hasDockerServices(wtPath)) {
-      return error(res, 'No docker-compose.wt.yml found in worktree', 404);
+    const dockerAvailable = isDockerRunning();
+    const hasComposeFile = hasDockerServices(wtPath);
+
+    if (!dockerAvailable || !hasComposeFile) {
+      return json(res, { services: [], hasComposeFile, dockerAvailable });
+    }
+
+    const services = getServicesStatus(wtPath);
+    json(res, { services, hasComposeFile, dockerAvailable });
+  });
+
+  // Start a specific service
+  router.post('/api/features/:name/wt/services/:service/start', async (req, res, { params, root }) => {
+    const branch = getFeatureBranch(params.name);
+    const wtPath = getWorktreePath(branch, root);
+
+    if (!wtPath) {
+      return error(res, 'No worktree found for this feature', 404);
     }
 
     try {
-      startServices(wtPath);
+      startComposeService(wtPath, params.service);
       json(res, { ok: true });
     } catch (err) {
-      error(res, `Failed to start services: ${err.message}`, 500);
+      error(res, `Failed to start service: ${err.message}`, 500);
     }
   });
 
-  // Stop docker services in worktree
-  router.post('/api/features/:name/wt/services/stop', async (req, res, { params, root }) => {
+  // Stop a specific service
+  router.post('/api/features/:name/wt/services/:service/stop', async (req, res, { params, root }) => {
     const branch = getFeatureBranch(params.name);
     const wtPath = getWorktreePath(branch, root);
 
@@ -124,30 +147,45 @@ export function registerWorktrunkRoutes(router) {
       return error(res, 'No worktree found for this feature', 404);
     }
 
-    if (!hasDockerServices(wtPath)) {
-      return error(res, 'No docker-compose.wt.yml found in worktree', 404);
+    try {
+      stopComposeService(wtPath, params.service);
+      json(res, { ok: true });
+    } catch (err) {
+      error(res, `Failed to stop service: ${err.message}`, 500);
+    }
+  });
+
+  // Start all services
+  router.post('/api/features/:name/wt/services/start', async (req, res, { params, root }) => {
+    const branch = getFeatureBranch(params.name);
+    const wtPath = getWorktreePath(branch, root);
+
+    if (!wtPath) {
+      return error(res, 'No worktree found for this feature', 404);
     }
 
     try {
-      stopServices(wtPath);
+      startAllComposeServices(wtPath);
       json(res, { ok: true });
     } catch (err) {
-      error(res, `Failed to stop services: ${err.message}`, 500);
+      error(res, `Failed to start services: ${err.message}`, 500);
     }
   });
 
-  // Get services status
-  router.get('/api/features/:name/wt/services', async (req, res, { params, root }) => {
+  // Stop all services
+  router.post('/api/features/:name/wt/services/stop', async (req, res, { params, root }) => {
     const branch = getFeatureBranch(params.name);
     const wtPath = getWorktreePath(branch, root);
 
     if (!wtPath) {
-      return json(res, { services: [], hasServices: false });
+      return error(res, 'No worktree found for this feature', 404);
     }
 
-    const hasServices = hasDockerServices(wtPath);
-    const services = hasServices ? getServicesStatus(wtPath) : [];
-
-    json(res, { services, hasServices });
+    try {
+      stopAllComposeServices(wtPath);
+      json(res, { ok: true });
+    } catch (err) {
+      error(res, `Failed to stop services: ${err.message}`, 500);
+    }
   });
 }