@bamptee/aia-code 2.0.12 → 2.0.13

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

package/src/ui/public/components/config-view.js

@@ -245,6 +245,98 @@ function ProjectSettings({ onSaved }) {
   );
 }
 
+function ProjectScope({ onSaved }) {
+  const [apps, setApps] = React.useState([]);
+  const [loading, setLoading] = React.useState(true);
+  const [scanning, setScanning] = React.useState(false);
+  const [dirty, setDirty] = React.useState(false);
+  const [msg, setMsg] = React.useState(null);
+
+  React.useEffect(() => {
+    api.get('/apps').then(setApps).catch(() => {}).finally(() => setLoading(false));
+  }, []);
+
+  const handleToggle = async (appName, enabled) => {
+    setDirty(true);
+    setMsg(null);
+    try {
+      await api.patch(`/apps/${appName}`, { enabled });
+      setApps(prev => prev.map(a => a.name === appName ? { ...a, enabled } : a));
+      setDirty(false);
+      setMsg({ type: 'ok', text: 'Saved.' });
+      if (onSaved) onSaved();
+    } catch (e) {
+      setMsg({ type: 'err', text: e.message });
+    }
+  };
+
+  const handleScan = async () => {
+    setScanning(true);
+    setMsg(null);
+    try {
+      const scanned = await api.post('/apps/scan');
+      setApps(scanned);
+      setMsg({ type: 'ok', text: `Found ${scanned.length} app(s).` });
+      if (onSaved) onSaved();
+    } catch (e) {
+      setMsg({ type: 'err', text: e.message });
+    }
+    setScanning(false);
+  };
+
+  if (loading) return React.createElement('p', { className: 'text-slate-500 text-sm' }, 'Loading...');
+
+  return React.createElement('div', { className: 'bg-aia-card border border-aia-border rounded p-4 space-y-4' },
+    React.createElement('div', { className: 'flex items-center justify-between' },
+      React.createElement('h3', { className: 'text-sm font-semibold text-amber-400' }, 'Project Scope'),
+      React.createElement('div', { className: 'flex gap-2 items-center' },
+        msg && React.createElement('span', { className: `text-xs ${msg.type === 'ok' ? 'text-emerald-400' : 'text-red-400'}` }, msg.text),
+        React.createElement('button', {
+          onClick: handleScan,
+          disabled: scanning,
+          className: 'bg-aia-accent/20 text-aia-accent border border-aia-accent/30 rounded px-3 py-1 text-xs hover:bg-aia-accent/30 disabled:opacity-40',
+        }, scanning ? 'Scanning...' : 'Re-scan Project'),
+      ),
+    ),
+
+    apps.length === 0
+      ? React.createElement('p', { className: 'text-slate-500 text-sm' },
+          'No apps detected. Click "Re-scan Project" to detect apps and submodules.'
+        )
+      : React.createElement('div', { className: 'space-y-2' },
+          ...apps.map(app =>
+            React.createElement('div', {
+              key: app.name,
+              className: 'flex items-center justify-between py-2 border-b border-slate-700 last:border-0',
+            },
+              React.createElement('div', { className: 'flex items-center gap-2' },
+                React.createElement('span', { className: 'text-lg' }, app.icon || '\uD83D\uDCC1'),
+                React.createElement('div', null,
+                  React.createElement('span', { className: 'text-sm text-slate-200' }, app.name),
+                  React.createElement('p', { className: 'text-xs text-slate-500' }, app.path),
+                ),
+              ),
+              React.createElement('label', { className: 'relative inline-flex items-center cursor-pointer' },
+                React.createElement('input', {
+                  type: 'checkbox',
+                  checked: app.enabled !== false,
+                  onChange: (e) => handleToggle(app.name, e.target.checked),
+                  className: 'sr-only peer',
+                }),
+                React.createElement('div', {
+                  className: 'w-9 h-5 bg-slate-700 rounded-full peer peer-checked:bg-aia-accent peer-checked:after:translate-x-full after:content-[\'\'] after:absolute after:top-0.5 after:left-[2px] after:bg-white after:rounded-full after:h-4 after:w-4 after:transition-all',
+                }),
+              ),
+            )
+          )
+        ),
+
+    React.createElement('p', { className: 'text-xs text-slate-500' },
+      'Enable/disable apps to control feature scope options. Disabled apps won\'t appear in feature scope selection.'
+    ),
+  );
+}
+
 export function ConfigView() {
   const [contextFiles, setContextFiles] = React.useState([]);
   const [knowledgeCategories, setKnowledgeCategories] = React.useState([]);
@@ -293,6 +385,9 @@ export function ConfigView() {
       React.createElement(ProjectSettings, { onSaved: handlePreferencesSaved }),
     ),
 
+    // Project Scope
+    React.createElement(ProjectScope, { onSaved: handlePreferencesSaved }),
+
     // config.yaml (advanced)
     React.createElement(YamlEditor, {
       key: `config-${configVersion}`,