@bamptee/aia-code 2.0.12 → 2.0.13

package/src/services/worktrunk.js

@@ -146,24 +146,15 @@ export function getFeatureBranch(featureName) {
 }
 
 /**
- * Start docker-compose services in a worktree
- * @param {string} wtPath - Worktree directory path
- */
-export function startServices(wtPath) {
-  const composePath = path.join(wtPath, 'docker-compose.wt.yml');
-  if (fs.existsSync(composePath)) {
-    execSync('docker-compose -f docker-compose.wt.yml up -d', { cwd: wtPath, stdio: 'inherit' });
-  }
-}
-
-/**
- * Stop docker-compose services in a worktree
- * @param {string} wtPath - Worktree directory path
+ * Check if Docker daemon is running
+ * @returns {boolean}
  */
-export function stopServices(wtPath) {
-  const composePath = path.join(wtPath, 'docker-compose.wt.yml');
-  if (fs.existsSync(composePath)) {
-    execSync('docker-compose -f docker-compose.wt.yml down', { cwd: wtPath, stdio: 'inherit' });
+export function isDockerRunning() {
+  try {
+    execSync('docker info', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
   }
 }
 
@@ -179,19 +170,142 @@ export function hasDockerServices(wtPath) {
 }
 
 /**
- * Get docker services status
+ * List services defined in docker-compose.wt.yml
  * @param {string} wtPath - Worktree directory path
- * @returns {Array} List of service objects with name and status
+ * @returns {Array<string>} List of service names
+ */
+export function listComposeServices(wtPath) {
+  if (!hasDockerServices(wtPath)) return [];
+  try {
+    const output = execSync('docker-compose -f docker-compose.wt.yml config --services', {
+      cwd: wtPath,
+      encoding: 'utf-8',
+    });
+    return output.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get status of all services from docker-compose
+ * @param {string} wtPath - Worktree directory path
+ * @returns {Array} List of service objects with name, state, status
  */
 export function getServicesStatus(wtPath) {
   if (!hasDockerServices(wtPath)) return [];
+
+  // Get all defined services
+  const definedServices = listComposeServices(wtPath);
+  if (!definedServices.length) return [];
+
+  // Get running containers status
+  let runningServices = [];
   try {
     const output = execSync('docker-compose -f docker-compose.wt.yml ps --format json', {
       cwd: wtPath,
       encoding: 'utf-8',
     });
-    return JSON.parse(output);
+    // docker-compose ps --format json outputs one JSON per line
+    runningServices = output.trim().split('\n').filter(Boolean).map(line => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
   } catch {
-    return [];
+    // docker-compose ps failed, all services are stopped
   }
+
+  // Map defined services to their status
+  return definedServices.map(serviceName => {
+    const running = runningServices.find(s =>
+      s.Service === serviceName || s.Name?.includes(serviceName)
+    );
+
+    // Extract published ports from Publishers array
+    const ports = (running?.Publishers || [])
+      .filter(p => p.PublishedPort)
+      .map(p => ({
+        published: p.PublishedPort,
+        target: p.TargetPort,
+        protocol: p.Protocol || 'tcp',
+      }));
+
+    return {
+      name: serviceName,
+      state: running?.State || 'stopped',
+      status: running?.Status || 'Stopped',
+      health: running?.Health || null,
+      ports,
+    };
+  });
+}
+
+/**
+ * Start a docker-compose service
+ * @param {string} wtPath - Worktree directory path
+ * @param {string} serviceName - Service name to start
+ */
+export function startComposeService(wtPath, serviceName) {
+  if (!hasDockerServices(wtPath)) {
+    throw new Error('No docker-compose.wt.yml found');
+  }
+  // Validate service name
+  if (!/^[a-zA-Z0-9_-]+$/.test(serviceName)) {
+    throw new Error(`Invalid service name: "${serviceName}"`);
+  }
+  execSync(`docker-compose -f docker-compose.wt.yml up -d ${serviceName}`, {
+    cwd: wtPath,
+    stdio: 'inherit',
+  });
+}
+
+/**
+ * Stop a docker-compose service
+ * @param {string} wtPath - Worktree directory path
+ * @param {string} serviceName - Service name to stop
+ */
+export function stopComposeService(wtPath, serviceName) {
+  if (!hasDockerServices(wtPath)) {
+    throw new Error('No docker-compose.wt.yml found');
+  }
+  // Validate service name
+  if (!/^[a-zA-Z0-9_-]+$/.test(serviceName)) {
+    throw new Error(`Invalid service name: "${serviceName}"`);
+  }
+  execSync(`docker-compose -f docker-compose.wt.yml stop ${serviceName}`, {
+    cwd: wtPath,
+    stdio: 'inherit',
+  });
+}
+
+/**
+ * Start all docker-compose services
+ * @param {string} wtPath - Worktree directory path
+ */
+export function startAllComposeServices(wtPath) {
+  if (!hasDockerServices(wtPath)) {
+    throw new Error('No docker-compose.wt.yml found');
+  }
+  execSync('docker-compose -f docker-compose.wt.yml up -d', {
+    cwd: wtPath,
+    stdio: 'inherit',
+  });
 }
+
+/**
+ * Stop all docker-compose services
+ * @param {string} wtPath - Worktree directory path
+ */
+export function stopAllComposeServices(wtPath) {
+  if (!hasDockerServices(wtPath)) {
+    throw new Error('No docker-compose.wt.yml found');
+  }
+  execSync('docker-compose -f docker-compose.wt.yml stop', {
+    cwd: wtPath,
+    stdio: 'inherit',
+  });
+}
+

package/src/types/test-quick.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview Type definitions for test-quick feature
+ * Uses JSDoc for type definitions in this JavaScript codebase
+ */
+
+/**
+ * @typedef {Object} TestQuickConfig
+ * @property {string} name - Name of the test-quick item
+ * @property {string} [description] - Optional description
+ * @property {boolean} [enabled=true] - Whether the item is enabled
+ * @property {string} [createdAt] - ISO timestamp of creation
+ */
+
+/**
+ * @typedef {Object} TestQuickItem
+ * @property {string} id - Unique identifier
+ * @property {string} name - Item name
+ * @property {string} [description] - Optional description
+ * @property {'pending'|'active'|'completed'|'error'} status - Current status
+ * @property {Object} [metadata] - Additional metadata
+ * @property {string} createdAt - ISO timestamp of creation
+ * @property {string} [updatedAt] - ISO timestamp of last update
+ */
+
+/**
+ * @typedef {Object} TestQuickResult
+ * @property {boolean} success - Whether the operation succeeded
+ * @property {string} [message] - Result message
+ * @property {TestQuickItem} [data] - Result data
+ * @property {string} [error] - Error message if failed
+ */
+
+/**
+ * @typedef {Object} TestQuickListResult
+ * @property {boolean} success - Whether the operation succeeded
+ * @property {TestQuickItem[]} items - List of items
+ * @property {number} total - Total count
+ */
+
+/**
+ * Valid status values for test-quick items
+ * @type {Object.<string, string>}
+ */
+export const TEST_QUICK_STATUS = {
+  PENDING: 'pending',
+  ACTIVE: 'active',
+  COMPLETED: 'completed',
+  ERROR: 'error',
+};
+
+/**
+ * Default configuration for test-quick
+ * @type {TestQuickConfig}
+ */
+export const DEFAULT_TEST_QUICK_CONFIG = {
+  name: '',
+  description: '',
+  enabled: true,
+  createdAt: null,
+};
+
+/**
+ * Validates a test-quick item name
+ * @param {string} name - Name to validate
+ * @returns {boolean} Whether the name is valid
+ */
+export function isValidTestQuickName(name) {
+  if (!name || typeof name !== 'string') return false;
+  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
+}
+
+/**
+ * Creates a new test-quick item with defaults
+ * @param {Partial<TestQuickItem>} data - Partial item data
+ * @returns {TestQuickItem} Complete item with defaults
+ */
+export function createTestQuickItem(data) {
+  const now = new Date().toISOString();
+  return {
+    id: data.id || `tq-${Date.now()}`,
+    name: data.name || '',
+    description: data.description || '',
+    status: data.status || TEST_QUICK_STATUS.PENDING,
+    metadata: data.metadata || {},
+    createdAt: data.createdAt || now,
+    updatedAt: now,
+  };
+}

package/src/ui/api/config.js

@@ -2,10 +2,37 @@ import path from 'node:path';
 import fs from 'fs-extra';
 import yaml from 'yaml';
 import { AIA_DIR } from '../../constants.js';
-import { loadGlobalConfig, saveGlobalConfig, getGlobalConfigPath } from '../../services/config.js';
+import { loadGlobalConfig, saveGlobalConfig, getGlobalConfigPath, getApps, setApps, toggleApp } from '../../services/config.js';
+import { scanApps } from '../../services/apps.js';
 import { json, error } from '../router.js';
 
 export function registerConfigRoutes(router) {
+  // GET /api/apps - List configured apps
+  router.get('/api/apps', async (req, res, { root }) => {
+    const apps = await getApps(root);
+    json(res, apps);
+  });
+
+  // POST /api/apps/scan - Re-scan and update apps
+  router.post('/api/apps/scan', async (req, res, { root }) => {
+    const scanned = await scanApps(root);
+    const existing = await getApps(root);
+    // Merge: keep enabled status from existing apps
+    const merged = scanned.map(s => {
+      const ex = existing.find(e => e.path === s.path);
+      return ex ? { ...s, enabled: ex.enabled } : s;
+    });
+    await setApps(merged, root);
+    json(res, merged);
+  });
+
+  // PATCH /api/apps/:name - Toggle app enabled status
+  router.patch('/api/apps/:name', async (req, res, { params, root, parseBody }) => {
+    const { enabled } = await parseBody();
+    await toggleApp(params.name, enabled, root);
+    json(res, { ok: true });
+  });
+
   // Get project config
   router.get('/api/config', async (req, res, { root }) => {
     const configPath = path.join(root, AIA_DIR, 'config.yaml');

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);
 }