@bamptee/aia-code 2.0.12 → 2.0.13

package/src/services/apps.js

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { APP_ICONS } from '../constants.js';
+
+const MANIFEST_FILES = {
+  'package.json': 'node',
+  'pom.xml': 'java',
+  'go.mod': 'go',
+  'Cargo.toml': 'rust',
+  'requirements.txt': 'python',
+  'pyproject.toml': 'python',
+};
+
+const IGNORE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'vendor',
+  '.aia',
+  'coverage',
+  '__pycache__',
+  '.next',
+  '.nuxt',
+]);
+
+/**
+ * Detect the icon for an app based on its manifest file
+ */
+async function detectIcon(appPath, manifestType) {
+  // For node projects, check for framework-specific indicators
+  if (manifestType === 'node') {
+    const pkgPath = path.join(appPath, 'package.json');
+    try {
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      if (deps.react || deps['react-dom']) return 'react';
+      if (deps.vue) return 'vue';
+      if (deps['@angular/core']) return 'angular';
+      return 'node';
+    } catch {
+      return 'node';
+    }
+  }
+
+  return manifestType;
+}
+
+/**
+ * Check if a directory is a git submodule
+ */
+async function isGitSubmodule(dirPath) {
+  const gitPath = path.join(dirPath, '.git');
+  try {
+    const stat = await fs.stat(gitPath);
+    // Submodules have a .git file (not directory) pointing to the main repo
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Scan a directory for apps/submodules
+ */
+export async function scanApps(root = process.cwd()) {
+  const apps = [];
+  const visited = new Set();
+
+  async function scan(dir, depth = 0) {
+    // Limit depth to avoid deep recursion
+    if (depth > 3) return;
+
+    const relativePath = path.relative(root, dir);
+    if (visited.has(relativePath)) return;
+    visited.add(relativePath);
+
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    // Check for manifest files in current directory
+    let foundManifest = null;
+    for (const [manifest, type] of Object.entries(MANIFEST_FILES)) {
+      if (entries.some(e => e.isFile() && e.name === manifest)) {
+        foundManifest = { manifest, type };
+        break;
+      }
+    }
+
+    // Check if this is a git submodule
+    const isSubmodule = await isGitSubmodule(dir);
+
+    // If we found a manifest or submodule (not at root), add as app
+    if ((foundManifest || isSubmodule) && relativePath) {
+      const appName = path.basename(dir);
+      const iconType = foundManifest
+        ? await detectIcon(dir, foundManifest.type)
+        : 'generic';
+
+      apps.push({
+        name: appName,
+        path: relativePath,
+        icon: APP_ICONS[iconType] || APP_ICONS.generic,
+        enabled: true,
+      });
+
+      // Don't scan deeper if we found an app
+      return;
+    }
+
+    // Recurse into subdirectories
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      if (entry.name.startsWith('.')) continue;
+
+      await scan(path.join(dir, entry.name), depth + 1);
+    }
+  }
+
+  await scan(root);
+
+  // Sort by name
+  apps.sort((a, b) => a.name.localeCompare(b.name));
+
+  return apps;
+}

package/src/services/config.js

@@ -4,6 +4,11 @@ import fs from 'fs-extra';
 import yaml from 'yaml';
 import { AIA_DIR } from '../constants.js';
 
+// Project config path helper
+function projectConfigPath(root) {
+  return path.join(root, AIA_DIR, 'config.yaml');
+}
+
 // Global user config directory
 const GLOBAL_AIA_DIR = path.join(os.homedir(), '.aia');
 const GLOBAL_CONFIG_PATH = path.join(GLOBAL_AIA_DIR, 'config.yaml');
@@ -103,3 +108,39 @@ export async function updateGlobalConfig(updates) {
 export function getGlobalConfigPath() {
   return GLOBAL_CONFIG_PATH;
 }
+
+// Project config helpers for apps
+export async function loadProjectConfig(root = process.cwd()) {
+  const configPath = projectConfigPath(root);
+  if (!(await fs.pathExists(configPath))) {
+    return {};
+  }
+  const raw = await fs.readFile(configPath, 'utf-8');
+  return yaml.parse(raw) || {};
+}
+
+export async function getApps(root = process.cwd()) {
+  const config = await loadProjectConfig(root);
+  return config.apps || [];
+}
+
+export async function setApps(apps, root = process.cwd()) {
+  const configPath = projectConfigPath(root);
+  let config = {};
+  if (await fs.pathExists(configPath)) {
+    const raw = await fs.readFile(configPath, 'utf-8');
+    config = yaml.parse(raw) || {};
+  }
+  config.apps = apps;
+  await fs.writeFile(configPath, yaml.stringify(config), 'utf-8');
+}
+
+export async function toggleApp(appName, enabled, root = process.cwd()) {
+  const apps = await getApps(root);
+  const app = apps.find(a => a.name === appName);
+  if (!app) {
+    throw new Error(`App "${appName}" not found`);
+  }
+  app.enabled = Boolean(enabled);
+  await setApps(apps, root);
+}

package/src/services/feature.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import yaml from 'yaml';
-import { AIA_DIR, FEATURE_STEPS } from '../constants.js';
+import { AIA_DIR, FEATURE_STEPS, DEFAULT_FEATURE_TYPE, FEATURE_TYPES } from '../constants.js';
 
 const FEATURE_FILES = [
   'status.yaml',
@@ -36,21 +36,42 @@ function buildInitMd(name) {
 `;
 }
 
-function buildStatusYaml(name) {
+function buildStatusYaml(name, { type = DEFAULT_FEATURE_TYPE, apps = [] } = {}) {
+  // Validate type
+  const validType = FEATURE_TYPES.includes(type) ? type : DEFAULT_FEATURE_TYPE;
+
+  // Validate apps - ensure it's an array of strings
+  const validApps = Array.isArray(apps)
+    ? apps.filter(a => typeof a === 'string' && a.trim()).map(a => a.trim())
+    : [];
+
   const steps = {};
   for (const step of FEATURE_STEPS) {
     steps[step] = 'pending';
   }
 
-  return yaml.stringify({
+  // Bug type defaults to quick flow, feature type defaults to full flow
+  const flow = validType === 'bug' ? 'quick' : 'full';
+  const currentStep = flow === 'quick' ? 'dev-plan' : 'brief';
+
+  const status = {
     feature: name,
-    current_step: 'brief',
+    type: validType,
+    flow,
+    current_step: currentStep,
+    createdAt: new Date().toISOString(),
     steps,
     knowledge: ['backend'],
-  });
+  };
+
+  if (validApps.length > 0) {
+    status.apps = validApps;
+  }
+
+  return yaml.stringify(status);
 }
 
-export async function createFeature(name, root = process.cwd()) {
+export async function createFeature(name, root = process.cwd(), options = {}) {
   validateFeatureName(name);
 
   const featureDir = path.join(root, AIA_DIR, 'features', name);
@@ -64,7 +85,7 @@ export async function createFeature(name, root = process.cwd()) {
   for (const file of FEATURE_FILES) {
     const filePath = path.join(featureDir, file);
     let content = '';
-    if (file === 'status.yaml') content = buildStatusYaml(name);
+    if (file === 'status.yaml') content = buildStatusYaml(name, options);
     else if (file === 'init.md') content = buildInitMd(name);
     await fs.writeFile(filePath, content, 'utf-8');
   }

package/src/services/model-call.js

@@ -1,12 +1,12 @@
 import chalk from 'chalk';
 import { resolveModelAlias } from '../providers/registry.js';
 
-export async function callModel(model, prompt, { verbose = false, apply = false, onData } = {}) {
+export async function callModel(model, prompt, { verbose = false, apply = false, onData, cwd } = {}) {
   const resolved = resolveModelAlias(model);
   const displayName = resolved.model ?? `${model} (CLI default)`;
   const mode = apply ? 'agent' : 'print';
 
   console.log(chalk.yellow(`[AI] Calling ${displayName} (${mode} mode)...`));
 
-  return resolved.provider.generate(prompt, resolved.model, { verbose, apply, onData });
+  return resolved.provider.generate(prompt, resolved.model, { verbose, apply, onData, cwd });
 }

package/src/services/runner.js

@@ -7,6 +7,8 @@ import { buildPrompt } from '../prompt-builder.js';
 import { callModel } from './model-call.js';
 import { loadStatus, updateStepStatus } from './status.js';
 import { logExecution } from '../logger.js';
+import { startSession, endSession, appendLog } from './agent-sessions.js';
+import { hasWorktree, getWorktreePath, getFeatureBranch } from './worktrunk.js';
 
 export async function runStep(step, feature, { description, instructions, history, attachments, model: modelOverride, verbose = false, apply = false, root = process.cwd(), onData } = {}) {
   if (!FEATURE_STEPS.includes(step)) {
@@ -25,12 +27,29 @@ export async function runStep(step, feature, { description, instructions, histor
 
   const shouldApply = apply || APPLY_STEPS.has(step);
 
+  // Start agent session for tracking
+  startSession(feature, step);
+
+  // Note: Claude CLI has a bug where it hangs in git worktrees
+  // So we always use the main repo root as CWD for now
+  // TODO: Re-enable worktree CWD when Claude CLI fixes this
+  // const branch = getFeatureBranch(feature);
+  // const wtPath = hasWorktree(branch, root) ? getWorktreePath(branch, root) : null;
+  // const cwd = wtPath || root;
+  const cwd = root;
+
+  // Wrapper onData to buffer logs in session
+  const wrappedOnData = (data) => {
+    appendLog(feature, data.text, data.type);
+    if (onData) onData(data);
+  };
+
   try {
     const model = modelOverride || await resolveModel(step, root);
     const prompt = await buildPrompt(feature, step, { description, instructions, history, attachments, root });
 
     const start = performance.now();
-    const output = await callModel(model, prompt, { verbose, apply: shouldApply, onData });
+    const output = await callModel(model, prompt, { verbose, apply: shouldApply, onData: wrappedOnData, cwd });
     const duration = performance.now() - start;
 
     const outputPath = path.join(root, AIA_DIR, 'features', feature, `${step}.md`);
@@ -44,5 +63,8 @@ export async function runStep(step, feature, { description, instructions, histor
   } catch (err) {
     await updateStepStatus(feature, step, STEP_STATUS.ERROR, root);
     throw err;
+  } finally {
+    // End session regardless of success or failure
+    endSession(feature);
   }
 }

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