qa360 2.2.1 → 2.2.7

package/docs/OPTION_3_4_EXPLORATION.md

@@ -1,1257 +0,0 @@
-# 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)