smart-spec-kit-mcp 2.0.0 → 2.0.2

package/README.md

@@ -1,32 +1,27 @@
 # 🚀 Spec-Kit MCP Server
 
-Plateforme d'orchestration automatisée pour transformer vos work items Azure DevOps en spécifications complètes via **GitHub Copilot**.
+[![npm version](https://img.shields.io/npm/v/smart-spec-kit-mcp.svg)](https://www.npmjs.com/package/smart-spec-kit-mcp)
+[![CI/CD](https://github.com/anthropic-ai/smart-spec-kit/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/anthropic-ai/smart-spec-kit/actions/workflows/ci-cd.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Plateforme d'orchestration automatisée pour le **développement piloté par les spécifications** (Spec-Driven Development) via **GitHub Copilot** et **MCP** (Model Context Protocol).
 
 ## ✨ Fonctionnalités
 
-- **🤖 Orchestration Automatisée**: Un seul prompt, Copilot fait le reste
+- **📝 Slash Commands**: Commandes intégrées à VS Code Copilot (`/speckit.specify`, `/speckit.plan`, etc.)
+- **🤖 Orchestration Automatisée**: Workflows guidés pour créer des spécifications complètes
 - **🔄 Workflows YAML**: Processus personnalisables étape par étape
-- **🛡️ Gouvernance Intégrée**: RGPD, Sécurité, Architecture, Design System
-- **📝 Templates**: Spécifications, bugfix reports, documentation
+- **📋 Templates**: Spécifications fonctionnelles, plans d'implémentation, rapports de bugs
+- **🛡️ Gouvernance Intégrée**: Constitution projet, principes de développement
 - **🔗 Azure DevOps**: Intégration native via MCP
 
 ---
 
-## ⚡ Installation Express
-
-### Via Slash Command (Recommandé)
-
-Dans **GitHub Copilot Chat**:
-
-```text
-/setupSpecKit
-```
-
-L'assistant configure tout automatiquement selon votre environnement.
+## ⚡ Installation Rapide
 
-### Via NPX (Zero Config)
+### 1. Configurer VS Code
 
-Ajoutez dans VS Code `settings.json`:
+Ajoutez dans `.vscode/settings.json` (créez le fichier si nécessaire):
 
 ```json
 {
@@ -34,159 +29,104 @@ Ajoutez dans VS Code `settings.json`:
     "servers": {
       "spec-kit": {
         "command": "npx",
-        "args": ["-y", "spec-kit-mcp"]
+        "args": ["-y", "smart-spec-kit-mcp"]
       }
     }
   }
 }
 ```
 
-Rechargez VS Code (`Ctrl+Shift+P` → "Developer: Reload Window").
+### 2. Recharger VS Code
 
-### Installation Locale
+`Ctrl+Shift+P` → "Developer: Reload Window"
 
-```bash
-git clone https://github.com/your-org/spec-kit-mcp.git
-cd spec-kit-mcp
-npm install
-npm run build
-```
+### 3. Initialiser le Projet
 
-```json
-{
-  "mcp": {
-    "servers": {
-      "spec-kit": {
-        "command": "node",
-        "args": ["/path/to/spec-kit-mcp/dist/index.js"]
-      }
-    }
-  }
-}
+Dans Copilot Chat, utilisez l'outil MCP `init` ou demandez:
 ```
-
----
-
-## 🚀 Usage
-
-### Démarrer un Workflow
-
-```text
-@spec-kit start_workflow workflow_name="feature-standard" context_id="12345"
+Initialise Spec-Kit dans ce projet
 ```
 
-Le serveur orchestre automatiquement:
+Cela crée:
+```
+votre-projet/
+├── .github/
+│   └── prompts/              # Slash commands pour Copilot
+│       ├── speckit.init.md
+│       ├── speckit.specify.md
+│       ├── speckit.clarify.md
+│       ├── speckit.plan.md
+│       ├── speckit.tasks.md
+│       └── speckit.implement.md
+├── .spec-kit/
+│   ├── templates/            # Templates de spécifications
+│   └── memory/               # Contexte projet
+│       └── constitution.md   # Principes du projet
+└── specs/                    # Spécifications générées
+```
 
-1. Récupération du work item Azure DevOps
-2. Génération de la spécification (SpecAgent)
-3. Planification technique (PlanAgent)
-4. Validation gouvernance (GovAgent)
-5. Création des artefacts
+---
 
-> Validez chaque étape avec "OK" - c'est tout!
+## 🎮 Slash Commands
 
-### Workflows Disponibles
+Une fois installé, utilisez ces commandes dans Copilot Chat:
 
-| Workflow           | Description                              |
-| ------------------ | ---------------------------------------- |
-| `feature-standard` | Spécification fonctionnelle (5 étapes)   |
-| `feature-full`     | Spec + gouvernance complète (10 étapes)  |
-| `bugfix`           | Rapport de correction de bug (5 étapes)  |
+| Commande | Description |
+|----------|-------------|
+| `/speckit.init` | Initialise Spec-Kit dans le projet |
+| `/speckit.specify` | Crée une spécification à partir des requirements |
+| `/speckit.clarify` | Clarifie les zones ambiguës de la spec |
+| `/speckit.plan` | Crée un plan d'implémentation technique |
+| `/speckit.tasks` | Génère la liste des tâches à implémenter |
+| `/speckit.implement` | Exécute les tâches d'implémentation |
 
 ---
 
-## 🛠 MCP Tools
+## 🚀 Workflow Recommandé
 
-### Orchestration
+### 1. Établir les principes du projet
 
-| Tool              | Description                     |
-| ----------------- | ------------------------------- |
-| `start_workflow`  | Démarre un workflow automatisé  |
-| `execute_step`    | Continue à l'étape suivante     |
-| `workflow_status` | Statut de la session active     |
-| `list_workflows`  | Liste les workflows disponibles |
-| `abort_workflow`  | Annule le workflow en cours     |
+Éditez `.spec-kit/memory/constitution.md` avec vos principes de développement.
 
-### Utilitaires
+### 2. Créer une spécification
 
-| Tool   | Description             |
-| ------ | ----------------------- |
-| `ping` | Health check du serveur |
-| `help` | Aide et documentation   |
+```
+/speckit.specify Build a user authentication feature with email/password login
+```
 
----
+### 3. Créer le plan technique
 
-## 🤖 Agents IA
+```
+/speckit.plan Use TypeScript, Express.js, PostgreSQL, and JWT for authentication
+```
 
-| Agent        | Rôle          | Utilisation                      |
-| ------------ | ------------- | -------------------------------- |
-| **SpecAgent**| Rédacteur     | Spécifications fonctionnelles    |
-| **PlanAgent**| Planificateur | Découpage en tâches techniques   |
-| **GovAgent** | Validateur    | Conformité RGPD, Sécurité, Archi |
-| **TestAgent**| Testeur       | Stratégies et cas de tests       |
+### 4. Générer les tâches
 
----
+```
+/speckit.tasks
+```
 
-## 📁 Structure du Projet
-
-```text
-spec-kit-mcp/
-├── src/
-│   ├── index.ts                 # Entrypoint MCP Server
-│   ├── engine/
-│   │   ├── sessionManager.ts    # Gestion des sessions
-│   │   └── workflowEngine.ts    # Moteur d'orchestration
-│   ├── tools/
-│   │   └── orchestrationTools.ts # Tools MCP
-│   ├── prompts/
-│   │   └── agents.ts            # System prompts des agents
-│   ├── schemas/
-│   │   └── workflowSchema.ts    # Validation Zod
-│   └── utils/
-│       ├── workflowLoader.ts    # Chargeur YAML
-│       └── markdownGenerator.ts # Générateur de templates
-├── workflows/                   # Définitions YAML
-│   ├── feature-standard.yaml
-│   ├── feature-full.yaml
-│   └── bugfix.yaml
-├── templates/                   # Templates Markdown
-│   ├── functional-spec.md
-│   └── bugfix-report.md
-└── .github/
-    └── copilot/
-        └── setupSpecKit.md      # Slash command setup
+### 5. Implémenter
+
+```
+/speckit.implement
 ```
 
 ---
 
-## 🔗 Intégration Azure DevOps
+## 🔧 Personnalisation
 
-Pour activer l'intégration ADO, ajoutez le serveur MCP Azure DevOps:
+### Templates
 
-```json
-{
-  "mcp": {
-    "servers": {
-      "spec-kit": {
-        "command": "npx",
-        "args": ["-y", "spec-kit-mcp"]
-      },
-      "azure-devops": {
-        "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-azure-devops"],
-        "env": {
-          "AZURE_DEVOPS_ORG_URL": "https://dev.azure.com/your-org",
-          "AZURE_DEVOPS_PAT": "your-personal-access-token"
-        }
-      }
-    }
-  }
-}
-```
+Personnalisez les templates dans `.spec-kit/templates/`:
+- `functional-spec.md` - Spécification fonctionnelle
+- `plan-template.md` - Plan d'implémentation
+- `tasks-template.md` - Liste des tâches
+- `bugfix-report.md` - Rapport de correction
 
----
+### Workflows (Avancé)
 
-## 📐 Créer un Workflow Custom
+Créez des workflows personnalisés dans `.spec-kit/workflows/`:
 
 ```yaml
 name: mon-workflow
@@ -208,55 +148,57 @@ steps:
     description: "Génère le contenu"
 ```
 
-**Actions disponibles**: `fetch_ado`, `generate_content`, `call_agent`, `review`, `create_file`
-
 ---
 
-## 🧪 Développement
+## 🔗 Intégration Azure DevOps
 
-```bash
-npm run build    # Compile TypeScript
-npm run dev      # Watch mode
-npm run start    # Lance le serveur
+Pour utiliser avec Azure DevOps:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "spec-kit": {
+        "command": "npx",
+        "args": ["-y", "smart-spec-kit-mcp"]
+      },
+      "azure-devops": {
+        "command": "npx",
+        "args": ["-y", "@anthropic-ai/azure-devops-mcp"],
+        "env": {
+          "AZURE_DEVOPS_ORG_URL": "https://dev.azure.com/your-org",
+          "AZURE_DEVOPS_PAT": "your-token"
+        }
+      }
+    }
+  }
+}
 ```
 
 ---
 
-## � Personnalisation
-
-### Initialiser la config locale
+## 🤖 Agents IA
 
-```text
-@spec-kit init
-```
+| Agent | Rôle | Utilisation |
+|-------|------|-------------|
+| **SpecAgent** | Rédacteur | Spécifications fonctionnelles |
+| **PlanAgent** | Planificateur | Découpage en tâches techniques |
+| **GovAgent** | Validateur | Conformité RGPD, Sécurité, Archi |
+| **TestAgent** | Testeur | Stratégies et cas de tests |
 
-Crée `.spec-kit/` avec des workflows et templates personnalisables.
+---
 
-### Voir la configuration
+## 🧪 Développement
 
-```text
-@spec-kit config
+```bash
+git clone https://github.com/anthropic-ai/smart-spec-kit.git
+cd smart-spec-kit
+npm install
+npm run build
 ```
 
-Affiche les chemins de recherche et workflows disponibles (locaux vs package).
-
-### Ordre de résolution
-
-1. **Local**: `.spec-kit/workflows/` et `.spec-kit/templates/`
-2. **Package**: Workflows par défaut (feature-standard, bugfix, etc.)
-
-> 📖 Voir [docs/PACKAGING.md](docs/PACKAGING.md) pour le guide complet de personnalisation.
-
 ---
 
-## �📄 License
+## 📄 License
 
 MIT
-
----
-
-## 🙏 Technologies
-
-- [@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/sdk) - MCP Framework
-- [Zod](https://zod.dev) - Schema Validation
-- [js-yaml](https://github.com/nodeca/js-yaml) - YAML Parser

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Spec-Kit Setup CLI
+ *
+ * Automatise l'installation de Spec-Kit sur une machine de développement:
+ * - Copie les slash commands (prompts) dans le projet
+ * - Configure VS Code settings.json
+ * - Affiche les instructions
+ *
+ * Usage: npx smart-spec-kit-mcp setup [options]
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;GASG"}

package/dist/cli.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+/**
+ * Spec-Kit Setup CLI
+ *
+ * Automatise l'installation de Spec-Kit sur une machine de développement:
+ * - Copie les slash commands (prompts) dans le projet
+ * - Configure VS Code settings.json
+ * - Affiche les instructions
+ *
+ * Usage: npx smart-spec-kit-mcp setup [options]
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+// Couleurs pour le terminal
+const colors = {
+    reset: "\x1b[0m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    cyan: "\x1b[36m",
+    red: "\x1b[31m",
+    bold: "\x1b[1m",
+};
+function log(message, color = colors.reset) {
+    console.log(`${color}${message}${colors.reset}`);
+}
+function logStep(step, message) {
+    console.log(`\n${colors.cyan}[${step}/4]${colors.reset} ${colors.bold}${message}${colors.reset}`);
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+async function copyDir(src, dest) {
+    await ensureDir(dest);
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    let count = 0;
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            count += await copyDir(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+            count++;
+        }
+    }
+    return count;
+}
+async function getVSCodeSettingsPath() {
+    const platform = os.platform();
+    let settingsPath;
+    if (platform === "win32") {
+        settingsPath = path.join(os.homedir(), "AppData", "Roaming", "Code", "User", "settings.json");
+    }
+    else if (platform === "darwin") {
+        settingsPath = path.join(os.homedir(), "Library", "Application Support", "Code", "User", "settings.json");
+    }
+    else {
+        settingsPath = path.join(os.homedir(), ".config", "Code", "User", "settings.json");
+    }
+    // Check for VS Code Insiders
+    if (!(await fileExists(settingsPath))) {
+        const insidersPath = settingsPath.replace("Code", "Code - Insiders");
+        if (await fileExists(insidersPath)) {
+            return insidersPath;
+        }
+    }
+    return settingsPath;
+}
+async function updateVSCodeSettings(settingsPath) {
+    let settings = {};
+    // Read existing settings
+    if (await fileExists(settingsPath)) {
+        try {
+            const content = await fs.readFile(settingsPath, "utf-8");
+            // Remove comments (simple approach for JSON with comments)
+            const cleanContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+            settings = JSON.parse(cleanContent);
+        }
+        catch {
+            log("⚠️  Impossible de parser settings.json existant, création d'un nouveau", colors.yellow);
+            settings = {};
+        }
+    }
+    // Check if MCP config already exists
+    const mcp = settings.mcp;
+    const servers = mcp?.servers;
+    if (servers?.["spec-kit"]) {
+        log("   spec-kit déjà configuré dans VS Code", colors.green);
+        return false;
+    }
+    // Add spec-kit configuration
+    if (!settings.mcp) {
+        settings.mcp = { servers: {} };
+    }
+    if (!settings.mcp.servers) {
+        settings.mcp.servers = {};
+    }
+    const mcpServers = settings.mcp.servers;
+    mcpServers["spec-kit"] = {
+        command: "npx",
+        args: ["-y", "smart-spec-kit-mcp"]
+    };
+    // Write updated settings
+    await ensureDir(path.dirname(settingsPath));
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return true;
+}
+async function copyPromptsToProject(projectPath) {
+    const srcPrompts = path.join(PACKAGE_ROOT, ".github", "copilot", "prompts");
+    const destPrompts = path.join(projectPath, ".github", "copilot", "prompts");
+    if (!(await fileExists(srcPrompts))) {
+        log("⚠️  Dossier prompts non trouvé dans le package", colors.yellow);
+        return 0;
+    }
+    return await copyDir(srcPrompts, destPrompts);
+}
+async function addToGitignore(projectPath) {
+    const gitignorePath = path.join(projectPath, ".gitignore");
+    const specKitIgnore = "\n# Spec-Kit sessions (auto-generated)\n.spec-kit-sessions/\n";
+    if (await fileExists(gitignorePath)) {
+        const content = await fs.readFile(gitignorePath, "utf-8");
+        if (!content.includes(".spec-kit-sessions")) {
+            await fs.appendFile(gitignorePath, specKitIgnore);
+        }
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    // Help command
+    if (command === "setup" && (args.includes("--help") || args.includes("-h"))) {
+        console.log(`
+${colors.bold}Spec-Kit Setup CLI${colors.reset}
+
+${colors.cyan}Usage:${colors.reset}
+  npx smart-spec-kit-mcp setup [options]
+
+${colors.cyan}Options:${colors.reset}
+  --project <path>   Chemin du projet (défaut: répertoire courant)
+  --skip-vscode      Ne pas modifier VS Code settings.json
+  --skip-prompts     Ne pas copier les slash commands
+  --dry-run          Afficher ce qui serait fait sans rien modifier
+  -h, --help         Afficher cette aide
+
+${colors.cyan}Exemples:${colors.reset}
+  npx smart-spec-kit-mcp setup
+  npx smart-spec-kit-mcp setup --project ./mon-projet
+  npx smart-spec-kit-mcp setup --dry-run
+  npx smart-spec-kit-mcp setup --skip-vscode
+`);
+        return;
+    }
+    if (command !== "setup") {
+        // If no setup command, run as MCP server (default behavior)
+        // Import and run the main server
+        await import("./index.js");
+        return;
+    }
+    // Parse options
+    const projectPath = args.includes("--project")
+        ? (args[args.indexOf("--project") + 1] ?? process.cwd())
+        : process.cwd();
+    const skipVSCode = args.includes("--skip-vscode");
+    const skipPrompts = args.includes("--skip-prompts");
+    const dryRun = args.includes("--dry-run");
+    console.log(`
+${colors.cyan}╔═══════════════════════════════════════════════════════════╗
+║                                                             ║
+║   ${colors.bold}🚀 Spec-Kit Setup${colors.reset}${colors.cyan}${dryRun ? " (DRY RUN)" : ""}                                        ║
+║   Installation automatisée pour développeurs                ║
+║                                                             ║
+╚═══════════════════════════════════════════════════════════╝${colors.reset}
+`);
+    if (dryRun) {
+        log("🔍 Mode dry-run: aucune modification ne sera effectuée\n", colors.yellow);
+    }
+    log(`📁 Projet: ${projectPath}`, colors.blue);
+    // Step 1: Copy prompts to project
+    if (!skipPrompts) {
+        logStep(1, "Installation des slash commands...");
+        if (dryRun) {
+            log("   📋 Copierait les prompts dans .github/copilot/prompts/", colors.yellow);
+        }
+        else {
+            const promptsCount = await copyPromptsToProject(projectPath);
+            if (promptsCount > 0) {
+                log(`   ✅ ${promptsCount} fichiers copiés dans .github/copilot/prompts/`, colors.green);
+            }
+            else {
+                log("   ⏭️  Aucun prompt à copier", colors.yellow);
+            }
+        }
+    }
+    else {
+        logStep(1, "Slash commands (ignoré)");
+    }
+    // Step 2: Configure VS Code
+    if (!skipVSCode) {
+        logStep(2, "Configuration de VS Code...");
+        const settingsPath = await getVSCodeSettingsPath();
+        if (settingsPath) {
+            if (dryRun) {
+                log(`   📋 Ajouterait MCP server à ${settingsPath}`, colors.yellow);
+            }
+            else {
+                const updated = await updateVSCodeSettings(settingsPath);
+                if (updated) {
+                    log(`   ✅ MCP server ajouté à ${settingsPath}`, colors.green);
+                }
+            }
+        }
+        else {
+            log("   ⚠️  VS Code settings.json non trouvé", colors.yellow);
+        }
+    }
+    else {
+        logStep(2, "VS Code config (ignoré)");
+    }
+    // Step 3: Update .gitignore
+    logStep(3, "Mise à jour .gitignore...");
+    if (dryRun) {
+        log("   📋 Ajouterait .spec-kit-sessions/ au .gitignore", colors.yellow);
+    }
+    else {
+        await addToGitignore(projectPath);
+        log("   ✅ .spec-kit-sessions/ ajouté au .gitignore", colors.green);
+    }
+    // Step 4: Create .spec-kit directory (optional)
+    logStep(4, "Création de la config locale...");
+    const specKitDir = path.join(projectPath, ".spec-kit");
+    if (!(await fileExists(specKitDir))) {
+        if (dryRun) {
+            log("   📋 Créerait le dossier .spec-kit/", colors.yellow);
+        }
+        else {
+            await ensureDir(path.join(specKitDir, "workflows"));
+            await ensureDir(path.join(specKitDir, "templates"));
+            log("   ✅ Dossier .spec-kit/ créé", colors.green);
+        }
+    }
+    else {
+        log("   ⏭️  .spec-kit/ existe déjà", colors.yellow);
+    }
+    // Final instructions
+    if (dryRun) {
+        console.log(`
+${colors.yellow}╔═══════════════════════════════════════════════════════════╗
+║                                                             ║
+║   ${colors.bold}🔍 Dry run terminé - aucune modification effectuée${colors.reset}${colors.yellow}       ║
+║                                                             ║
+╚═══════════════════════════════════════════════════════════╝${colors.reset}
+
+Exécutez sans --dry-run pour appliquer les changements.
+`);
+        return;
+    }
+    console.log(`
+${colors.green}╔═══════════════════════════════════════════════════════════╗
+║                                                             ║
+║   ${colors.bold}✅ Installation terminée!${colors.reset}${colors.green}                               ║
+║                                                             ║
+╚═══════════════════════════════════════════════════════════╝${colors.reset}
+
+${colors.bold}Prochaines étapes:${colors.reset}
+
+1. ${colors.cyan}Rechargez VS Code:${colors.reset}
+   Ctrl+Shift+P → "Developer: Reload Window"
+
+2. ${colors.cyan}Testez l'installation:${colors.reset}
+   Dans Copilot Chat, tapez: /spec-kit-ping
+
+3. ${colors.cyan}Démarrez un workflow:${colors.reset}
+   /spec-kit-start
+
+${colors.bold}Slash commands disponibles:${colors.reset}
+   /spec-kit-ping      Vérifie le serveur
+   /spec-kit-init      Initialise les templates
+   /spec-kit-list      Liste les workflows
+   /spec-kit-start     Démarre un workflow
+   /spec-kit-status    Statut du workflow
+   /spec-kit-continue  Continue le workflow
+   /spec-kit-abort     Annule le workflow
+   /spec-kit-config    Affiche la config
+
+${colors.blue}Documentation: https://github.com/anthropic-ai/smart-spec-kit${colors.reset}
+`);
+}
+main().catch((error) => {
+    console.error(`${colors.red}Erreur:${colors.reset}`, error);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map