qa360 2.1.2 → 2.1.4

package/docs/OPTION_3_4_EXPLORATION.md

@@ -0,0 +1,1257 @@
+# Exploration Détaillée : Options 3 & 4
+
+**Date** : 31 Décembre 2024
+**Sujet** : Intégration IA pour QA360 - LLM Direct vs MCP Server
+
+---
+
+## Table des Matières
+
+1. [Option 3 : Intégration LLM Directe](#option-3)
+2. [Option 4 : Enhancement MCP Server](#option-4)
+3. [Comparaison Détaillée](#comparaison)
+4. [Recommandation Stratégique](#recommandation)
+
+---
+
+## Option 3 : Intégration LLM Directe {#option-3}
+
+### Concept
+
+Intégrer directement des providers LLM (OpenAI, Anthropic, etc.) dans QA360 pour générer des tests de manière intelligente.
+
+### Architecture Proposée
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                         QA360 CLI                                       │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                    New: AI Module                                  │ │
+│  │  ┌────────────────┐  ┌────────────────┐  ┌────────────────────┐   │ │
+│  │  │ LLM Provider   │  │ Test Generator │  │ Smart Triage       │   │ │
+│  │  │ Abstraction    │  │                │  │                    │   │ │
+│  │  └────────────────┘  └────────────────┘  └────────────────────┘   │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+│                                    ↓                                    │
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                 Existing: Commands                                 │ │
+│  │  ask | generate | triage | fix | chat                               │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+│                                    ↓                                    │
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                    Core Execution                                   │ │
+│  │  Phase3Runner → Adapters → Vault → Proof                           │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+│                                                                          │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+### Implémentation Technique
+
+#### 1. Abstraction Multi-Provider
+
+```typescript
+// core/src/ai/providers/base.ts
+export interface LLMProvider {
+  name: string;
+  models: string[];
+  generate(request: GenerationRequest): Promise<GenerationResponse>;
+  stream?(request: GenerationRequest): AsyncIterable<string>;
+  countTokens(text: string): number;
+}
+
+export interface GenerationRequest {
+  prompt: string;
+  systemPrompt?: string;
+  maxTokens?: number;
+  temperature?: number;
+  jsonMode?: boolean;  // Pour output structuré
+}
+
+export interface GenerationResponse {
+  content: string;
+  usage: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  model: string;
+  finishReason: 'stop' | 'length' | 'content_filter';
+}
+```
+
+#### 2. Implémentations Providers
+
+```typescript
+// core/src/ai/providers/openai.ts
+export class OpenAIProvider implements LLMProvider {
+  name = 'openai';
+  models = ['gpt-4o', 'gpt-4o-mini', 'gpt-3.5-turbo'];
+
+  constructor(private client: OpenAI) {}
+
+  async generate(request: GenerationRequest): Promise<GenerationResponse> {
+    const response = await this.client.responses.create({
+      model: 'gpt-4o',
+      input: request.prompt,
+    });
+    // ...
+  }
+}
+
+// core/src/ai/providers/anthropic.ts
+export class AnthropicProvider implements LLMProvider {
+  name = 'anthropic';
+  models = ['claude-sonnet-4-20250514', 'claude-opus-4-20250514', 'claude-haiku-4-20250514'];
+
+  constructor(private client: Anthropic) {}
+
+  async generate(request: GenerationRequest): Promise<GenerationResponse> {
+    const response = await this.client.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: request.maxTokens || 4096,
+      messages: [{ role: 'user', content: request.prompt }],
+    });
+    // ...
+  }
+}
+
+// core/src/ai/providers/ollama.ts (pour local)
+export class OllamaProvider implements LLMProvider {
+  name = 'ollama';
+  models = ['llama3.2', 'mistral', 'codellama', 'deepseek-coder'];
+
+  constructor(private baseUrl: string = 'http://localhost:11434') {}
+
+  async generate(request: GenerationRequest): Promise<GenerationResponse> {
+    const response = await fetch(`${this.baseUrl}/api/generate`, {
+      method: 'POST',
+      body: JSON.stringify({
+        model: 'llama3.2',
+        prompt: request.prompt,
+        stream: false,
+      }),
+    });
+    // ...
+  }
+}
+```
+
+#### 3. Provider Manager avec Fallback
+
+```typescript
+// core/src/ai/manager.ts
+export class LLMManager {
+  private providers: Map<string, LLMProvider> = new Map();
+  private primary: LLMProvider;
+  private fallback?: LLMProvider;
+
+  constructor(config: LLMConfig) {
+    // Initialiser providers
+    if (config.openai) {
+      this.providers.set('openai', new OpenAIProvider(config.openai.apiKey));
+    }
+    if (config.anthropic) {
+      this.providers.set('anthropic', new AnthropicProvider(config.anthropic.apiKey));
+    }
+    if (config.ollama) {
+      this.providers.set('ollama', new OllamaProvider(config.ollama.baseUrl));
+    }
+
+    this.primary = this.providers.get(config.primary) || this.providers.values().next().value;
+    this.fallback = config.fallback ? this.providers.get(config.fallback) : undefined;
+  }
+
+  async generate(request: GenerationRequest): Promise<GenerationResponse> {
+    try {
+      return await this.primary.generate(request);
+    } catch (error) {
+      if (this.fallback) {
+        console.warn(`Primary provider failed, trying fallback: ${error}`);
+        return await this.fallback.generate(request);
+      }
+      throw error;
+    }
+  }
+
+  // Optimisation coût : utiliser petit modèle pour résumés
+  async generateSummary(longText: string): Promise<string> {
+    const smallProvider = this.findCheapest();
+    const response = await smallProvider.generate({
+      prompt: `Summarize concisely: ${longText}`,
+      maxTokens: 500,
+    });
+    return response.content;
+  }
+}
+```
+
+#### 4. Test Generator
+
+```typescript
+// core/src/ai/generators/test-generator.ts
+export class TestGenerator {
+  constructor(private llm: LLMManager) {}
+
+  async generateFromOpenAPI(spec: OpenAPISpec): Promise<PackConfig> {
+    const systemPrompt = `You are a QA test generation expert. Generate a comprehensive QA360 pack YAML from OpenAPI spec.
+
+Output format (JSON):
+{
+  "name": "pack-name",
+  "version": "1.0.0",
+  "description": "...",
+  "gates": {
+    "api_smoke": {
+      "adapter": "playwright-api",
+      "config": {
+        "baseUrl": "...",
+        "requests": [
+          {"method": "GET", "path": "/health", "expect": {"status": 200}},
+          ...
+        ]
+      }
+    }
+  }
+}`;
+
+    const userPrompt = `Generate tests for this OpenAPI spec:
+${JSON.stringify(spec, null, 2)}
+
+Focus on:
+1. Critical health endpoints
+2. Authentication flows
+3. CRUD operations for main resources
+4. Error responses
+`;
+
+    const response = await this.llm.generate({
+      systemPrompt,
+      prompt: userPrompt,
+      jsonMode: true,
+      maxTokens: 8000,
+    });
+
+    return JSON.parse(response.content) as PackConfig;
+  }
+
+  async generateFromUserStories(stories: string): Promise<PackConfig> {
+    const systemPrompt = `You are a QA expert. Convert user stories into E2E tests using Playwright.
+
+Focus on:
+- Happy path scenarios
+- Edge cases and error handling
+- Accessibility checks
+- Performance budgets
+`;
+
+    const response = await this.llm.generate({
+      systemPrompt,
+      prompt: `Generate tests for these user stories:\n${stories}`,
+      jsonMode: true,
+      maxTokens: 6000,
+    });
+
+    return JSON.parse(response.content);
+  }
+
+  async generateFromCrawl(url: string): Promise<PackConfig> {
+    // D'abord crawler avec Playwright
+    const pages = await this.crawlApplication(url);
+
+    // Ensuite générer les tests
+    const response = await this.llm.generate({
+      prompt: `Generate E2E tests for application at ${url}.
+Discovered pages: ${JSON.stringify(pages, null, 2)}`,
+      jsonMode: true,
+    });
+
+    return JSON.parse(response.content);
+  }
+
+  private async crawlApplication(url: string): Promise<PageInfo[]> {
+    // Implémentation crawl avec Playwright
+    // ...
+  }
+}
+```
+
+#### 5. Smart Triage
+
+```typescript
+// core/src/ai/triage/smart-triage.ts
+export class SmartTriage {
+  constructor(private llm: LLMManager) {}
+
+  async analyzeFailure(
+    runResult: RunResult,
+    context: { codebase?: string; logs?: string }
+  ): Promise<TriageAnalysis> {
+    const systemPrompt = `You are a QA debugging expert. Analyze test failures and provide:
+1. Root cause analysis
+2. Suggested fixes with code examples
+3. Confidence score (0-100)
+4. Whether it can be auto-fixed`;
+
+    const userPrompt = `Analyze this test failure:
+
+Gate: ${runResult.gate}
+Status: ${runResult.status}
+Error: ${runResult.error}
+Logs: ${context.logs || 'N/A'}
+
+Code context:
+${context.codebase || 'N/A'}`;
+
+    const response = await this.llm.generate({
+      systemPrompt,
+      prompt: userPrompt,
+      jsonMode: true,
+    });
+
+    return JSON.parse(response.content) as TriageAnalysis;
+  }
+
+  async autoFix(
+    filePath: string,
+    error: TestError,
+    analysis: TriageAnalysis
+  ): Promise<FixResult> {
+    if (!analysis.canAutoFix || analysis.confidence < 80) {
+      return { success: false, reason: 'Low confidence or not auto-fixable' };
+    }
+
+    const systemPrompt = `You are a code fixer. Modify the test file to fix the issue.
+Return ONLY the complete fixed file content.`;
+
+    const currentContent = await fs.readFile(filePath, 'utf-8');
+
+    const response = await this.llm.generate({
+      systemPrompt,
+      prompt: `Fix this test file:
+
+File: ${filePath}
+Error: ${error.message}
+Analysis: ${analysis.explanation}
+
+Current content:
+${currentContent}`,
+    });
+
+    await fs.writeFile(filePath, response.content, 'utf-8');
+    return { success: true, fixedContent: response.content };
+  }
+}
+```
+
+#### 6. Nouvelles Commandes CLI
+
+```typescript
+// cli/src/commands/generate.ts
+export async function generateCommand(options: GenerateOptions): Promise<void> {
+  const llm = new LLMManager(loadLLMConfig());
+  const generator = new TestGenerator(llm);
+
+  let pack: PackConfig;
+
+  switch (options.source) {
+    case 'openapi':
+      pack = await generator.generateFromOpenAPI(options.spec);
+      break;
+    case 'stories':
+      pack = await generator.generateFromUserStories(options.content);
+      break;
+    case 'crawl':
+      pack = await generator.generateFromCrawl(options.url);
+      break;
+    default:
+      pack = await generator.generateFromPrompt(options.prompt);
+  }
+
+  await savePack(pack, options.output);
+  console.log(`✅ Pack generated: ${options.output}`);
+}
+
+// cli/src/commands/triage.ts
+export async function triageCommand(runId: string, options: TriageOptions): Promise<void> {
+  const run = await getRunResult(runId);
+  const context = await getFailureContext(runId);
+
+  const llm = new LLMManager(loadLLMConfig());
+  const triage = new SmartTriage(llm);
+
+  const analysis = await triage.analyzeFailure(run, context);
+
+  console.log(`\n🔍 Root Cause: ${analysis.rootCause}`);
+  console.log(`📊 Confidence: ${analysis.confidence}%`);
+  console.log(`\n💡 Suggested Fix:\n${analysis.suggestedFix}`);
+
+  if (options.autoFix && analysis.canAutoFix) {
+    const result = await triage.autoFix(analysis.fileToFix, run.error, analysis);
+    if (result.success) {
+      console.log(`✅ Auto-fixed: ${result.fileToFix}`);
+    }
+  }
+}
+
+// cli/src/commands/chat.ts
+export async function chatCommand(): Promise<void> {
+  const llm = new LLMManager(loadLLMConfig());
+  const vault = new EvidenceVault();
+
+  const history: Message[] = [];
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  while (true) {
+    const input = await question('\n> ');
+    if (input === 'exit') break;
+
+    // Ajouter contexte QA360
+    const context = await gatherQA360Context(input, vault);
+
+    const response = await llm.generate({
+      systemPrompt: `You are QA360 Assistant, a QA expert. Help with test creation, debugging, and quality analysis.`,
+      prompt: `${context}\n\nUser: ${input}`,
+    });
+
+    console.log(`\n
+    history.push({ role: 'user', content: input });
+    history.push({ role: 'assistant', content: response.content });
+  }
+}
+```
+
+#### 7. Configuration
+
+```yaml
+# .qa360/ai.yml
+ai:
+  enabled: true
+
+  providers:
+    openai:
+      apiKey: ${OPENAI_API_KEY}
+      models:
+        default: gpt-4o
+        cheap: gpt-4o-mini
+        fast: gpt-3.5-turbo
+
+    anthropic:
+      apiKey: ${ANTHROPIC_API_KEY}
+      models:
+        default: claude-sonnet-4-20250514
+        cheap: claude-haiku-4-20250514
+
+    ollama:
+      baseUrl: http://localhost:11434
+      models:
+        default: llama3.2
+        coder: deepseek-coder
+
+  primary: openai
+  fallback: anthropic
+
+  cost_optimization:
+    use_cheap_for_summaries: true
+    max_tokens_per_request: 8000
+    cache_enabled: true
+
+  features:
+    test_generation: true
+    smart_triage: true
+    auto_fix: true
+    chat_mode: true
+```
+
+### Avantages
+
+| Avantage | Description |
+|----------|-------------|
+| **Contrôle total** | QA360 possède toute la logique, pas de dépendance externe |
+| **Performances** | Pas de surcharge MCP, appels LLM directs |
+| **Offline possible** | Support Ollama pour modèles locaux |
+| **Flexibilité** | Multi-provider avec fallback intelligent |
+| **Coût optimisé** | Utilisation de petits modèles pour les résumés |
+| **Intégration profonde** | L'AI connaît toute la structure QA360 |
+
+### Inconvénients
+
+| Inconvénient | Description |
+|--------------|-------------|
+| **Maintenance** | QA360 doit maintenir les intégrations LLM |
+| **Complexité** | Plus de code dans le core |
+| **Mises à jour** | Doit suivre les évolutions des APIs LLM |
+| **Dépendances** | Ajoute des dépendances externes (SDKs) |
+| **Coût développement** | Plus de temps à implémenter |
+
+---
+
+## Option 4 : Enhancement MCP Server {#option-4}
+
+### Concept
+
+Renforcer le serveur MCP existant de QA360 et permettre à des agents externes (Goose, , Cursor) de l'utiliser.
+
+### Architecture Proposée
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                     External AI Agents                                  │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
+│  │  Goose   │  │Cursor    │  │Claude    │  │Custom    │  │Future   │ │
+│  │          │  │          │  │Code      │  │Agent     │  │Agents   │ │
+│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬────┘ │
+│       └──────────────┴──────────────┴──────────────┴────────────┴───────┘ │
+│                              ↓                                           │
+│                     ┌───────────────┐                                    │
+│                     │  MCP Protocol │                                    │
+│                     └───────┬───────┘                                    │
+└──────────────────────────────┼───────────────────────────────────────────┘
+                               ↓
+┌─────────────────────────────────────────────────────────────────────────┐
+│                      QA360 MCP Server (Enhanced)                         │
+├─────────────────────────────────────────────────────────────────────────┤
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                   Enhanced Tools (40+)                             │ │
+│  │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐  │ │
+│  │  │ Test        │ │ Codebase    │ │ Generator   │ │ Collabor.   │  │ │
+│  │  │ Execution   │ │ Analysis    │ │ Tools       │ │ Tools       │  │ │
+│  │  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘  │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+│                              ↓                                           │
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                    QA360 Core                                       │ │
+│  │  Phase3Runner → Adapters → Vault → Proof                            │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+### Implémentation Technique
+
+#### 1. Nouveaux Outils MCP
+
+```typescript
+// packages/mcp/src/tools/enhanced/test-generator.ts
+export class TestGeneratorTools {
+  /**
+   * Génère un pack depuis une spec OpenAPI
+   */
+  async generateFromOpenAPI(args: {
+    specUrl?: string;
+    specContent?: string;
+    options?: {
+      includeAuth?: boolean;
+      includeCRUD?: boolean;
+      includeErrorCases?: boolean;
+    };
+  }): Promise<{
+    pack: string;  // YAML
+    summary: {
+      endpointsCount: number;
+      testsGenerated: number;
+      coverageEstimate: string;
+    };
+  }> {
+    // Analyser la spec
+    const spec = args.specContent
+      ? JSON.parse(args.specContent)
+      : await this.fetchSpec(args.specUrl);
+
+    // Extraire endpoints
+    const endpoints = this.extractEndpoints(spec);
+
+    // Générer les tests
+    const tests = this.generateTestsFromEndpoints(endpoints, args.options);
+
+    // Construire le pack YAML
+    const pack = this.buildPackYAML(tests);
+
+    return {
+      pack,
+      summary: {
+        endpointsCount: endpoints.length,
+        testsGenerated: tests.length,
+        coverageEstimate: this.estimateCoverage(tests, endpoints),
+      },
+    };
+  }
+
+  /**
+   * Génère des tests depuis une URL (crawling)
+   */
+  async generateFromCrawl(args: {
+    url: string;
+    maxDepth?: number;
+    maxPages?: number;
+    selectors?: {
+      login?: string;
+      forms?: string;
+      navigation?: string;
+    };
+  }): Promise<{
+    pack: string;
+    discoveredPages: PageInfo[];
+    userFlows: UserFlow[];
+  }> {
+    // Lancer le crawl avec Playwright
+    const crawler = new QACrawler({
+      maxDepth: args.maxDepth || 2,
+      maxPages: args.maxPages || 20,
+    });
+
+    const { pages, flows } = await crawler.crawl(args.url);
+
+    // Générer les tests E2E
+    const tests = this.generateE2ETests(pages, flows);
+
+    return {
+      pack: this.buildPackYAML(tests),
+      discoveredPages: pages,
+      userFlows: flows,
+    };
+  }
+
+  /**
+   * Suggère des tests depuis le code
+   */
+  async suggestTests(args: {
+    projectPath: string;
+    language?: string;
+    framework?: string;
+  }): Promise<{
+    suggestions: TestSuggestion[];
+    missingCoverage: CoverageGap[];
+  }> {
+    // Analyser le codebase
+    const analyzer = new CodeAnalyzer(args.projectPath);
+
+    // Trouver les fonctions sans tests
+    const untested = await analyzer.findUntestedFunctions();
+
+    // Suggérer des tests
+    const suggestions = untested.map(fn => ({
+      type: this.suggestTestType(fn),
+      description: this.suggestTestDescription(fn),
+      priority: this.calculatePriority(fn),
+      codeTemplate: this.generateTestTemplate(fn),
+    }));
+
+    return {
+      suggestions,
+      missingCoverage: await analyzer.getCoverageGaps(),
+    };
+  }
+}
+
+// packages/mcp/src/tools/enhanced/codebase-analyzer.ts
+export class CodebaseAnalysisTools {
+  /**
+   * Analyse le code pour trouver des patterns testables
+   */
+  async analyzeTestability(args: {
+    path: string;
+    includePatterns?: string[];
+    excludePatterns?: string[];
+  }): Promise<TestabilityReport> {
+    const analyzer = new TestabilityAnalyzer(args.path);
+
+    return {
+      functions: await analyzer.analyzeFunctions(),
+      apis: await analyzer.analyzeAPIs(),
+      components: await analyzer.analyzeComponents(),
+      testabilityScore: analyzer.calculateScore(),
+      recommendations: await analyzer.getRecommendations(),
+    };
+  }
+
+  /**
+   * Trouve les selectors fragiles
+   */
+  async findFragileSelectors(args: {
+    testPath: string;
+    codebasePath: string;
+  }): Promise<FragileSelector[]> {
+    const parser = new SelectorParser();
+    const validators = [
+      new ClassNameValidator(),
+      new TextContentValidator(),
+      new AttributeValidator(),
+    ];
+
+    const selectors = await parser.extractFromTestFiles(args.testPath);
+    const fragile: FragileSelector[] = [];
+
+    for (const selector of selectors) {
+      for (const validator of validators) {
+        if (!(await validator.validate(selector, args.codebasePath))) {
+          fragile.push({
+            selector: selector.value,
+            file: selector.file,
+            line: selector.line,
+            reason: validator.getReason(),
+            suggestion: validator.getSuggestion(),
+          });
+        }
+      }
+    }
+
+    return fragile;
+  }
+}
+
+// packages/mcp/src/tools/enhanced/smart-triage.ts
+export class SmartTriageTools {
+  /**
+   * Analyse un échec avec contexte étendu
+   */
+  async analyzeFailure(args: {
+    runId: string;
+    includeLogs?: boolean;
+    includeScreenshots?: boolean;
+    includeStackTrace?: boolean;
+  }): Promise<FailureAnalysis> {
+    const vault = new EvidenceVault();
+    const run = await vault.getRun(args.runId);
+
+    // Collecter le contexte
+    const context = await this.collectContext(run, args);
+
+    // Analyser avec heuristiques
+    const heuristics = this.runHeuristics(context);
+
+    return {
+      failure: {
+        gate: run.gate,
+        error: run.error,
+        timestamp: run.timestamp,
+      },
+      rootCause: heuristics.rootCause,
+      confidence: heuristics.confidence,
+      suggestedFixes: heuristics.fixes,
+      relatedRuns: await this.findRelatedRuns(run),
+      canAutoFix: heuristics.canAutoFix,
+    };
+  }
+
+  /**
+   * Génère un patch de correction
+   */
+  async generateFix(args: {
+    runId: string;
+    filePath: string;
+    approach?: 'safe' | 'aggressive';
+  }): Promise<FixPatch> {
+    const analysis = await this.analyzeFailure({ runId: args.runId });
+
+    if (!analysis.canAutoFix) {
+      throw new Error('Cannot auto-fix this failure');
+    }
+
+    const fixer = new TestFixer(args.approach || 'safe');
+    return await fixer.generatePatch(args.filePath, analysis);
+  }
+}
+
+// packages/mcp/src/tools/enhanced/collaboration.ts
+export class CollaborationTools {
+  /**
+   * Génère un rapport pour l'équipe
+   */
+  async generateTeamReport(args: {
+    runId: string;
+    format?: 'markdown' | 'html' | 'slack';
+    include?: {
+      screenshots?: boolean;
+      logs?: boolean;
+      recommendations?: boolean;
+    };
+  }): Promise<TeamReport> {
+    const vault = new EvidenceVault();
+    const run = await vault.getRun(args.runId);
+
+    const report = new ReportGenerator();
+
+    return await report.generate({
+      run,
+      format: args.format || 'markdown',
+      include: args.include,
+    });
+  }
+
+  /**
+   * Compare deux runs pour régression
+   */
+  async compareRuns(args: {
+    runA: string;
+    runB: string;
+    metrics?: string[];
+  }): Promise<RunComparison> {
+    const vault = new EvidenceVault();
+    const [runA, runB] = await Promise.all([
+      vault.getRun(args.runA),
+      vault.getRun(args.runB),
+    ]);
+
+    return {
+      summary: this.compareSummary(runA, runB),
+      gates: this.compareGates(runA, runB),
+      regressions: this.findRegressions(runA, runB),
+      improvements: this.findImprovements(runA, runB),
+    };
+  }
+}
+```
+
+#### 2. Outils d'Intégration Codebase
+
+```typescript
+// packages/mcp/src/tools/integration/git.ts
+export class GitIntegrationTools {
+  async getChangedFiles(args: {
+    branch?: string;
+    commit?: string;
+  }): Promise<ChangedFile[]> {
+    // Utiliser git simple ou isogit pour éviter les dépendances
+  }
+
+  async getCommitInfo(args: {
+    sha: string;
+  }): Promise<CommitInfo> {
+    // Info sur le commit pour contexte
+  }
+}
+
+// packages/mcp/src/tools/integration/ci.ts
+export class CIIntegrationTools {
+  async parseCIConfig(args: {
+    type: 'github' | 'gitlab' | 'jenkins';
+  }): Promise<CIConfig> {
+    // Parser les configs CI pour suggérer des intégrations
+  }
+
+  async generateCIStep(args: {
+    packPath: string;
+    ciType: 'github' | 'gitlab';
+  }): Promise<CIStep> {
+    // Générer la step CI pour QA360
+  }
+}
+```
+
+#### 3. Instructions Riches pour Agents
+
+```typescript
+// packages/mcp/src/server.ts - Enhanced
+const TOOL_INSTRUCTIONS = `
+You are interacting with QA360, a cryptographic QA orchestration platform.
+
+## Key Concepts
+
+1. **Packs**: Test definitions in YAML format defining multiple quality gates
+2. **Gates**: Individual test executions (api_smoke, ui, perf, sast, etc.)
+3. **Adapters**: Test execution engines (Playwright, K6, Semgrep, etc.)
+4. **Evidence Vault**: SQLite-based immutable audit trail
+5. **Proofs**: Ed25519 cryptographic signatures for verification
+
+## Available Tool Categories
+
+### Test Generation
+- qa360.generate.from_openapi: Generate tests from OpenAPI specs
+- qa360.generate.from_crawl: Generate E2E tests by crawling
+- qa360.generate.suggest: Suggest tests from code analysis
+
+### Test Execution
+- qa360.run: Execute a pack (requires permission)
+- qa360.history.*: Query past runs, compare, trends
+
+### Analysis & Triage
+- qa360.analyze.testability: Analyze code testability
+- qa360.triage.analyze: Deep failure analysis
+- qa360.triage.fix: Generate auto-fix patches
+
+### Collaboration
+- qa360.report.team: Generate team-friendly reports
+- qa360.compare.runs: Compare runs for regressions
+
+## Best Practices
+
+1. Always validate packs before running
+2. Use suggest_tests before generating to understand coverage
+3. Check historical trends before concluding on failures
+4. Use triage.analyze before attempting fixes
+5. Generate team reports for non-technical stakeholders
+
+## Example Workflows
+
+### For Test Generation:
+1. Call qa360.generate.suggest_tests to see what's missing
+2. Call qa360.generate.from_openapi for API tests
+3. Call qa360.pack.validate to verify the pack
+4. User can then run: qa360 run pack.yml
+
+### For Debugging:
+1. Call qa360.history.get to get run details
+2. Call qa360.triage.analyze for root cause
+3. Call qa360.compare.runs to check for regressions
+4. If auto-fixable, call qa360.triage.fix
+`;
+```
+
+#### 4. Enhanced Registry
+
+```typescript
+// packages/mcp/src/registry/enhanced.ts
+export class EnhancedToolRegistry {
+  private tools = new Map<string, Tool>();
+
+  constructor() {
+    // Existing tools (23)
+    this.registerExistingTools();
+
+    // NEW: Test Generation (3 tools)
+    this.register('qa360.generate.from_openapi', new GenerateFromOpenAPITool());
+    this.register('qa360.generate.from_crawl', new GenerateFromCrawlTool());
+    this.register('qa360.generate.suggest', new SuggestTestsTool());
+
+    // NEW: Codebase Analysis (2 tools)
+    this.register('qa360.analyze.testability', new TestabilityTool());
+    this.register('qa360.analyze.fragile_selectors', new FragileSelectorsTool());
+
+    // NEW: Enhanced Triage (2 tools)
+    this.register('qa360.triage.analyze', new AnalyzeFailureTool());
+    this.register('qa360.triage.fix', new GenerateFixTool());
+
+    // NEW: Collaboration (3 tools)
+    this.register('qa360.report.team', new TeamReportTool());
+    this.register('qa360.compare.runs', new CompareRunsTool());
+    this.register('qa360.ai.explain', new AIExplainTool());
+
+    // NEW: Integrations (2 tools)
+    this.register('qa360.git.changed_files', new GitChangedFilesTool());
+    this.register('qa360.ci.generate_step', new CIGenerateStepTool());
+  }
+
+  // Total: 23 existing + 12 new = 35 tools
+}
+```
+
+#### 5. Documentation MCP
+
+```markdown
+<!-- packages/mcp/README.md -->
+# QA360 MCP Server
+
+Enhanced MCP server with 35+ tools for AI-powered QA.
+
+## Quick Start for Agent Developers
+
+\`\`\`bash
+# Install QA360
+npm install -g qa360
+
+# Start MCP server
+qa360-mcp serve --allow-run
+
+# In Claude Desktop settings.json:
+\`\`\`json
+{
+  "mcpServers": {
+    "qa360": {
+      "command": "qa360-mcp",
+      "args": ["serve", "--allow-run"]
+    }
+  }
+}
+\`\`\`
+
+## Tool Categories
+
+### Generation (3 tools)
+- `qa360.generate.from_openapi` - Generate API tests from OpenAPI
+- `qa360.generate.from_crawl` - Generate E2E tests by crawling
+- `qa360.generate.suggest` - Suggest tests from code analysis
+
+### Analysis (2 tools)
+- `qa360.analyze.testability` - Analyze code testability
+- `qa360.analyze.fragile_selectors` - Find fragile selectors
+
+### Triage (2 tools)
+- `qa360.triage.analyze` - Deep failure analysis
+- `qa360.triage.fix` - Generate auto-fix patches
+
+### Collaboration (3 tools)
+- `qa360.report.team` - Generate team reports
+- `qa360.compare.runs` - Compare runs
+- `qa360.ai.explain` - Explain results in natural language
+
+## Example Agent Usage
+
+\`\`\`typescript
+// In your agent code
+const result = await mcp.callTool('qa360.generate.from_openapi', {
+  specUrl: 'https://api.example.com/openapi.json',
+  options: {
+    includeAuth: true,
+    includeCRUD: true
+  }
+});
+
+console.log(result.pack);  // YAML pack
+\`\`\`
+```
+
+### Avantages
+
+| Avantage | Description |
+|----------|-------------|
+| **Déjà implémenté** | MCP server existe déjà avec 23 outils |
+| **Compatibilité agents** | Fonctionne avec Goose, , Cursor, etc. |
+| **Pas de dépendance LLM** | QA360 ne gère pas les providers LLM |
+| **Extensibilité** | Facile d'ajouter de nouveaux outils |
+| **Maintenance réduite** | Agents externes gèrent leur logique AI |
+| **Standard ouvert** | MCP est un standard de l'industrie |
+| **Sécurité** | Permissions granulaires déjà en place |
+| **Audit trail** |
+| **Future-proof** | Nouveaux agents compatibles automatiquement |
+
+### Inconvénients
+
+| Inconvénient | Description |
+|--------------|-------------|
+| **Dépendance externe** | Nécessite un agent AI externe |
+| **Expérience fractionnée** | L'utilisateur doit utiliser 2 outils |
+| **Limité par l'agent** | Dépend des capacités de l'agent externe |
+| **Latence MCP** | Surcharge de communication |
+| **Moins de contrôle** | QA360 ne contrôle pas l'expérience AI |
+
+---
+
+## Comparaison Détaillée {#comparaison}
+
+### Tableau Comparatif
+
+| Dimension | Option 3 (LLM Direct) | Option 4 (MCP Enhanced) |
+|-----------|----------------------|-------------------------|
+| **Développement** | 4-6 semaines | 2-3 semaines |
+| **Maintenance** | Élevée (SDKs LLM) | Faible (outils MCP) |
+| **Contrôle** | Total | Partagé avec agents |
+| **Coût LLM** | QA360 le gère | Utilisateur le gère |
+| **Dépendances** | +3-5 packages | +0 packages |
+| **Offline** | Oui (Ollama) | Oui (si agent local) |
+| **Extensibilité** | Modérée | Élevée |
+| **Expérience UX** | Unifiée | Fractionnée |
+| **Standard** | Propriétaire | MCP (ouvert) |
+| **Future-proof** | Dépend adoption | Dépend écosystème MCP |
+
+### Matrice de Complexité
+
+```
+Complexité de développement
+
+Option 3 (LLM Direct):
+┌─────────────────────────────────────────────────────────────┐
+│ ████████████████████████████████████░░░░░░░░░░░░░░░░░░░░░  │ 70%
+│ - Provider abstraction                                      │
+│ - Multi-provider support                                   │
+│ - Test generation logic                                    │
+│ - Smart triage                                             │
+│ - Chat mode                                                │
+│ - Error handling                                           │
+│ - Cost optimization                                        │
+└─────────────────────────────────────────────────────────────┘
+
+Option 4 (MCP Enhanced):
+┌─────────────────────────────────────────────────────────────┐
+│ ████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  │ 40%
+│ - New tools (12)                                           │
+│ - Tool descriptions                                        │
+│ - Enhanced registry                                        │
+│ - Documentation                                            │
+│ - Testing                                                  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Analyse de Valeur
+
+```
+Valeur pour l'utilisateur
+
+Option 3 (LLM Direct):
+┌─────────────────────────────────────────────────────────────┐
+│ ██████████████████████████████████████████████████████████  │ 95%
+│ - One-stop shop                                           │
+│ - No AI setup needed                                       │
+│ - Works out of the box                                     │
+│ - Optimized for QA360                                      │
+└─────────────────────────────────────────────────────────────┘
+
+Option 4 (MCP Enhanced):
+┌─────────────────────────────────────────────────────────────┐
+│ ████████████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░  │ 70%
+│ - Requires external agent                                  │
+│ - More setup                                               │
+│ - But more flexible                                        │
+│ - Can use favorite agent                                   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Recommandation Stratégique {#recommandation}
+
+### Approche Hybride : Les Deux Options
+
+**Ne pas choisir. Combiner.**
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                      QA360 AI Strategy                                   │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                    Option 3: LLM Direct                            │ │
+│  │  Pour utilisateurs qui veulent une solution tout-en-un             │ │
+│  │                                                                      │ │
+│  │  Fonctions:                                                          │ │
+│  │  - qa360 generate --ai                                              │ │
+│  │  - qa360 triage --ai                                                │ │
+│  │  - qa360 chat                                                        │ │
+│  │                                                                      │ │
+│  │  Implémentation: Lite version                                        │ │
+│  │  - Un seul provider (configurable)                                  │ │
+│  │  - Fonctions essentielles seulement                                │ │
+│  │  - Coût maîtrisé                                                    │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+│                                    ↓                                    │
+│  ┌────────────────────────────────────────────────────────────────────┐ │
+│  │                    Option 4: MCP Enhanced                          │ │
+│  │  Pour utilisateurs avec leur propre agent AI                        │ │
+│  │                                                                      │ │
+│  │  Fonctions:                                                          │ │
+│  │  - 35+ outils MCP                                                   │ │
+│  │  - Documentation agent-first                                        │ │
+│  │  - Examples pour Goose,                                  │ │
+│  │                                                                      │ │
+│  │  Implémentation: Full enhancement                                   │ │
+│  │  - Tous les outils                                                  │ │
+│  │  - Instructions riches                                              │ │
+│  │  - Examples et templates                                            │ │
+│  └────────────────────────────────────────────────────────────────────┘ │
+│                                                                          │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+### Roadmap Phasée
+
+#### Phase 1 : MCP Enhancement (Mois 1-2)
+**Quick win, impact immédiat**
+
+- [ ] Ajouter 12 nouveaux outils MCP
+- [ ] Documenter les outils pour agents
+- [ ] Créer examples pour Goose, 
+- [ ] Publier article sur intégration
+
+**Livraison** : QA360 MCP Server v2 avec 35 outils
+
+#### Phase 2 : LLM Lite Integration (Mois 3-4)
+**Fonctions essentielles pour utilisateurs sans agent**
+
+- [ ] Abstraction LLM simple
+- [ ] Support OpenAI + Anthropic
+- [ ] Commande `qa360 generate --ai`
+- [ ] Configuration simple
+
+**Livraison** : QA360 CLI avec AI basique
+
+#### Phase 3 : Enhanced AI (Mois 5-6)
+**Fonctions avancées**
+
+- [ ] Smart triage avec AI
+- [ ] Auto-fix basique
+- [ ] Support Ollama (local)
+- [ ] Optimisation coût
+
+**Livraison** : QA360 AI complet
+
+#### Phase 4 : Ecosystem (Mois 7+)
+**Intégrations et communauté**
+
+- [ ] Plugins communauté
+- [ ] Templates par industrie
+- [ ] Intégrations CI/CD
+- [ ] Dashboard web
+
+### Configuration Finale Proposée
+
+```yaml
+# .qa360/config.yml
+ai:
+  mode: hybrid  # | mcp-only | embedded-only
+
+  embedded:
+    provider: openai  # | anthropic | ollama
+    model: gpt-4o
+    fallback: anthropic
+
+    features:
+      test_generation: true
+      smart_triage: true
+      auto_fix: true
+
+    cost_optimization:
+      use_cheap_model_for_summaries: true
+      max_tokens_per_request: 8000
+
+  mcp:
+    enabled: true
+    enhanced_tools: true
+    agent_instructions: true
+
+    tools:
+      generation: true
+      analysis: true
+      triage: true
+      collaboration: true
+
+# L'utilisateur choisit son mode
+# - "embedded" : QA360 gère l'IA
+# - "mcp" : Utilise son agent préféré
+# - "hybrid" : Les deux disponibles
+```
+
+### Conclusion
+
+**L'approche hybride est la meilleure stratégie pour QA360 :**
+
+1. **MCP Enhanced** = S'assurer que QA360 est compatible avec tous les agents
+2. **LLM Lite** = Pour les utilisateurs qui veulent du "tout-en-un"
+3. **Hybrid** = Flexibilité maximale pour tous les cas d'usage
+
+**Cela permet à QA360 de :**
+- Être indispensable avec des agents externes
+- Être autonome pour ceux qui veulent simplicité
+- Resté agnostic face aux évolutions du marché IA
+- Capturer les deux segments d'utilisateurs
+
+---
+
+## Sources
+
+### Option 3 Sources
+- [multi-llm-ts GitHub](https://github.com/nbonamy/multi-llm-ts) - Multi-provider LLM abstraction
+- [OpenAI Agents SDK TypeScript](https://techwithibrahim.medium.com/getting-started-with-openais-agents-sdk-for-typescript-6b551c42e1ae)
+- [LangChain 1.0 Best Practices](https://skywork.ai/blog/ai-agent/best-practices-langchain-1-0-production-ready-llm-apps/)
+- [Building AI Agents with TypeScript](https://medium.com/@vishwajeety14122/building-ai-agents-with-javascript-typescript-your-complete-guide-7cf969e7d85b)
+
+### Option 4 Sources
+- [MCP TS Simple Template](https://github.com/ChenReuven/mcp-ts-simple-template)
+- [Building a TypeScript MCP Server - Medium](https://medium.com/@jageenshukla/building-a-typescript-mcp-server-a-guide-for-integrating-existing-services-5bde3fc13b23)
+- [How to Build an MCP Server in TypeScript - DEV.to](https://dev.to/shayy/how-to-build-an-mcp-server-in-typescript-4kp5)
+- [Build an MCP Server - Official Docs](https://modelcontextprotocol.io/docs/develop/build-server)
+- [MCP Server TypeScript Azure Guide](https://learn.microsoft.com/en-us/azure/developer/ai/build-mcp-server-ts)