@bamptee/aia-code 2.0.12 → 2.0.14

package/src/providers/cli-runner.js

@@ -1,24 +1,117 @@
 import { spawn } from 'node:child_process';
+import { Readable } from 'node:stream';
 import chalk from 'chalk';
 
 const DEFAULT_IDLE_TIMEOUT_MS = 180_000;
-const AGENT_IDLE_TIMEOUT_MS = 600_000;
+const AGENT_IDLE_TIMEOUT_MS = 1_800_000; // 30 minutes pour éviter les timeouts sur les tâches complexes
 
-export function runCli(command, args, { stdin: stdinData, verbose = false, apply = false, idleTimeoutMs, onData } = {}) {
+/**
+ * Parse stream-json events from Claude CLI and extract human-readable output
+ */
+function parseStreamJsonEvent(line, onData, state = {}) {
+  try {
+    const event = JSON.parse(line);
+
+    // Extract readable content based on event type
+    if (event.type === 'system' && event.subtype === 'init') {
+      const msg = `[init] Model: ${event.model}, Tools: ${event.tools?.length || 0}\n`;
+      if (onData) onData({ type: 'stdout', text: msg });
+      return { result: null, state };
+    }
+
+    // Stream events (partial messages) - token by token streaming
+    if (event.type === 'stream_event' && event.event) {
+      const streamEvent = event.event;
+
+      // Content block delta - actual text tokens
+      if (streamEvent.type === 'content_block_delta' && streamEvent.delta) {
+        if (streamEvent.delta.type === 'text_delta' && streamEvent.delta.text) {
+          if (onData) onData({ type: 'stdout', text: streamEvent.delta.text });
+        }
+        // Tool use input delta
+        if (streamEvent.delta.type === 'input_json_delta' && streamEvent.delta.partial_json) {
+          // Tool input streaming - don't output raw JSON
+        }
+      }
+
+      // Content block start - new block starting
+      if (streamEvent.type === 'content_block_start' && streamEvent.content_block) {
+        if (streamEvent.content_block.type === 'tool_use') {
+          const toolMsg = `\n[tool] ${streamEvent.content_block.name}\n`;
+          if (onData) onData({ type: 'stdout', text: toolMsg });
+        }
+      }
+
+      // Message start
+      if (streamEvent.type === 'message_start') {
+        // New message starting - could add indicator
+      }
+
+      // Message stop
+      if (streamEvent.type === 'message_stop') {
+        if (onData) onData({ type: 'stdout', text: '\n' });
+      }
+
+      return { result: null, state };
+    }
+
+    // Complete assistant message (non-streaming)
+    if (event.type === 'assistant' && event.message?.content) {
+      for (const block of event.message.content) {
+        if (block.type === 'text' && block.text) {
+          if (onData) onData({ type: 'stdout', text: block.text });
+        } else if (block.type === 'tool_use') {
+          const toolMsg = `\n[tool] ${block.name}\n`;
+          if (onData) onData({ type: 'stdout', text: toolMsg });
+        }
+      }
+      return { result: null, state };
+    }
+
+    // User message (tool results)
+    if (event.type === 'user' && event.message?.content) {
+      for (const block of event.message.content) {
+        if (block.type === 'tool_result') {
+          const status = block.is_error ? '✗' : '✓';
+          const resultMsg = `\n[${status}] Tool completed\n`;
+          if (onData) onData({ type: 'stdout', text: resultMsg });
+        }
+      }
+      return { result: null, state };
+    }
+
+    // Final result
+    if (event.type === 'result') {
+      return { result: event.result || '', state };
+    }
+
+    return { result: null, state };
+  } catch {
+    // Not valid JSON, return as-is
+    return { result: null, state };
+  }
+}
+
+export function runCli(command, args, { stdin: stdinData, verbose = false, apply = false, idleTimeoutMs, onData, cwd, streamJson = false } = {}) {
   if (!idleTimeoutMs) {
     idleTimeoutMs = apply ? AGENT_IDLE_TIMEOUT_MS : DEFAULT_IDLE_TIMEOUT_MS;
   }
   return new Promise((resolve, reject) => {
-    const { CLAUDECODE, ...cleanEnv } = process.env;
+    // Remove CLAUDECODE from env to avoid conflicts
+    const { CLAUDECODE: _, ...cleanEnv } = process.env;
     const child = spawn(command, args, {
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...cleanEnv, FORCE_COLOR: '0' },
+      cwd,
     });
 
     const chunks = [];
     let stderr = '';
     let settled = false;
     let gotFirstOutput = false;
+    let jsonBuffer = ''; // Buffer for incomplete JSON lines
+    let finalResult = ''; // Store the final result from stream-json
+    let parserState = {}; // State for stream parser
 
     function resetTimer() {
       clearTimeout(timer);
@@ -45,10 +138,32 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
         console.error(chalk.gray('[AI] First stdout received — agent is running'));
       }
       const text = data.toString();
-      process.stdout.write(text);
-      chunks.push(text);
-      if (onData) onData({ type: 'stdout', text });
       resetTimer();
+
+      if (streamJson) {
+        // Parse stream-json format line by line
+        jsonBuffer += text;
+        const lines = jsonBuffer.split('\n');
+        jsonBuffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const { result, state } = parseStreamJsonEvent(line, onData, parserState);
+          parserState = state;
+          if (result !== null) {
+            finalResult = result;
+          }
+          if (verbose) {
+            // In verbose mode, also show raw JSON for debugging
+            process.stdout.write(chalk.gray(line + '\n'));
+          }
+        }
+      } else {
+        // Original behavior for non-stream-json
+        if (verbose) process.stdout.write(text);
+        chunks.push(text);
+        if (onData) onData({ type: 'stdout', text });
+      }
     });
 
     child.stderr.on('data', (data) => {
@@ -74,10 +189,19 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
     });
 
     child.on('close', (code) => {
+      // Process any remaining data in the buffer
+      if (streamJson && jsonBuffer.trim()) {
+        const { result } = parseStreamJsonEvent(jsonBuffer, onData, parserState);
+        if (result !== null) {
+          finalResult = result;
+        }
+      }
+
       if (code !== 0) {
         finish(new Error(`${command} exited with code ${code}:\n${stderr.trim()}`));
       } else {
-        finish(null, chunks.join(''));
+        // For stream-json, return the extracted result; otherwise return chunks
+        finish(null, streamJson ? finalResult : chunks.join(''));
       }
     });
 

package/src/providers/gemini.js

@@ -1,14 +1,16 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model, { verbose = false, apply = false, onData } = {}) {
+export async function generate(prompt, model, { verbose = false, apply = false, onData, cwd } = {}) {
   const args = [];
   if (model) {
     args.push('-m', model);
   }
   if (apply) {
     args.push('--sandbox', 'false');
+    // Use stream-json for real-time output visibility
+    args.push('--output-format', 'stream-json');
   }
   args.push('-');
 
-  return runCli('gemini', args, { stdin: prompt, verbose: verbose || apply, apply, onData });
+  return runCli('gemini', args, { stdin: prompt, verbose: verbose || apply, apply, onData, cwd, streamJson: apply });
 }

package/src/providers/openai.js

@@ -1,6 +1,6 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model, { verbose = false, apply = false, onData } = {}) {
+export async function generate(prompt, model, { verbose = false, apply = false, onData, cwd } = {}) {
   const args = ['exec'];
   if (model) {
     args.push('-c', `model="${model}"`);
@@ -10,5 +10,6 @@ export async function generate(prompt, model, { verbose = false, apply = false,
   }
   args.push('-');
 
-  return runCli('codex', args, { stdin: prompt, verbose: verbose || apply, apply, onData });
+  // Note: Codex CLI does not support stream-json output format
+  return runCli('codex', args, { stdin: prompt, verbose: verbose || apply, apply, onData, cwd });
 }

package/src/services/agent-sessions.js

@@ -0,0 +1,110 @@
+// Agent session tracking - in-memory Map with log buffer
+// Map<featureName, { step, startedAt, logs: Array<{text, type, ts}>, sseClients: Set<Response> }>
+const sessions = new Map();
+const MAX_LOGS = 500;
+
+/**
+ * Start a new agent session for a feature
+ * @param {string} feature - Feature name
+ * @param {string} step - Step name
+ */
+export function startSession(feature, step) {
+  sessions.set(feature, {
+    step,
+    startedAt: Date.now(),
+    logs: [],
+    sseClients: new Set(),
+  });
+}
+
+/**
+ * End an agent session and notify all SSE clients
+ * @param {string} feature - Feature name
+ */
+export function endSession(feature) {
+  const session = sessions.get(feature);
+  if (session) {
+    // Notify all SSE clients that session ended
+    for (const client of session.sseClients) {
+      try {
+        client.write(`event: done\ndata: {}\n\n`);
+      } catch {
+        // Client may have disconnected
+      }
+    }
+    sessions.delete(feature);
+  }
+}
+
+/**
+ * Get an active session for a feature
+ * @param {string} feature - Feature name
+ * @returns {Object|null} Session object or null
+ */
+export function getSession(feature) {
+  return sessions.get(feature) || null;
+}
+
+/**
+ * Append a log entry to a session's buffer
+ * @param {string} feature - Feature name
+ * @param {string} text - Log text
+ * @param {string} type - Log type ('stdout' or 'stderr')
+ */
+export function appendLog(feature, text, type = 'stdout') {
+  const session = sessions.get(feature);
+  if (!session) return;
+
+  session.logs.push({ text, type, ts: Date.now() });
+  if (session.logs.length > MAX_LOGS) session.logs.shift();
+
+  // Broadcast to all SSE clients
+  for (const client of session.sseClients) {
+    try {
+      client.write(`event: log\ndata: ${JSON.stringify({ text, type })}\n\n`);
+    } catch {
+      // Client may have disconnected
+    }
+  }
+}
+
+/**
+ * Register an SSE client for a session
+ * @param {string} feature - Feature name
+ * @param {Response} res - HTTP response object
+ */
+export function addSseClient(feature, res) {
+  const session = sessions.get(feature);
+  if (session) session.sseClients.add(res);
+}
+
+/**
+ * Unregister an SSE client from a session
+ * @param {string} feature - Feature name
+ * @param {Response} res - HTTP response object
+ */
+export function removeSseClient(feature, res) {
+  const session = sessions.get(feature);
+  if (session) session.sseClients.delete(res);
+}
+
+/**
+ * Check if a feature has an active session
+ * @param {string} feature - Feature name
+ * @returns {boolean}
+ */
+export function isRunning(feature) {
+  return sessions.has(feature);
+}
+
+/**
+ * Get all running sessions (for dashboard)
+ * @returns {Object} Map of feature name to session summary
+ */
+export function getAllRunningSessions() {
+  const result = {};
+  for (const [feature, session] of sessions) {
+    result[feature] = { step: session.step, startedAt: session.startedAt };
+  }
+  return result;
+}

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