@bamptee/aia-code 2.0.12 → 2.0.14

package/src/services/status.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import yaml from 'yaml';
-import { AIA_DIR, FEATURE_STEPS, STEP_STATUS } from '../constants.js';
+import { AIA_DIR, FEATURE_STEPS, STEP_STATUS, FEATURE_TYPES } from '../constants.js';
 
 function statusPath(feature, root) {
   return path.join(root, AIA_DIR, 'features', feature, 'status.yaml');
@@ -79,3 +79,71 @@ export async function resetStep(feature, step, root = process.cwd()) {
 
   // Keep the existing output — it will be fed back as context on re-run
 }
+
+export async function updateType(feature, type, root = process.cwd()) {
+  // Validate type
+  if (!FEATURE_TYPES.includes(type)) {
+    throw new Error(`Invalid type "${type}". Valid types: ${FEATURE_TYPES.join(', ')}`);
+  }
+
+  const status = await loadStatus(feature, root);
+  status.type = type;
+
+  // Bug type forces quick flow, but only if no steps have been completed
+  if (type === 'bug') {
+    const allPending = Object.values(status.steps).every(s => s === STEP_STATUS.PENDING);
+    if (allPending) {
+      status.flow = 'quick';
+      status.current_step = 'dev-plan';
+    }
+  }
+
+  const content = yaml.stringify(status);
+  await fs.writeFile(statusPath(feature, root), content, 'utf-8');
+}
+
+export async function updateApps(feature, apps, root = process.cwd()) {
+  // Validate apps - must be an array of strings
+  if (!Array.isArray(apps)) {
+    throw new Error('apps must be an array');
+  }
+  const validApps = apps.filter(a => typeof a === 'string' && a.trim()).map(a => a.trim());
+
+  const status = await loadStatus(feature, root);
+  status.apps = validApps;
+  const content = yaml.stringify(status);
+  await fs.writeFile(statusPath(feature, root), content, 'utf-8');
+}
+
+/**
+ * Soft delete a feature by setting deletedAt timestamp
+ * @param {string} feature - Feature name
+ * @param {string} root - Project root directory
+ */
+export async function softDeleteFeature(feature, root = process.cwd()) {
+  const status = await loadStatus(feature, root);
+  status.deletedAt = new Date().toISOString();
+  const content = yaml.stringify(status);
+  await fs.writeFile(statusPath(feature, root), content, 'utf-8');
+}
+
+/**
+ * Restore a deleted feature by clearing deletedAt
+ * @param {string} feature - Feature name
+ * @param {string} root - Project root directory
+ */
+export async function restoreFeature(feature, root = process.cwd()) {
+  const status = await loadStatus(feature, root);
+  delete status.deletedAt;
+  const content = yaml.stringify(status);
+  await fs.writeFile(statusPath(feature, root), content, 'utf-8');
+}
+
+/**
+ * Check if a feature is deleted
+ * @param {object} status - Feature status object
+ * @returns {boolean}
+ */
+export function isFeatureDeleted(status) {
+  return !!(status && status.deletedAt != null);
+}

package/src/services/test-quick.js

@@ -0,0 +1,229 @@
+/**
+ * @fileoverview Service layer for test-quick feature
+ * Provides business logic for managing test-quick items
+ */
+
+import path from 'node:path';
+import fs from 'fs-extra';
+import yaml from 'yaml';
+import { AIA_DIR } from '../constants.js';
+import {
+  TEST_QUICK_STATUS,
+  isValidTestQuickName,
+  createTestQuickItem,
+} from '../types/test-quick.js';
+
+const TEST_QUICK_DIR = 'test-quick';
+const DATA_FILE = 'items.yaml';
+
+/**
+ * Gets the test-quick directory path
+ * @param {string} root - Project root directory
+ * @returns {string} Path to test-quick directory
+ */
+function getTestQuickDir(root) {
+  return path.join(root, AIA_DIR, TEST_QUICK_DIR);
+}
+
+/**
+ * Gets the data file path
+ * @param {string} root - Project root directory
+ * @returns {string} Path to data file
+ */
+function getDataFilePath(root) {
+  return path.join(getTestQuickDir(root), DATA_FILE);
+}
+
+/**
+ * Ensures the test-quick directory exists
+ * @param {string} root - Project root directory
+ */
+async function ensureTestQuickDir(root) {
+  await fs.ensureDir(getTestQuickDir(root));
+}
+
+/**
+ * Loads all test-quick items from storage
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<import('../types/test-quick.js').TestQuickItem[]>} List of items
+ */
+export async function loadItems(root = process.cwd()) {
+  const dataPath = getDataFilePath(root);
+
+  if (!(await fs.pathExists(dataPath))) {
+    return [];
+  }
+
+  const content = await fs.readFile(dataPath, 'utf-8');
+  const data = yaml.parse(content);
+
+  return Array.isArray(data?.items) ? data.items : [];
+}
+
+/**
+ * Saves all test-quick items to storage
+ * @param {import('../types/test-quick.js').TestQuickItem[]} items - Items to save
+ * @param {string} [root=process.cwd()] - Project root directory
+ */
+async function saveItems(items, root = process.cwd()) {
+  await ensureTestQuickDir(root);
+  const dataPath = getDataFilePath(root);
+  const content = yaml.stringify({ items, updatedAt: new Date().toISOString() });
+  await fs.writeFile(dataPath, content, 'utf-8');
+}
+
+/**
+ * Creates a new test-quick item
+ * @param {Object} data - Item data
+ * @param {string} data.name - Item name
+ * @param {string} [data.description] - Item description
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<import('../types/test-quick.js').TestQuickResult>} Creation result
+ */
+export async function createItem(data, root = process.cwd()) {
+  const { name, description } = data;
+
+  if (!name) {
+    return { success: false, error: 'Name is required' };
+  }
+
+  if (!isValidTestQuickName(name)) {
+    return {
+      success: false,
+      error: 'Invalid name. Use lowercase alphanumeric with hyphens (e.g., my-item)',
+    };
+  }
+
+  const items = await loadItems(root);
+
+  if (items.some(item => item.name === name)) {
+    return { success: false, error: `Item "${name}" already exists` };
+  }
+
+  const newItem = createTestQuickItem({ name, description });
+  items.push(newItem);
+
+  await saveItems(items, root);
+
+  return { success: true, message: `Item "${name}" created`, data: newItem };
+}
+
+/**
+ * Gets a single test-quick item by name
+ * @param {string} name - Item name
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<import('../types/test-quick.js').TestQuickResult>} Item result
+ */
+export async function getItem(name, root = process.cwd()) {
+  const items = await loadItems(root);
+  const item = items.find(i => i.name === name);
+
+  if (!item) {
+    return { success: false, error: `Item "${name}" not found` };
+  }
+
+  return { success: true, data: item };
+}
+
+/**
+ * Lists all test-quick items with optional filtering
+ * @param {Object} [options={}] - Filter options
+ * @param {string} [options.status] - Filter by status
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<import('../types/test-quick.js').TestQuickListResult>} List result
+ */
+export async function listItems(options = {}, root = process.cwd()) {
+  let items = await loadItems(root);
+
+  if (options.status) {
+    items = items.filter(item => item.status === options.status);
+  }
+
+  return { success: true, items, total: items.length };
+}
+
+/**
+ * Updates an existing test-quick item
+ * @param {string} name - Item name to update
+ * @param {Object} updates - Fields to update
+ * @param {string} [updates.description] - New description
+ * @param {string} [updates.status] - New status
+ * @param {Object} [updates.metadata] - New metadata
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<import('../types/test-quick.js').TestQuickResult>} Update result
+ */
+export async function updateItem(name, updates, root = process.cwd()) {
+  const items = await loadItems(root);
+  const index = items.findIndex(i => i.name === name);
+
+  if (index === -1) {
+    return { success: false, error: `Item "${name}" not found` };
+  }
+
+  const validStatuses = Object.values(TEST_QUICK_STATUS);
+  if (updates.status && !validStatuses.includes(updates.status)) {
+    return {
+      success: false,
+      error: `Invalid status. Valid values: ${validStatuses.join(', ')}`,
+    };
+  }
+
+  const updatedItem = {
+    ...items[index],
+    ...updates,
+    updatedAt: new Date().toISOString(),
+  };
+
+  items[index] = updatedItem;
+  await saveItems(items, root);
+
+  return { success: true, message: `Item "${name}" updated`, data: updatedItem };
+}
+
+/**
+ * Deletes a test-quick item
+ * @param {string} name - Item name to delete
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<import('../types/test-quick.js').TestQuickResult>} Delete result
+ */
+export async function deleteItem(name, root = process.cwd()) {
+  const items = await loadItems(root);
+  const index = items.findIndex(i => i.name === name);
+
+  if (index === -1) {
+    return { success: false, error: `Item "${name}" not found` };
+  }
+
+  const deletedItem = items[index];
+  items.splice(index, 1);
+
+  await saveItems(items, root);
+
+  return { success: true, message: `Item "${name}" deleted`, data: deletedItem };
+}
+
+/**
+ * Updates the status of a test-quick item
+ * @param {string} name - Item name
+ * @param {string} status - New status
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<import('../types/test-quick.js').TestQuickResult>} Update result
+ */
+export async function updateStatus(name, status, root = process.cwd()) {
+  return updateItem(name, { status }, root);
+}
+
+/**
+ * Clears all completed items
+ * @param {string} [root=process.cwd()] - Project root directory
+ * @returns {Promise<{success: boolean, cleared: number}>} Clear result
+ */
+export async function clearCompleted(root = process.cwd()) {
+  const items = await loadItems(root);
+  const remaining = items.filter(item => item.status !== TEST_QUICK_STATUS.COMPLETED);
+  const clearedCount = items.length - remaining.length;
+
+  await saveItems(remaining, root);
+
+  return { success: true, cleared: clearedCount };
+}

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