@boostecom/provider 0.0.1

package/docs/content/examples.mdx

@@ -0,0 +1,675 @@
+---
+title: Exemples pratiques
+description: Exemples concrets pour intégrer Claude Code dans vos applications
+---
+
+# Exemples pratiques
+
+Cette page présente des exemples concrets d'intégration du provider Claude Code dans différents types d'applications.
+
+## Applications web
+
+### API REST avec Express
+
+Créez une API REST qui utilise Claude pour générer du contenu :
+
+```typescript title="server.ts"
+import express from 'express';
+import { generateText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const app = express();
+app.use(express.json());
+
+// Endpoint pour génération de texte
+app.post('/api/generate', async (req, res) => {
+  try {
+    const { prompt, model = 'haiku' } = req.body;
+
+    if (!prompt) {
+      return res.status(400).json({ error: 'Prompt requis' });
+    }
+
+    const { text, usage } = await generateText({
+      model: claudeCode(model),
+      prompt,
+    });
+
+    res.json({
+      text,
+      usage,
+      model,
+    });
+  } catch (error: any) {
+    console.error('Erreur:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Endpoint pour génération d'objets structurés
+app.post('/api/extract', async (req, res) => {
+  try {
+    const { text } = req.body;
+
+    const { object } = await generateObject({
+      model: claudeCode('sonnet'),
+      schema: z.object({
+        nom: z.string(),
+        email: z.string().describe('Email (ex: user@example.com)'),
+        sujet: z.string(),
+        sentiment: z.enum(['positif', 'neutre', 'negatif']),
+      }),
+      prompt: `Extrait les informations de contact de ce texte: ${text}`,
+    });
+
+    res.json({ data: object });
+  } catch (error: any) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.listen(3000, () => {
+  console.log('🚀 Serveur démarré sur http://localhost:3000');
+});
+```
+
+### API avec streaming SSE (Server-Sent Events)
+
+Diffusez les réponses en temps réel vers le client :
+
+```typescript title="server.ts"
+import express from 'express';
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const app = express();
+app.use(express.json());
+
+app.post('/api/stream', async (req, res) => {
+  const { prompt } = req.body;
+
+  // Configurer SSE
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+
+  try {
+    const result = streamText({
+      model: claudeCode('sonnet'),
+      prompt,
+    });
+
+    for await (const chunk of result.textStream) {
+      // Envoyer chaque fragment au client
+      res.write(`data: ${JSON.stringify({ text: chunk })}\n\n`);
+    }
+
+    res.write('data: [DONE]\n\n');
+    res.end();
+  } catch (error: any) {
+    res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
+    res.end();
+  }
+});
+
+app.listen(3000);
+```
+
+```typescript title="client.ts"
+// Côté client
+async function streamFromAPI(prompt: string) {
+  const response = await fetch('http://localhost:3000/api/stream', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ prompt }),
+  });
+
+  const reader = response.body?.getReader();
+  const decoder = new TextDecoder();
+
+  while (true) {
+    const { done, value } = await reader!.read();
+    if (done) break;
+
+    const chunk = decoder.decode(value);
+    const lines = chunk.split('\n');
+
+    for (const line of lines) {
+      if (line.startsWith('data: ')) {
+        const data = line.slice(6);
+        if (data === '[DONE]') return;
+
+        const parsed = JSON.parse(data);
+        process.stdout.write(parsed.text);
+      }
+    }
+  }
+}
+
+streamFromAPI('Raconte une histoire courte');
+```
+
+### Next.js App Router
+
+Intégration avec Next.js 13+ et le App Router :
+
+```typescript title="app/api/chat/route.ts"
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import type { CoreMessage } from 'ai';
+
+export const runtime = 'nodejs'; // Important pour le CLI
+
+export async function POST(req: Request) {
+  try {
+    const { messages }: { messages: CoreMessage[] } = await req.json();
+
+    const result = streamText({
+      model: claudeCode('sonnet'),
+      messages,
+    });
+
+    // Retourner le stream AI SDK (compatible avec useChat)
+    return result.toDataStreamResponse();
+  } catch (error: any) {
+    return new Response(JSON.stringify({ error: error.message }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+}
+```
+
+```typescript title="app/chat/page.tsx"
+'use client';
+
+import { useChat } from 'ai/react';
+
+export default function ChatPage() {
+  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
+    api: '/api/chat',
+  });
+
+  return (
+    <div className="flex flex-col h-screen max-w-2xl mx-auto p-4">
+      <div className="flex-1 overflow-y-auto space-y-4 mb-4">
+        {messages.map((message) => (
+          <div
+            key={message.id}
+            className={`p-4 rounded-lg ${
+              message.role === 'user' 
+                ? 'bg-blue-100 ml-auto' 
+                : 'bg-gray-100'
+            }`}
+          >
+            <div className="font-bold mb-1">
+              {message.role === 'user' ? 'Vous' : 'Claude'}
+            </div>
+            <div>{message.content}</div>
+          </div>
+        ))}
+        {isLoading && (
+          <div className="bg-gray-100 p-4 rounded-lg">
+            <div className="animate-pulse">Claude réfléchit...</div>
+          </div>
+        )}
+      </div>
+
+      <form onSubmit={handleSubmit} className="flex gap-2">
+        <input
+          value={input}
+          onChange={handleInputChange}
+          placeholder="Tapez votre message..."
+          className="flex-1 p-2 border rounded"
+          disabled={isLoading}
+        />
+        <button
+          type="submit"
+          disabled={isLoading}
+          className="px-4 py-2 bg-blue-500 text-white rounded disabled:bg-gray-300"
+        >
+          Envoyer
+        </button>
+      </form>
+    </div>
+  );
+}
+```
+
+## Outils et scripts
+
+### Analyseur de code
+
+Script pour analyser et améliorer du code :
+
+```typescript title="code-analyzer.ts"
+import { generateObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+
+async function analyzeCode(filePath: string) {
+  const code = readFileSync(filePath, 'utf-8');
+
+  const { object } = await generateObject({
+    model: claudeCode('opus', {
+      allowedTools: ['Read'], // Permettre la lecture
+    }),
+    schema: z.object({
+      qualite: z.number().min(0).max(10).describe('Score de qualité sur 10'),
+      problemes: z.array(z.object({
+        ligne: z.number().optional(),
+        severite: z.enum(['faible', 'moyen', 'critique']),
+        description: z.string(),
+      })),
+      suggestions: z.array(z.string()),
+      refactoring: z.string().optional().describe('Code refactorisé si nécessaire'),
+    }),
+    prompt: `Analyse ce code et donne des suggestions d'amélioration:\n\n${code}`,
+  });
+
+  return object;
+}
+
+// Utilisation
+const analysis = await analyzeCode('./src/index.ts');
+
+console.log(`📊 Qualité: ${analysis.qualite}/10\n`);
+
+if (analysis.problemes.length > 0) {
+  console.log('⚠️ Problèmes détectés:');
+  analysis.problemes.forEach((p, i) => {
+    console.log(`  ${i + 1}. [${p.severite}] ${p.description}`);
+  });
+  console.log();
+}
+
+if (analysis.suggestions.length > 0) {
+  console.log('💡 Suggestions:');
+  analysis.suggestions.forEach((s, i) => {
+    console.log(`  ${i + 1}. ${s}`);
+  });
+}
+
+if (analysis.refactoring) {
+  console.log('\n✨ Code refactorisé proposé:');
+  console.log(analysis.refactoring);
+}
+```
+
+### Générateur de documentation
+
+Générez automatiquement de la documentation depuis votre code :
+
+```typescript title="doc-generator.ts"
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { readFileSync, writeFileSync } from 'fs';
+import { glob } from 'glob';
+
+async function generateDocs(pattern: string) {
+  const files = await glob(pattern);
+
+  for (const file of files) {
+    console.log(`📝 Génération de la doc pour ${file}...`);
+
+    const code = readFileSync(file, 'utf-8');
+
+    const result = streamText({
+      model: claudeCode('sonnet', {
+        allowedTools: ['Read'],
+      }),
+      prompt: `Génère une documentation détaillée en Markdown pour ce code.
+Include:
+- Description générale
+- Paramètres et types
+- Valeurs de retour
+- Exemples d'utilisation
+- Notes importantes
+
+Code:
+${code}`,
+    });
+
+    let doc = '';
+    for await (const chunk of result.textStream) {
+      doc += chunk;
+    }
+
+    // Sauvegarder la documentation
+    const docFile = file.replace(/\.(ts|js)$/, '.md');
+    writeFileSync(docFile, doc);
+
+    console.log(`✅ Documentation sauvegardée dans ${docFile}\n`);
+  }
+}
+
+// Générer la doc pour tous les fichiers TypeScript
+generateDocs('src/**/*.ts');
+```
+
+### Assistant CLI interactif
+
+Créez un assistant en ligne de commande :
+
+```typescript title="cli-assistant.ts"
+#!/usr/bin/env node
+
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import * as readline from 'readline';
+import type { CoreMessage } from 'ai';
+import chalk from 'chalk';
+
+const messages: CoreMessage[] = [];
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+async function chat() {
+  rl.question(chalk.blue('Vous: '), async (userInput) => {
+    if (userInput.toLowerCase() === 'exit') {
+      console.log(chalk.green('\n👋 Au revoir!'));
+      rl.close();
+      return;
+    }
+
+    if (userInput.toLowerCase() === 'clear') {
+      messages.length = 0;
+      console.log(chalk.yellow('🗑️  Historique effacé\n'));
+      chat();
+      return;
+    }
+
+    messages.push({ role: 'user', content: userInput });
+
+    const result = streamText({
+      model: claudeCode('sonnet', {
+        systemPrompt: 'Tu es un assistant de développement en ligne de commande. ' +
+                     'Aide l\'utilisateur avec ses questions de programmation.',
+        allowedTools: ['Read', 'LS', 'Bash(git:*)'],
+        verbose: false,
+      }),
+      messages,
+    });
+
+    process.stdout.write(chalk.green('Claude: '));
+
+    let assistantResponse = '';
+    for await (const chunk of result.textStream) {
+      process.stdout.write(chunk);
+      assistantResponse += chunk;
+    }
+
+    console.log('\n');
+    messages.push({ role: 'assistant', content: assistantResponse });
+
+    chat();
+  });
+}
+
+console.log(chalk.bold('\n🤖 Assistant CLI Claude Code'));
+console.log(chalk.dim('Commandes: exit (quitter), clear (effacer historique)\n'));
+
+chat();
+```
+
+```bash
+# Rendre le script exécutable
+chmod +x cli-assistant.ts
+
+# Lancer l'assistant
+./cli-assistant.ts
+```
+
+## Traitement par lots
+
+### Traduction de fichiers en masse
+
+```typescript title="batch-translator.ts"
+import { generateObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+import { readFileSync, writeFileSync } from 'fs';
+import { glob } from 'glob';
+import { parse } from 'path';
+
+async function translateFiles(pattern: string, targetLang: string) {
+  const files = await glob(pattern);
+
+  for (const file of files) {
+    console.log(`🌐 Traduction de ${file} vers ${targetLang}...`);
+
+    const content = readFileSync(file, 'utf-8');
+    const json = JSON.parse(content);
+
+    const { object } = await generateObject({
+      model: claudeCode('sonnet'),
+      schema: z.record(z.string()),
+      prompt: `Traduis toutes les valeurs de cet objet JSON en ${targetLang}.
+Garde les clés identiques, traduis seulement les valeurs.
+
+JSON à traduire:
+${JSON.stringify(json, null, 2)}`,
+    });
+
+    // Sauvegarder la traduction
+    const { dir, name } = parse(file);
+    const outputFile = `${dir}/${name}.${targetLang}.json`;
+    writeFileSync(outputFile, JSON.stringify(object, null, 2));
+
+    console.log(`✅ Sauvegardé dans ${outputFile}\n`);
+  }
+}
+
+// Traduire tous les fichiers i18n en espagnol
+translateFiles('i18n/en/**/*.json', 'es');
+```
+
+### Extraction de données en masse
+
+```typescript title="batch-extractor.ts"
+import { generateObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+
+const productSchema = z.object({
+  nom: z.string(),
+  prix: z.number().describe('Prix en euros'),
+  description: z.string(),
+  caracteristiques: z.array(z.string()),
+  categorie: z.enum(['electronique', 'vetements', 'maison', 'autre']),
+});
+
+async function extractProducts(htmlPages: string[]) {
+  const products = [];
+
+  for (const html of htmlPages) {
+    console.log('🔍 Extraction des données...');
+
+    const { object } = await generateObject({
+      model: claudeCode('haiku'), // Haiku pour rapidité et coût
+      schema: productSchema,
+      prompt: `Extrait les informations produit de ce HTML:\n\n${html}`,
+    });
+
+    products.push(object);
+  }
+
+  return products;
+}
+
+// Exemple d'utilisation
+const htmlPages = [
+  '<html>...</html>',
+  '<html>...</html>',
+];
+
+const products = await extractProducts(htmlPages);
+console.log('✅ Produits extraits:', products);
+```
+
+## Intégration avec bases de données
+
+### Génération de requêtes SQL
+
+```typescript title="sql-generator.ts"
+import { generateObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+
+const schema = z.object({
+  query: z.string().describe('Requête SQL'),
+  explication: z.string(),
+  parametres: z.array(z.object({
+    nom: z.string(),
+    type: z.string(),
+    description: z.string(),
+  })).optional(),
+});
+
+async function generateSQL(naturalLanguage: string, dbSchema: string) {
+  const { object } = await generateObject({
+    model: claudeCode('opus'),
+    schema,
+    prompt: `Génère une requête SQL pour: "${naturalLanguage}"
+
+Schéma de la base de données:
+${dbSchema}
+
+Utilise des paramètres préparés pour éviter les injections SQL.`,
+  });
+
+  return object;
+}
+
+// Exemple
+const dbSchema = `
+CREATE TABLE users (
+  id INT PRIMARY KEY,
+  name VARCHAR(255),
+  email VARCHAR(255),
+  created_at TIMESTAMP
+);
+
+CREATE TABLE orders (
+  id INT PRIMARY KEY,
+  user_id INT REFERENCES users(id),
+  amount DECIMAL(10, 2),
+  status VARCHAR(50)
+);
+`;
+
+const result = await generateSQL(
+  'Trouve tous les utilisateurs qui ont commandé plus de 100€ ce mois',
+  dbSchema
+);
+
+console.log('📝 Requête:', result.query);
+console.log('💡 Explication:', result.explication);
+if (result.parametres) {
+  console.log('⚙️  Paramètres:', result.parametres);
+}
+```
+
+### Analyse de logs avec stockage
+
+```typescript title="log-analyzer.ts"
+import { generateObject } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+import { z } from 'zod';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+const logAnalysisSchema = z.object({
+  niveau: z.enum(['info', 'warning', 'error', 'critical']),
+  resume: z.string(),
+  cause_probable: z.string().optional(),
+  action_recommandee: z.string().optional(),
+  tags: z.array(z.string()),
+});
+
+async function analyzeAndStoreLogs(logLines: string[]) {
+  for (const line of logLines) {
+    const { object } = await generateObject({
+      model: claudeCode('haiku'),
+      schema: logAnalysisSchema,
+      prompt: `Analyse cette ligne de log et extrais les informations:\n${line}`,
+    });
+
+    // Stocker en base de données
+    await prisma.logAnalysis.create({
+      data: {
+        originalLog: line,
+        niveau: object.niveau,
+        resume: object.resume,
+        causeProbable: object.cause_probable,
+        actionRecommandee: object.action_recommandee,
+        tags: object.tags,
+        analyzedAt: new Date(),
+      },
+    });
+  }
+
+  console.log(`✅ ${logLines.length} logs analysés et stockés`);
+}
+
+// Exemple
+const logs = [
+  '[2025-02-07 10:23:45] ERROR: Database connection timeout after 30s',
+  '[2025-02-07 10:24:12] WARNING: High memory usage: 92%',
+];
+
+await analyzeAndStoreLogs(logs);
+```
+
+## Intégration avec services tiers
+
+### Slack Bot
+
+```typescript title="slack-bot.ts"
+import { App } from '@slack/bolt';
+import { streamText } from 'ai';
+import { claudeCode } from '@boostecom/provider';
+
+const app = new App({
+  token: process.env.SLACK_BOT_TOKEN,
+  signingSecret: process.env.SLACK_SIGNING_SECRET,
+});
+
+app.message(async ({ message, say }) => {
+  if (message.subtype || !('text' in message)) return;
+
+  const userMessage = message.text;
+
+  // Ignorer les messages sans mention du bot
+  if (!userMessage.includes('<@BOT_USER_ID>')) return;
+
+  try {
+    const result = streamText({
+      model: claudeCode('sonnet'),
+      prompt: userMessage,
+    });
+
+    let response = '';
+    for await (const chunk of result.textStream) {
+      response += chunk;
+    }
+
+    await say(response);
+  } catch (error) {
+    await say('Désolé, une erreur est survenue.');
+  }
+});
+
+await app.start(process.env.PORT || 3000);
+console.log('⚡️ Slack bot démarré');
+```
+
+## Prochaines étapes
+
+- [Skills](/docs/skills) - Créer des compétences personnalisées
+- [Agent Teams](/docs/agent-teams) - Créer des équipes d'agents spécialisés
+- [Best Practices](/docs/best-practices) - Conseils et optimisations