proffesor-for-testing__agentic-qe/docs/fixes/cli-non-interactive-implementation.md

# CLI Non-Interactive Mode Implementation (Release 1.2.0)

## Problem

**P1 Issue**: The `aqe init` command prompted for user input even when CLI options were provided, breaking CI/CD automation.

**Symptoms**:
- `npx aqe init --topology mesh --max-agents 5` would still prompt interactively
- Cannot use in automated scripts or CI pipelines
- Blocks automated testing and deployment workflows

## Solution

Added non-interactive mode support with two approaches:

### 1. CLI Flags

Added `--yes` and `--non-interactive` flags to skip all prompts:

```bash
# Using --yes flag
npx aqe init --topology mesh --max-agents 5 --yes

# Using --non-interactive flag
npx aqe init --topology mesh --max-agents 5 --non-interactive
```

### 2. Environment Variables

All configuration can be provided via environment variables:

```bash
# Environment variable configuration
AQE_PROJECT_NAME=my-project \
AQE_LANGUAGE=typescript \
AQE_ROUTING_ENABLED=true \
AQE_STREAMING_ENABLED=true \
AQE_LEARNING_ENABLED=true \
AQE_PATTERNS_ENABLED=true \
AQE_IMPROVEMENT_ENABLED=true \
npx aqe init -y
```

## Implementation Details

### File Changes

**1. `/workspaces/agentic-qe-cf/src/cli/index.ts`**

Added CLI options:
```typescript
program
  .command('init')
  .description('Initialize the AQE Fleet')
  .option('-c, --config <path>', 'Configuration file path')
  .option('-t, --topology <type>', 'Swarm topology', 'hierarchical')
  .option('-m, --max-agents <number>', 'Maximum agents', '10')
  .option('-f, --focus <areas>', 'Testing focus areas', 'unit,integration')
  .option('-e, --environments <envs>', 'Target environments', 'development')
  .option('--frameworks <frameworks>', 'Test frameworks', 'jest')
  .option('-y, --yes', 'Skip all prompts and use defaults (non-interactive mode)')
  .option('--non-interactive', 'Same as --yes (skip all prompts)')
```

**2. `/workspaces/agentic-qe-cf/src/cli/commands/init.ts`**

Added non-interactive logic:
```typescript
// Detect non-interactive mode
const isNonInteractive = (options as any).nonInteractive || (options as any).yes;

if (!options.config && !isNonInteractive) {
  // Interactive mode: prompt user
  const projectAnswers = await inquirer.prompt([...]);
  // ... use answers
} else {
  // Non-interactive mode: use defaults or environment variables
  (fleetConfig as any).project = {
    name: process.env.AQE_PROJECT_NAME || path.basename(process.cwd()),
    path: process.cwd(),
    language: (process.env.AQE_LANGUAGE || 'typescript').toLowerCase()
  };

  // Use environment variables or defaults
  if (fleetConfig.routing) {
    fleetConfig.routing.enabled = process.env.AQE_ROUTING_ENABLED === 'true' || false;
  }
  if (fleetConfig.streaming) {
    fleetConfig.streaming.enabled = process.env.AQE_STREAMING_ENABLED !== 'false';
  }

  // Phase 2 features
  (options as any).enableLearning = process.env.AQE_LEARNING_ENABLED !== 'false';
  (options as any).enablePatterns = process.env.AQE_PATTERNS_ENABLED !== 'false';
  (options as any).enableImprovement = process.env.AQE_IMPROVEMENT_ENABLED !== 'false';

  // User feedback
  console.log(chalk.gray('  ℹ️  Running in non-interactive mode with defaults'));
  console.log(chalk.gray(`  • Project: ${(fleetConfig as any).project.name}`));
  console.log(chalk.gray(`  • Language: ${(fleetConfig as any).project.language}`));
  console.log(chalk.gray(`  • Routing: ${fleetConfig.routing?.enabled ? 'enabled' : 'disabled'}`));
  console.log(chalk.gray(`  • Streaming: ${fleetConfig.streaming?.enabled ? 'enabled' : 'disabled'}`));
}
```

## Usage Examples

### Basic Non-Interactive Initialization

```bash
# Simplest form - use all defaults
npx aqe init -y

# With custom topology and agent count
npx aqe init --topology mesh --max-agents 8 --yes

# With custom frameworks
npx aqe init --frameworks jest,vitest --non-interactive
```

### CI/CD Pipeline Usage

```bash
# GitHub Actions / GitLab CI
- name: Initialize AQE Fleet
  run: |
    npx aqe init \
      --topology hierarchical \
      --max-agents 10 \
      --focus unit,integration,e2e \
      --environments development,staging,production \
      --frameworks jest \
      --yes
```

### Docker/Container Usage

```bash
# Dockerfile
RUN npx aqe init \
    --topology mesh \
    --max-agents 5 \
    --yes

# Or with environment variables
ENV AQE_PROJECT_NAME=my-app \
    AQE_TOPOLOGY=mesh \
    AQE_ROUTING_ENABLED=true

RUN npx aqe init -y
```

### Automated Script Usage

```bash
#!/bin/bash
# setup-aqe.sh

# Set configuration via environment
export AQE_PROJECT_NAME="automated-tests"
export AQE_LANGUAGE="typescript"
export AQE_ROUTING_ENABLED="true"
export AQE_STREAMING_ENABLED="true"

# Initialize without prompts
npx aqe init \
  --topology hierarchical \
  --max-agents 10 \
  --focus unit,integration \
  --environments development,staging \
  --yes

echo "AQE Fleet initialized successfully"
```

## Environment Variables Reference

| Variable | Type | Default | Description |
|----------|------|---------|-------------|
| `AQE_PROJECT_NAME` | string | Current directory name | Project name |
| `AQE_LANGUAGE` | string | `typescript` | Primary programming language |
| `AQE_ROUTING_ENABLED` | boolean | `false` | Enable Multi-Model Router |
| `AQE_STREAMING_ENABLED` | boolean | `true` | Enable streaming progress |
| `AQE_LEARNING_ENABLED` | boolean | `true` | Enable Q-learning |
| `AQE_PATTERNS_ENABLED` | boolean | `true` | Enable pattern bank |
| `AQE_IMPROVEMENT_ENABLED` | boolean | `true` | Enable improvement loop |

## CLI Options Reference

| Option | Alias | Default | Description |
|--------|-------|---------|-------------|
| `--topology <type>` | `-t` | `hierarchical` | Fleet topology (hierarchical, mesh, ring, adaptive) |
| `--max-agents <number>` | `-m` | `10` | Maximum number of agents (5-50) |
| `--focus <areas>` | `-f` | `unit,integration` | Comma-separated testing focus areas |
| `--environments <envs>` | `-e` | `development` | Comma-separated environments |
| `--frameworks <frameworks>` | - | `jest` | Comma-separated test frameworks |
| `--yes` | `-y` | - | Skip all prompts (non-interactive) |
| `--non-interactive` | - | - | Same as --yes |
| `--config <path>` | `-c` | - | Use configuration file |

## Verification

### Test Non-Interactive Mode

```bash
# Test 1: Basic non-interactive
npx aqe init -y

# Expected output:
# ℹ️  Running in non-interactive mode with defaults
# • Project: agentic-qe-cf
# • Language: typescript
# • Routing: disabled
# • Streaming: enabled
```

### Test Environment Variables

```bash
# Test 2: Environment variable override
AQE_PROJECT_NAME=test-project \
AQE_ROUTING_ENABLED=true \
npx aqe init --yes

# Expected: Project name should be "test-project", routing enabled
```

### Test CLI Options

```bash
# Test 3: CLI options
npx aqe init \
  --topology mesh \
  --max-agents 8 \
  --frameworks jest,vitest \
  --non-interactive

# Expected: No prompts, uses specified values
```

## Backward Compatibility

✅ **Fully backward compatible**

- Without `--yes` or `--non-interactive`: Interactive mode (original behavior)
- With flags: Non-interactive mode (new behavior)
- Existing scripts without flags continue to work

## Impact

- **Before**: Cannot use in CI/CD or automation (blocks on prompts)
- **After**: Full automation support via flags or environment variables
- **Breaking Changes**: None
- **Migration**: None required (opt-in feature)

## Related Issues

This fixes P1 blocker for Release 1.2.0 enabling CI/CD integration.

## Testing

Manual testing performed:
1. ✅ Interactive mode still works (no flags)
2. ✅ `--yes` flag skips all prompts
3. ✅ `--non-interactive` flag skips all prompts
4. ✅ Environment variables properly applied
5. ✅ CLI options properly used
6. ✅ Default values applied when not specified

---

**Implemented by**: Claude Code (Backend API Developer agent)
**Date**: 2025-10-21
**Release**: 1.2.0