@bamptee/aia-code 2.0.13 → 2.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamptee/aia-code",
-  "version": "2.0.13",
+  "version": "2.0.15",
   "description": "AI Architecture Assistant - orchestrate AI-assisted development workflows via CLI tools (Claude, Codex, Gemini)",
   "type": "module",
   "license": "MIT",

package/src/providers/anthropic.js

@@ -12,10 +12,14 @@ export async function generate(prompt, model, { verbose = false, apply = false,
   }
   if (apply) {
     args.push('--allowedTools', 'Edit,Write,Bash,Read,Glob,Grep');
+    // Use stream-json for real-time output visibility
+    args.push('--output-format', 'stream-json');
+    // Include partial messages for token-by-token streaming
+    args.push('--include-partial-messages');
   }
   if (verbose || apply) {
     args.push('--verbose');
   }
 
-  return runCli('claude', args, { stdin: prompt, verbose: verbose || apply, apply, onData, cwd });
+  return runCli('claude', args, { stdin: prompt, verbose: verbose || apply, apply, onData, cwd, streamJson: apply });
 }

package/src/providers/cli-runner.js

@@ -3,24 +3,124 @@ 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, cwd } = {}) {
+/**
+ * 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;
+    // Log the full command for debugging (allows manual replay)
+    const shellCmd = [command, ...args].map(a => /[\s"']/.test(a) ? `'${a.replace(/'/g, "'\\''")}'` : a).join(' ');
+    console.error(chalk.gray(`[AI] Run: ${shellCmd}`));
+    if (stdinData) {
+      console.error(chalk.gray(`[AI] stdin: ${stdinData.length > 200 ? stdinData.slice(0, 200) + '...' : stdinData} (${(stdinData.length / 1024).toFixed(1)}KB)`));
+    }
+
+    // Remove CLAUDECODE from env to avoid conflicts
+    const { CLAUDECODE: _, ...cleanEnv } = process.env;
     const child = spawn(command, args, {
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, FORCE_COLOR: '0' },
+      env: { ...cleanEnv, FORCE_COLOR: '0' },
       cwd,
     });
 
+    console.error(chalk.gray(`[AI] PID: ${child.pid}`));
+
     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);
@@ -47,10 +147,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();
-      if (verbose) 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) => {
@@ -75,11 +197,21 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
       }
     });
 
-    child.on('close', (code) => {
+    child.on('close', (code, signal) => {
+      console.error(chalk.gray(`[AI] Process exited: code=${code} signal=${signal || 'none'}`));
+      // 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 });
 }