@patricksardinha/agentkit-cli 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,1079 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/commands/init.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = require("path");
+var import_inquirer = __toESM(require("inquirer"), 1);
+var import_ora = __toESM(require("ora"), 1);
+
+// src/detectors/stackDetector.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+async function pathExists(p) {
+  try {
+    await (0, import_promises.access)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(p) {
+  try {
+    const raw = await (0, import_promises.readFile)(p, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function readText(p) {
+  try {
+    return await (0, import_promises.readFile)(p, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function detectStack(projectPath) {
+  const info = {
+    framework: "unknown",
+    language: "unknown",
+    hasTypeScript: false,
+    extras: []
+  };
+  const packageJson = await readJson((0, import_node_path.join)(projectPath, "package.json"));
+  const requirementsTxt = await readText((0, import_node_path.join)(projectPath, "requirements.txt"));
+  const hasTauriDir = await pathExists((0, import_node_path.join)(projectPath, "src-tauri"));
+  const hasTsConfig = await pathExists((0, import_node_path.join)(projectPath, "tsconfig.json"));
+  if (packageJson !== null) {
+    const deps = packageJson.dependencies ?? {};
+    const devDeps = packageJson.devDependencies ?? {};
+    const allDeps = { ...deps, ...devDeps };
+    info.hasTypeScript = "typescript" in allDeps || hasTsConfig;
+    info.language = info.hasTypeScript ? "typescript" : "javascript";
+    if ("next" in allDeps) {
+      info.framework = "nextjs";
+    } else if (hasTauriDir || "@tauri-apps/api" in allDeps || "@tauri-apps/cli" in allDeps) {
+      info.framework = "tauri";
+    } else if ("react" in allDeps) {
+      info.framework = "react";
+    } else if ("express" in allDeps) {
+      info.framework = "express";
+    } else {
+      info.framework = "node";
+    }
+    if ("vitest" in allDeps || "jest" in allDeps) info.extras.push("testing");
+    if ("prisma" in allDeps || "@prisma/client" in allDeps) info.extras.push("prisma");
+    if ("tailwindcss" in allDeps) info.extras.push("tailwind");
+  }
+  if (requirementsTxt !== null && info.framework === "unknown") {
+    info.language = "python";
+    if (/\bfastapi\b/i.test(requirementsTxt)) {
+      info.framework = "fastapi";
+    }
+  }
+  if (hasTauriDir && info.framework === "unknown") {
+    info.framework = "tauri";
+  }
+  return info;
+}
+
+// src/detectors/gitDetector.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+async function isGitRepo(projectPath) {
+  try {
+    await (0, import_promises2.access)((0, import_node_path2.join)(projectPath, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/blueprintParser.ts
+function parseBlueprint(content) {
+  const features = [];
+  const sectionRegex = /^## (.+)$/gm;
+  const sections = [];
+  let m;
+  while ((m = sectionRegex.exec(content)) !== null) {
+    sections.push({ name: m[1].trim(), start: m.index });
+  }
+  for (let i = 0; i < sections.length; i++) {
+    const section = sections[i];
+    const end = i + 1 < sections.length ? sections[i + 1].start : content.length;
+    const body = content.slice(section.start, end);
+    const items = [...body.matchAll(/^[-*]\s+(.+)$/gm)].map((r) => r[1].trim());
+    features.push({ name: section.name, items });
+  }
+  return features;
+}
+
+// src/templates/react.ts
+function claudeMd(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  const testLine = stack.extras.includes("testing") ? "- `npm test`      \u2014 run tests\n" : "";
+  return `# CLAUDE.md \u2014 React Project
+
+## Stack
+- Framework : React (${lang})
+- Language  : ${lang}
+- Build     : Vite
+
+## Commands
+- \`npm run dev\`   \u2014 development server
+- \`npm run build\` \u2014 production build
+${testLine}
+## Structure
+src/
+  components/   \u2190 UI components (PascalCase)
+  hooks/        \u2190 custom hooks (prefix: use*)
+  pages/        \u2190 page-level components
+  utils/        \u2190 shared helpers
+
+## Conventions
+1. Components in PascalCase
+2. Hooks prefixed with \`use\`
+3. Props interfaces named \`*Props\`
+4. Tout output console passe par un logger centralis\xE9
+`;
+}
+function workflow(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  return `# Agent Workflow \u2014 React Project
+
+## Stack d\xE9tect\xE9e
+Framework: React | Language: ${lang}
+
+## Agents
+
+### Agent 1 \xB7 Components
+P\xE9rim\xE8tre : composants UI r\xE9utilisables
+Produit   : src/components/
+Crit\xE8re   : composants document\xE9s et test\xE9s
+
+### Agent 2 \xB7 State & Hooks
+P\xE9rim\xE8tre : state management, hooks personnalis\xE9s
+Produit   : src/hooks/
+Crit\xE8re   : hooks test\xE9s unitairement
+
+### Agent 3 \xB7 Pages & Routing
+P\xE9rim\xE8tre : assemblage des pages, react-router
+Produit   : src/pages/
+Crit\xE8re   : navigation fonctionnelle
+
+### Agent 4 \xB7 Tests & CI
+P\xE9rim\xE8tre : couverture de tests, configuration CI
+Produit   : tests/, .github/workflows/
+Crit\xE8re   : npm test passe
+`;
+}
+
+// src/templates/nextjs.ts
+function claudeMd2(stack) {
+  const hasTailwind = stack.extras.includes("tailwind");
+  const hasPrisma = stack.extras.includes("prisma");
+  return `# CLAUDE.md \u2014 Next.js Project
+
+## Stack
+- Framework : Next.js (TypeScript)
+- Rendering : App Router (RSC + Client Components)
+- Styling   : ${hasTailwind ? "Tailwind CSS" : "CSS Modules"}
+${hasPrisma ? "- Database  : Prisma ORM\n" : ""}
+## Commands
+- \`npm run dev\`   \u2014 development server (http://localhost:3000)
+- \`npm run build\` \u2014 production build
+- \`npm start\`     \u2014 production server
+- \`npm test\`      \u2014 run tests
+
+## Structure
+src/
+  app/          \u2190 App Router pages and layouts
+  components/   \u2190 shared UI components
+  lib/          \u2190 server utilities, db clients
+  utils/        \u2190 shared helpers
+
+## Conventions
+1. Server Components by default, \`'use client'\` only when needed
+2. API routes in \`src/app/api/\`
+3. Environment variables via \`src/env.ts\` (validated)
+4. Tout output console passe par un logger centralis\xE9
+`;
+}
+function workflow2(stack) {
+  const hasPrisma = stack.extras.includes("prisma");
+  return `# Agent Workflow \u2014 Next.js Project
+
+## Stack d\xE9tect\xE9e
+Framework: Next.js | Language: TypeScript
+
+## Agents
+
+### Agent 1 \xB7 Data Layer
+P\xE9rim\xE8tre : sch\xE9ma${hasPrisma ? " Prisma" : ""}, types, server actions
+Produit   : src/lib/, ${hasPrisma ? "prisma/schema.prisma" : "src/types/"}
+Crit\xE8re   : types compilent, migrations propres
+
+### Agent 2 \xB7 UI Components
+P\xE9rim\xE8tre : composants r\xE9utilisables (Server + Client)
+Produit   : src/components/
+Crit\xE8re   : composants rendus sans erreur
+
+### Agent 3 \xB7 Pages & Layout
+P\xE9rim\xE8tre : App Router, layouts, pages
+Produit   : src/app/
+Crit\xE8re   : navigation fonctionnelle, build passe
+
+### Agent 4 \xB7 API & Tests
+P\xE9rim\xE8tre : API routes, tests e2e/unitaires
+Produit   : src/app/api/, tests/
+Crit\xE8re   : npm test passe
+`;
+}
+
+// src/templates/tauri.ts
+function claudeMd3(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  return `# CLAUDE.md \u2014 Tauri Project
+
+## Stack
+- Framework : Tauri (Rust + ${lang} frontend)
+- Language  : Rust (backend) + ${lang} (frontend)
+- Build     : Cargo + Vite
+
+## Commands
+- \`npm run tauri dev\`   \u2014 development (hot reload)
+- \`npm run tauri build\` \u2014 production bundle
+- \`npm run build\`       \u2014 frontend only
+- \`npm test\`            \u2014 run tests
+
+## Structure
+src/            \u2190 frontend (${lang})
+  components/
+  utils/
+src-tauri/      \u2190 Rust backend
+  src/
+    main.rs     \u2190 Tauri entry point
+    commands.rs \u2190 Tauri commands (IPC)
+  tauri.conf.json
+
+## Conventions
+1. IPC commands defined in \`src-tauri/src/commands.rs\`
+2. Frontend invokes via \`@tauri-apps/api/tauri\`
+3. No direct filesystem access from frontend
+4. Tout output console passe par un logger centralis\xE9
+`;
+}
+function workflow3(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  return `# Agent Workflow \u2014 Tauri Project
+
+## Stack d\xE9tect\xE9e
+Framework: Tauri | Language: Rust + ${lang}
+
+## Agents
+
+### Agent 1 \xB7 Rust Commands
+P\xE9rim\xE8tre : commandes Tauri (IPC), permissions
+Produit   : src-tauri/src/commands.rs, tauri.conf.json
+Crit\xE8re   : \`cargo build\` passe
+
+### Agent 2 \xB7 Frontend UI
+P\xE9rim\xE8tre : interface ${lang}, int\xE9gration IPC
+Produit   : src/components/, src/utils/
+Crit\xE8re   : appels IPC fonctionnels
+
+### Agent 3 \xB7 Build & Packaging
+P\xE9rim\xE8tre : configuration build, ic\xF4nes, installeurs
+Produit   : src-tauri/tauri.conf.json, icons/
+Crit\xE8re   : \`npm run tauri build\` produit un bundle
+
+### Agent 4 \xB7 Tests
+P\xE9rim\xE8tre : tests Rust + tests frontend
+Produit   : src-tauri/tests/, tests/
+Crit\xE8re   : \`cargo test\` + \`npm test\` passent
+`;
+}
+
+// src/templates/fastapi.ts
+function claudeMd4(_stack) {
+  return `# CLAUDE.md \u2014 FastAPI Project
+
+## Stack
+- Framework : FastAPI (Python)
+- Language  : Python 3.11+
+- Server    : Uvicorn
+- Validation: Pydantic v2
+
+## Commands
+- \`uvicorn main:app --reload\` \u2014 development server (http://localhost:8000)
+- \`pytest\`                    \u2014 run tests
+- \`pip install -r requirements.txt\` \u2014 install dependencies
+
+## Structure
+app/
+  main.py       \u2190 FastAPI app entry point
+  routers/      \u2190 API route groups
+  models/       \u2190 Pydantic models
+  services/     \u2190 business logic
+  dependencies/ \u2190 FastAPI dependencies (DI)
+tests/          \u2190 pytest tests
+
+## Conventions
+1. Routers grouped by domain in \`app/routers/\`
+2. Pydantic models for all request/response bodies
+3. Business logic in \`app/services/\`, not in routes
+4. Async endpoints by default (\`async def\`)
+5. Environment variables via \`python-dotenv\` + \`pydantic-settings\`
+`;
+}
+function workflow4(_stack) {
+  return `# Agent Workflow \u2014 FastAPI Project
+
+## Stack d\xE9tect\xE9e
+Framework: FastAPI | Language: Python
+
+## Agents
+
+### Agent 1 \xB7 Models & Schemas
+P\xE9rim\xE8tre : mod\xE8les Pydantic, sch\xE9mas DB (SQLAlchemy/SQLModel)
+Produit   : app/models/
+Crit\xE8re   : mod\xE8les valid\xE9s, migrations propres
+
+### Agent 2 \xB7 Services
+P\xE9rim\xE8tre : logique m\xE9tier, acc\xE8s base de donn\xE9es
+Produit   : app/services/
+Crit\xE8re   : services test\xE9s unitairement (pytest)
+
+### Agent 3 \xB7 Routers & API
+P\xE9rim\xE8tre : routes FastAPI, d\xE9pendances, auth
+Produit   : app/routers/, app/dependencies/
+Crit\xE8re   : endpoints document\xE9s (OpenAPI), tests d'int\xE9gration
+
+### Agent 4 \xB7 Tests & CI
+P\xE9rim\xE8tre : couverture pytest, configuration CI
+Produit   : tests/, .github/workflows/
+Crit\xE8re   : \`pytest\` passe \xE0 100%
+`;
+}
+
+// src/templates/express.ts
+function claudeMd5(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  const hasPrisma = stack.extras.includes("prisma");
+  return `# CLAUDE.md \u2014 Express Project
+
+## Stack
+- Framework : Express (${lang})
+- Language  : ${lang}
+- Runtime   : Node.js 20+
+${hasPrisma ? "- Database  : Prisma ORM\n" : ""}
+## Commands
+- \`npm run dev\`   \u2014 development server (nodemon)
+- \`npm run build\` \u2014 compile TypeScript
+- \`npm start\`     \u2014 production server
+- \`npm test\`      \u2014 run tests
+
+## Structure
+src/
+  routes/       \u2190 Express routers (one per domain)
+  controllers/  \u2190 request handlers
+  services/     \u2190 business logic
+  middleware/   \u2190 Express middleware
+  utils/        \u2190 shared helpers
+
+## Conventions
+1. Routes grouped by domain in \`src/routes/\`
+2. Business logic in \`src/services/\`, not in controllers
+3. Middleware for cross-cutting concerns (auth, validation)
+4. Tout output console passe par un logger centralis\xE9
+`;
+}
+function workflow5(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  return `# Agent Workflow \u2014 Express Project
+
+## Stack d\xE9tect\xE9e
+Framework: Express | Language: ${lang}
+
+## Agents
+
+### Agent 1 \xB7 Data & Models
+P\xE9rim\xE8tre : mod\xE8les de donn\xE9es, acc\xE8s DB
+Produit   : src/models/, src/services/db.ts
+Crit\xE8re   : connexion DB fonctionnelle
+
+### Agent 2 \xB7 Services
+P\xE9rim\xE8tre : logique m\xE9tier
+Produit   : src/services/
+Crit\xE8re   : services test\xE9s unitairement
+
+### Agent 3 \xB7 Routes & Controllers
+P\xE9rim\xE8tre : routes Express, validation, auth
+Produit   : src/routes/, src/controllers/, src/middleware/
+Crit\xE8re   : endpoints r\xE9pondent correctement
+
+### Agent 4 \xB7 Tests & CI
+P\xE9rim\xE8tre : tests d'int\xE9gration, configuration CI
+Produit   : tests/, .github/workflows/
+Crit\xE8re   : npm test passe
+`;
+}
+
+// src/templates/node.ts
+function claudeMd6(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  return `# CLAUDE.md \u2014 Node.js Project
+
+## Stack
+- Runtime  : Node.js 20+
+- Language : ${lang}
+
+## Commands
+- \`npm run dev\`   \u2014 development (with watch)
+- \`npm run build\` \u2014 compile${stack.hasTypeScript ? " TypeScript" : ""}
+- \`npm start\`     \u2014 run production build
+- \`npm test\`      \u2014 run tests
+
+## Structure
+src/
+  index.ts      \u2190 entry point
+  lib/          \u2190 core library code
+  utils/        \u2190 shared helpers
+
+## Conventions
+1. Modules follow single-responsibility principle
+2. Async/await over callbacks
+3. Tout output console passe par un logger centralis\xE9
+`;
+}
+function workflow6(stack) {
+  const lang = stack.hasTypeScript ? "TypeScript" : "JavaScript";
+  return `# Agent Workflow \u2014 Node.js Project
+
+## Stack d\xE9tect\xE9e
+Runtime: Node.js | Language: ${lang}
+
+## Agents
+
+### Agent 1 \xB7 Core Library
+P\xE9rim\xE8tre : logique principale
+Produit   : src/lib/
+Crit\xE8re   : module fonctionne et test\xE9
+
+### Agent 2 \xB7 CLI / API
+P\xE9rim\xE8tre : interface utilisateur (CLI ou API)
+Produit   : src/index.ts, src/cli.ts
+Crit\xE8re   : commandes fonctionnelles
+
+### Agent 3 \xB7 Tests & CI
+P\xE9rim\xE8tre : couverture de tests, configuration CI
+Produit   : tests/, .github/workflows/
+Crit\xE8re   : npm test passe
+`;
+}
+
+// src/templates/unknown.ts
+function claudeMd7(_stack) {
+  return `# CLAUDE.md
+
+## Stack
+Stack non d\xE9tect\xE9e automatiquement \u2014 \xE0 remplir manuellement.
+
+## Commands
+- \xC0 d\xE9finir selon le projet
+
+## Structure
+src/    \u2190 code source
+tests/  \u2190 tests
+
+## Conventions
+1. Tout output console passe par un logger centralis\xE9
+2. \xC0 compl\xE9ter selon les conventions du projet
+`;
+}
+function workflow7(_stack) {
+  return `# Agent Workflow
+
+## Stack d\xE9tect\xE9e
+Stack inconnue \u2014 workflow g\xE9n\xE9rique.
+
+## Agents
+
+### Agent 1 \xB7 Setup
+P\xE9rim\xE8tre : configuration initiale du projet
+Produit   : structure de base
+Crit\xE8re   : projet compilable
+
+### Agent 2 \xB7 Core
+P\xE9rim\xE8tre : logique principale
+Produit   : src/
+Crit\xE8re   : fonctionnalit\xE9s principales op\xE9rationnelles
+
+### Agent 3 \xB7 Tests
+P\xE9rim\xE8tre : couverture de tests
+Produit   : tests/
+Crit\xE8re   : tests passent
+`;
+}
+
+// src/generators/claudeMdGenerator.ts
+function generateClaudeMd(stack, blueprintContent) {
+  let base;
+  switch (stack.framework) {
+    case "react":
+      base = claudeMd(stack);
+      break;
+    case "nextjs":
+      base = claudeMd2(stack);
+      break;
+    case "tauri":
+      base = claudeMd3(stack);
+      break;
+    case "fastapi":
+      base = claudeMd4(stack);
+      break;
+    case "express":
+      base = claudeMd5(stack);
+      break;
+    case "node":
+      base = claudeMd6(stack);
+      break;
+    default:
+      base = claudeMd7(stack);
+  }
+  if (!blueprintContent) return base;
+  const features = parseBlueprint(blueprintContent);
+  if (features.length === 0) return base;
+  const featureLines = features.map((f, i) => {
+    const sub = f.items.length > 0 ? "\n" + f.items.map((it) => `   - ${it}`).join("\n") : "";
+    return `${i + 1}. **${f.name}**${sub}`;
+  }).join("\n");
+  const featureSection = `
+## Features (Blueprint)
+
+${featureLines}
+`;
+  const conventionsIdx = base.indexOf("\n## Conventions");
+  if (conventionsIdx !== -1) {
+    return base.slice(0, conventionsIdx) + featureSection + base.slice(conventionsIdx);
+  }
+  return base + featureSection;
+}
+
+// src/utils/agentParser.ts
+function toSlug(name) {
+  return name.toLowerCase().replace(/[·•&]/g, " ").replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function getFieldValue(lines, pattern) {
+  for (const line of lines) {
+    const m = line.match(pattern);
+    if (m) return (m[1] ?? "").trim();
+  }
+  return "";
+}
+function extractAgentsFromWorkflow(content) {
+  const agents = [];
+  const blocks = content.split(/(?=^### Agent \d)/m).filter((b) => /^### Agent \d/.test(b.trimStart()));
+  for (const block of blocks) {
+    const lines = block.split("\n");
+    const headerMatch = lines[0].match(/^### Agent (\d+)\s*[·•]\s*(.+)$/);
+    if (!headerMatch) continue;
+    const number = parseInt(headerMatch[1], 10);
+    const name = headerMatch[2].trim();
+    const fullName = `Agent ${number} \xB7 ${name}`;
+    const slug = toSlug(name);
+    const scope = getFieldValue(lines, /Périmètre\s*:\s*(.+)/);
+    const criterion = getFieldValue(lines, /Critère[s]?\s*:\s*(.+)/);
+    const outputs = [];
+    const produitIdx = lines.findIndex((l) => /Produit\s*:/.test(l));
+    if (produitIdx !== -1) {
+      const inlineVal = (lines[produitIdx].match(/Produit\s*:\s*(.+)/)?.[1] ?? "").trim();
+      if (inlineVal) {
+        outputs.push(inlineVal);
+      } else {
+        for (let i = produitIdx + 1; i < lines.length; i++) {
+          const line = lines[i];
+          if (/^\s+[-]/.test(line)) {
+            outputs.push(line.trim().replace(/^-\s*/, ""));
+          } else if (line.trim() !== "" && !/^\s/.test(line)) {
+            break;
+          }
+        }
+      }
+    }
+    agents.push({ number, name, fullName, slug, scope, outputs, criterion });
+  }
+  return agents;
+}
+
+// src/generators/workflowGenerator.ts
+function generateWorkflow(stack, blueprintContent) {
+  if (blueprintContent) return blueprintWorkflow(stack, blueprintContent);
+  switch (stack.framework) {
+    case "react":
+      return workflow(stack);
+    case "nextjs":
+      return workflow2(stack);
+    case "tauri":
+      return workflow3(stack);
+    case "fastapi":
+      return workflow4(stack);
+    case "express":
+      return workflow5(stack);
+    case "node":
+      return workflow6(stack);
+    default:
+      return workflow7(stack);
+  }
+}
+function blueprintWorkflow(stack, blueprintContent) {
+  const features = parseBlueprint(blueprintContent);
+  const agentBlocks = features.map((feature, i) => {
+    const n = i + 1;
+    const slug = toSlug(feature.name);
+    const outputLines = feature.items.length > 0 ? feature.items.map((item) => `  - ${item}`).join("\n") : `  - src/${slug}/`;
+    return `### Agent ${n} \xB7 ${feature.name}
+P\xE9rim\xE8tre : Impl\xE9menter la fonctionnalit\xE9 ${feature.name.toLowerCase()}
+Produit   :
+${outputLines}
+Crit\xE8re   : npm test (tests ${feature.name.toLowerCase()} passent)`;
+  });
+  const ciN = features.length + 1;
+  agentBlocks.push(
+    `### Agent ${ciN} \xB7 Tests & CI
+P\xE9rim\xE8tre : Couverture de tests compl\xE8te et configuration du pipeline CI
+Produit   :
+  - tests/
+  - .github/workflows/
+Crit\xE8re   : npm test passe, pipeline CI vert`
+  );
+  return `# Agent Workflow \u2014 ${stack.framework} (Blueprint)
+
+## Stack d\xE9tect\xE9e
+Framework: ${stack.framework} | Language: ${stack.language}
+
+## Agents
+
+${agentBlocks.join("\n\n")}
+`;
+}
+
+// src/generators/playbookGenerator.ts
+function generatePlaybook({ agents, projectName }) {
+  const agentBlocks = agents.map((a) => agentBlock(a)).join("\n---\n\n");
+  return `# PLAYBOOK.md \u2014 ${projectName}
+
+> Donne cette instruction \xE0 Claude Code : 'Lis PLAYBOOK.md et ex\xE9cute la proc\xE9dure.'
+
+## R\xE8gles d'ex\xE9cution globales
+
+Avant chaque agent :
+1. Lire \`CLAUDE.md\`
+2. Lire \`agents/agent-{N}-{slug}/skills.md\` (le fichier de l'agent courant)
+
+Apr\xE8s chaque agent :
+- Ex\xE9cuter le crit\xE8re de succ\xE8s
+- Si succ\xE8s \u2192 annoncer "\u2705 Agent N termin\xE9" et passer au suivant
+- Si \xE9chec \u2192 analyser la cause racine, corriger, r\xE9ex\xE9cuter (max 3 tentatives)
+- Apr\xE8s 3 \xE9checs cons\xE9cutifs \u2192 pause et demander validation humaine
+- **Ne jamais passer \xE0 l'agent suivant sans crit\xE8re valid\xE9**
+
+## Agents
+
+${agentBlocks}
+
+## It\xE9rations futures
+
+Lorsqu'un nouvel agent est ajout\xE9 via \`agentkit add --feature <description>\` :
+1. Un nouveau bloc agent est ajout\xE9 \xE0 la fin de \`AGENT_WORKFLOW.md\`
+2. Le dossier \`agents/agent-{N}-{slug}/\` est cr\xE9\xE9 avec \`skills.md\` et \`context.md\`
+3. Ce \`PLAYBOOK.md\` est r\xE9g\xE9n\xE9r\xE9 automatiquement pour inclure le nouvel agent
+4. L'ex\xE9cution reprend \xE0 ce nouvel agent uniquement \u2014 les agents pr\xE9c\xE9dents ne sont pas r\xE9ex\xE9cut\xE9s
+
+## Validation humaine requise
+
+Les cas suivants n\xE9cessitent une pause et une confirmation humaine avant de continuer :
+- **3 \xE9checs cons\xE9cutifs** sur le crit\xE8re de succ\xE8s d'un agent
+- **D\xE9pendance externe manquante** : cl\xE9 API, variable d'environnement non d\xE9finie, service tiers inaccessible
+- **Conflit** entre le blueprint fourni (\`--blueprint\`) et la stack d\xE9tect\xE9e automatiquement
+`;
+}
+function agentBlock(agent) {
+  const skillsPath = `agents/agent-${agent.number}-${agent.slug}/skills.md`;
+  const outputLines = agent.outputs.length > 0 ? agent.outputs.map((o) => `- ${o}`).join("\n") : "- (voir skills.md pour le d\xE9tail)";
+  return `### ${agent.fullName}
+
+**P\xE9rim\xE8tre** : ${agent.scope}
+
+**Skills** : \`${skillsPath}\`
+
+**Fichiers produits** :
+${outputLines}
+
+**Crit\xE8re de succ\xE8s** :
+\`\`\`bash
+${agent.criterion || "npm run build && npm test"}
+\`\`\`
+
+**En cas d'\xE9chec** :
+1. Analyser le message d'erreur complet
+2. Corriger la cause racine (pas les sympt\xF4mes)
+3. R\xE9ex\xE9cuter le crit\xE8re (max 3 tentatives)
+4. Apr\xE8s 3 \xE9checs \u2192 demander validation humaine
+`;
+}
+
+// src/generators/skillsGenerator.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+async function generateSkills(agents, outputDir) {
+  for (const agent of agents) {
+    const agentDir = (0, import_node_path3.join)(outputDir, "agents", `agent-${agent.number}-${agent.slug}`);
+    await (0, import_promises3.mkdir)(agentDir, { recursive: true });
+    await (0, import_promises3.writeFile)((0, import_node_path3.join)(agentDir, "skills.md"), skillsMd(agent), "utf-8");
+    await (0, import_promises3.writeFile)((0, import_node_path3.join)(agentDir, "context.md"), contextMd(agent), "utf-8");
+  }
+}
+function skillsMd(agent) {
+  return `# Skills \u2014 ${agent.fullName}
+
+> Ce fichier est lu par l'agent avant de commencer.
+
+## Contexte technique
+
+<!-- \xC0 remplir : biblioth\xE8ques, versions, d\xE9cisions d'architecture sp\xE9cifiques \xE0 cet agent -->
+
+## Documentation de r\xE9f\xE9rence
+
+<!-- \xC0 remplir : liens vers docs, exemples, ADRs pertinents -->
+
+## Conventions sp\xE9cifiques
+
+<!-- \xC0 remplir : r\xE8gles propres \xE0 cet agent (naming, patterns, structure de fichiers) -->
+`;
+}
+function contextMd(agent) {
+  const outputLines = agent.outputs.length > 0 ? agent.outputs.map((o) => `- ${o}`).join("\n") : "- (voir AGENT_WORKFLOW.md)";
+  return `# Context \u2014 ${agent.fullName}
+
+> Ce fichier fournit le contexte additionnel \xE0 l'agent avant ex\xE9cution.
+> \xC0 compl\xE9ter avant de lancer cet agent.
+
+## P\xE9rim\xE8tre
+
+${agent.scope}
+
+## Fichiers produits attendus
+
+${outputLines}
+
+## Crit\xE8re de succ\xE8s
+
+\`${agent.criterion || "npm run build && npm test"}\`
+`;
+}
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var logger = {
+  info: (message) => {
+    process.stdout.write(import_chalk.default.blue("\u2139") + " " + message + "\n");
+  },
+  success: (message) => {
+    process.stdout.write(import_chalk.default.green("\u2714") + " " + message + "\n");
+  },
+  warn: (message) => {
+    process.stdout.write(import_chalk.default.yellow("\u26A0") + " " + message + "\n");
+  },
+  error: (message) => {
+    process.stderr.write(import_chalk.default.red("\u2716") + " " + message + "\n");
+  }
+};
+
+// src/commands/init.ts
+var import_node_path5 = require("path");
+var FRAMEWORK_LABELS = {
+  react: "React",
+  nextjs: "Next.js",
+  tauri: "Tauri",
+  fastapi: "FastAPI (Python)",
+  express: "Express",
+  node: "Node.js",
+  unknown: "Unknown (generic)"
+};
+async function fileExists(path) {
+  try {
+    await (0, import_promises4.readFile)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registerInit(program2) {
+  program2.command("init").description("G\xE9n\xE8re CLAUDE.md et AGENT_WORKFLOW.md dans le dossier courant").option("-f, --force", "\xC9crase les fichiers existants sans confirmation").option("--blueprint <path>", "Fichier blueprint .md \xE0 utiliser pour personnaliser les fichiers g\xE9n\xE9r\xE9s").action(async (options) => {
+    const cwd = process.cwd();
+    const spinner = (0, import_ora.default)("D\xE9tection de la stack\u2026").start();
+    const [stack, isGit] = await Promise.all([detectStack(cwd), isGitRepo(cwd)]);
+    spinner.stop();
+    if (!isGit) {
+      logger.warn("Ce dossier n'est pas un repo git \u2014 lancez git init si n\xE9cessaire");
+    }
+    const label = FRAMEWORK_LABELS[stack.framework];
+    logger.info(`Stack d\xE9tect\xE9e : ${label} (${stack.language})`);
+    const { confirmed } = await import_inquirer.default.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: `G\xE9n\xE9rer les fichiers pour ${label} ?`,
+        default: true
+      }
+    ]);
+    if (!confirmed) {
+      logger.warn("Annul\xE9.");
+      return;
+    }
+    const claudeMdPath = (0, import_node_path4.join)(cwd, "CLAUDE.md");
+    const workflowPath = (0, import_node_path4.join)(cwd, "AGENT_WORKFLOW.md");
+    const playbookPath = (0, import_node_path4.join)(cwd, "PLAYBOOK.md");
+    let projectName = (0, import_node_path5.basename)(cwd);
+    try {
+      const pkg = JSON.parse(await (0, import_promises4.readFile)((0, import_node_path4.join)(cwd, "package.json"), "utf-8"));
+      if (pkg.name) projectName = pkg.name;
+    } catch {
+    }
+    if (!options.force) {
+      const existing = [];
+      if (await fileExists(claudeMdPath)) existing.push("CLAUDE.md");
+      if (await fileExists(workflowPath)) existing.push("AGENT_WORKFLOW.md");
+      if (await fileExists(playbookPath)) existing.push("PLAYBOOK.md");
+      if (existing.length > 0) {
+        const { overwrite } = await import_inquirer.default.prompt([
+          {
+            type: "confirm",
+            name: "overwrite",
+            message: `${existing.join(" et ")} existe d\xE9j\xE0. \xC9craser ?`,
+            default: false
+          }
+        ]);
+        if (!overwrite) {
+          logger.warn("Annul\xE9.");
+          return;
+        }
+      }
+    }
+    let blueprintContent;
+    if (options.blueprint) {
+      try {
+        blueprintContent = await (0, import_promises4.readFile)(options.blueprint, "utf-8");
+      } catch {
+        logger.error(`Blueprint introuvable : ${options.blueprint}`);
+        process.exit(1);
+      }
+    }
+    const genSpinner = (0, import_ora.default)("G\xE9n\xE9ration des fichiers\u2026").start();
+    const claudeMdContent = generateClaudeMd(stack, blueprintContent);
+    const workflowContent = generateWorkflow(stack, blueprintContent);
+    const agents = extractAgentsFromWorkflow(workflowContent);
+    const playbookContent = generatePlaybook({ agents, projectName });
+    await (0, import_promises4.writeFile)(claudeMdPath, claudeMdContent, "utf-8");
+    await (0, import_promises4.writeFile)(workflowPath, workflowContent, "utf-8");
+    await (0, import_promises4.writeFile)(playbookPath, playbookContent, "utf-8");
+    await generateSkills(agents, cwd);
+    genSpinner.succeed("Fichiers g\xE9n\xE9r\xE9s");
+    logger.success("CLAUDE.md         \u2192 cr\xE9\xE9");
+    logger.success("AGENT_WORKFLOW.md  \u2192 cr\xE9\xE9");
+    logger.success("PLAYBOOK.md        \u2192 cr\xE9\xE9");
+    logger.success(`agents/           \u2192 ${agents.length} dossier(s) cr\xE9\xE9(s)`);
+  });
+}
+
+// src/commands/add.ts
+var import_promises5 = require("fs/promises");
+var import_node_path6 = require("path");
+var import_inquirer2 = __toESM(require("inquirer"), 1);
+function featureToAgentName(description) {
+  const clean = description.replace(/^(add|implement|create|build|integrate|setup|configure|refactor|improve)\s+/i, "").trim();
+  return clean.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function addFeatureToProject(description, projectDir) {
+  const workflowPath = (0, import_node_path6.join)(projectDir, "AGENT_WORKFLOW.md");
+  const playbookPath = (0, import_node_path6.join)(projectDir, "PLAYBOOK.md");
+  let workflowContent = "";
+  try {
+    workflowContent = await (0, import_promises5.readFile)(workflowPath, "utf-8");
+  } catch {
+    throw new Error(`AGENT_WORKFLOW.md introuvable dans ${projectDir} \u2014 lancez agentkit init`);
+  }
+  const existingAgents = extractAgentsFromWorkflow(workflowContent);
+  const nextNumber = existingAgents.length + 1;
+  const name = featureToAgentName(description);
+  const slug = toSlug(name);
+  const fullName = `Agent ${nextNumber} \xB7 ${name}`;
+  const newAgent = {
+    number: nextNumber,
+    name,
+    fullName,
+    slug,
+    scope: description,
+    outputs: [`agents/agent-${nextNumber}-${slug}/`],
+    criterion: "npm run build && npm test"
+  };
+  const agentBlock2 = `
+### ${fullName}
+P\xE9rim\xE8tre : ${description}
+Produit   :
+  - agents/agent-${nextNumber}-${slug}/
+Crit\xE8re   : npm run build && npm test
+`;
+  await (0, import_promises5.writeFile)(workflowPath, workflowContent + agentBlock2, "utf-8");
+  await generateSkills([newAgent], projectDir);
+  let projectName = (0, import_node_path6.basename)(projectDir);
+  try {
+    const pkg = JSON.parse(
+      await (0, import_promises5.readFile)((0, import_node_path6.join)(projectDir, "package.json"), "utf-8")
+    );
+    if (pkg.name) projectName = pkg.name;
+  } catch {
+  }
+  const allAgents = [...existingAgents, newAgent];
+  const playbookContent = generatePlaybook({ agents: allAgents, projectName });
+  await (0, import_promises5.writeFile)(playbookPath, playbookContent, "utf-8");
+  return {
+    agent: newAgent,
+    agentDirPath: (0, import_node_path6.join)(projectDir, "agents", `agent-${nextNumber}-${slug}`)
+  };
+}
+function registerAdd(program2) {
+  const addCmd = program2.command("add").description("Ajoute des ressources au projet agentkit").option("--feature <description>", "Ajoute un agent depuis une description de feature et r\xE9g\xE9n\xE8re PLAYBOOK.md").action(async (options) => {
+    if (options.feature) {
+      try {
+        const result = await addFeatureToProject(options.feature, process.cwd());
+        logger.success(`Agent ajout\xE9   : ${result.agent.fullName}`);
+        logger.success(`Dossier cr\xE9\xE9   : agents/agent-${result.agent.number}-${result.agent.slug}/`);
+        logger.success("PLAYBOOK.md    : r\xE9g\xE9n\xE9r\xE9");
+      } catch (err) {
+        logger.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    } else {
+      addCmd.help();
+    }
+  });
+  addCmd.command("agent").description("Ajoute un nouvel agent dans AGENT_WORKFLOW.md (interactif)").action(async () => {
+    const cwd = process.cwd();
+    const workflowPath = (0, import_node_path6.join)(cwd, "AGENT_WORKFLOW.md");
+    let existing = "";
+    try {
+      existing = await (0, import_promises5.readFile)(workflowPath, "utf-8");
+    } catch {
+      logger.error("AGENT_WORKFLOW.md introuvable \u2014 lancez d'abord : agentkit init");
+      process.exit(1);
+    }
+    const agentCount = (existing.match(/^### Agent \d+/gm) ?? []).length;
+    const nextNumber = agentCount + 1;
+    const answers = await import_inquirer2.default.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: `Nom de l'agent (ex: "Agent ${nextNumber} \xB7 Feature X") :`,
+        default: `Agent ${nextNumber}`
+      },
+      {
+        type: "input",
+        name: "scope",
+        message: "P\xE9rim\xE8tre (une phrase) :"
+      },
+      {
+        type: "input",
+        name: "outputs",
+        message: "Fichiers produits (s\xE9par\xE9s par des virgules) :"
+      },
+      {
+        type: "input",
+        name: "criterion",
+        message: "Crit\xE8re de succ\xE8s :"
+      }
+    ]);
+    const outputLines = answers.outputs.split(",").map((o) => `  - ${o.trim()}`).join("\n");
+    const agentSection = `
+### ${answers.name}
+P\xE9rim\xE8tre : ${answers.scope}
+Produit   :
+${outputLines}
+Crit\xE8re   : ${answers.criterion}
+`;
+    await (0, import_promises5.writeFile)(workflowPath, existing + agentSection, "utf-8");
+    logger.success(`Agent "${answers.name}" ajout\xE9 dans AGENT_WORKFLOW.md`);
+  });
+}
+
+// src/commands/status.ts
+var import_promises6 = require("fs/promises");
+var import_node_path7 = require("path");
+var import_chalk2 = __toESM(require("chalk"), 1);
+function registerStatus(program2) {
+  program2.command("status").description("Affiche l'\xE9tat du workflow agentkit dans le dossier courant").action(async () => {
+    const cwd = process.cwd();
+    const [stack, isGit, claudeMd8, workflow8] = await Promise.all([
+      detectStack(cwd),
+      isGitRepo(cwd),
+      (0, import_promises6.readFile)((0, import_node_path7.join)(cwd, "CLAUDE.md"), "utf-8").catch(() => null),
+      (0, import_promises6.readFile)((0, import_node_path7.join)(cwd, "AGENT_WORKFLOW.md"), "utf-8").catch(() => null)
+    ]);
+    process.stdout.write("\n" + import_chalk2.default.bold("AgentKit Status") + "\n");
+    process.stdout.write("\u2500".repeat(40) + "\n");
+    process.stdout.write(
+      import_chalk2.default.bold("Git repo     : ") + (isGit ? import_chalk2.default.green("\u2714 oui") : import_chalk2.default.red("\u2716 non")) + "\n"
+    );
+    process.stdout.write(
+      import_chalk2.default.bold("Stack        : ") + import_chalk2.default.cyan(stack.framework) + " (" + stack.language + ")\n"
+    );
+    process.stdout.write(
+      import_chalk2.default.bold("CLAUDE.md    : ") + (claudeMd8 !== null ? import_chalk2.default.green("\u2714 pr\xE9sent") : import_chalk2.default.yellow("\u2716 absent \u2014 lancez agentkit init")) + "\n"
+    );
+    process.stdout.write(
+      import_chalk2.default.bold("AGENT_WORKFLOW.md : ") + (workflow8 !== null ? import_chalk2.default.green("\u2714 pr\xE9sent") : import_chalk2.default.yellow("\u2716 absent \u2014 lancez agentkit init")) + "\n"
+    );
+    if (workflow8 !== null) {
+      const agentMatches = workflow8.match(/^### Agent \d+/gm) ?? [];
+      process.stdout.write(
+        import_chalk2.default.bold("Agents d\xE9finis   : ") + import_chalk2.default.cyan(String(agentMatches.length)) + "\n"
+      );
+    }
+    process.stdout.write("\u2500".repeat(40) + "\n\n");
+  });
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("agentkit").description("Scaffolder des workflows multi-agents Claude Code").version("0.1.0");
+registerInit(program);
+registerAdd(program);
+registerStatus(program);
+program.parse();
+//# sourceMappingURL=cli.cjs.map