sdd-toolkit 2.1.0 → 3.1.0

package/definitions/skills/feature-templates/SKILL.md

@@ -0,0 +1,136 @@
+# SKILL.md — Feature Templates
+
+---
+name: feature-templates  
+description: Standard templates for creating feature structures
+---
+
+## Objective
+This skill contains templates for creating feature structures in SDD Toolkit.
+
+---
+
+## Directory Structure
+
+```
+.sdd-toolkit/features/[feature-slug]/
+├── index.md      # Overview + roadmap
+├── state.md      # Progress + context + files
+├── MT01.md       # Milestone 1
+├── MT02.md       # Milestone 2 (if needed)
+└── ...
+```
+
+---
+
+## Template: index.md
+
+```markdown
+# 🚀 Feature: [Name]
+
+## Overview
+- **Objective:** [Brief description of this feature's value]
+- **Linked Requirements:** [FR-XXX, FR-YYY]
+
+## Roadmap
+- **MT01:** [Milestone Name]
+- **MT02:** [Milestone Name]
+
+## Dependencies
+- **Depends on:** [other features or "None"]
+- **Blocks:** [other features or "None"]
+
+## Notes
+[Additional context or important decisions]
+```
+
+---
+
+## Template: state.md
+
+```markdown
+# 📊 Feature: [Name] - State
+
+## Progress
+| Milestone | Status | Tasks |
+|-----------|--------|-------|
+| MT01 | ⏳ Not Started | 0/X |
+| MT02 | ⏳ Not Started | 0/Y |
+
+## Current Work
+- **Last Task:** None
+- **Current Task:** MT01-task 1 (awaiting start)
+- **Next Task:** MT01-task 2
+
+## Technical Context
+### Created Files
+No files created yet.
+
+### Decisions Made
+| Date | Type | Description |
+|------|------|-------------|
+| - | - | No decisions recorded |
+
+## Known Issues
+No issues reported.
+```
+
+---
+
+## Template: MTxx.md (Milestone)
+
+```markdown
+# 🏁 MT01: [Milestone Name]
+
+**Objective:** [What will be delivered and tested at the end of this stage]
+
+## Tasks
+
+### MT01-task 1 — [Title]
+- **Description:** [What should be done]
+- **Reference:** [FR-XXX / BR-YYY]
+- **DoD:** [Definition of Done - verifiable result]
+- **Status:** ⏳ Not Started
+
+### MT01-task 2 — [Title]
+- **Description:** [What should be done]
+- **Reference:** [FR-XXX / BR-YYY]
+- **DoD:** [Definition of Done - verifiable result]
+- **Status:** ⏳ Not Started
+
+## Milestone Acceptance Criteria
+- [ ] All tasks completed
+- [ ] Code reviewed by QA Engineer
+- [ ] Tests passing (if applicable)
+```
+
+---
+
+## Creation Rules
+
+### Naming Convention
+| Element | Format | Example |
+|---------|--------|---------|
+| Feature slug | `kebab-case` | `user-authentication` |
+| Milestone | `MTXX` | `MT01`, `MT02` |
+| Task | `MTXX-task Y` | `MT01-task 1` |
+| Hotfix | `fix-[name]` | `fix-login-bug` |
+| Refactor | `refactor-[name]` | `refactor-api-layer` |
+
+### Limits
+- **Maximum 5 tasks per milestone** — If exceeded, create new milestone
+- **Maximum 4-5 milestones per feature** — If exceeded, split the feature
+- **Each task must have verifiable DoD** — No DoD = poorly defined task
+
+### Sequence
+Tasks within a milestone should be in **logical build order**:
+1. Setup/Configuration first
+2. Business logic after
+3. Tests last (or together with logic, if TDD)
+
+---
+
+## Notes
+- This skill is used by Feature Manager when creating new features
+- Templates can be adapted as needed for the project
+- Always update `.sdd-toolkit/context.md` after creating a feature

package/definitions/skills/handover-protocol/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: handover-protocol
+description: Standardized closure and handover protocol between SDD Toolkit agents. Use when completing a phase and needing to direct to the next agent.
+---
+
+# Handover Protocol
+
+This skill standardizes the transition between SDD Toolkit agents, ensuring consistency and traceability in communication.
+
+## When to Use
+
+- When completing a work phase (scope, requirements, feature, code, review, release)
+- When passing context to the next agent in the chain
+- When finishing a task and needing to indicate next steps
+
+## Handover Structure
+
+When finishing, you MUST use this format:
+
+```markdown
+> "🏷️ **[Artifact Name] successfully documented.**"
+>
+> **File Created/Updated:** `[file path]`
+>
+> **Summary:** [1-2 lines of what was done]
+>
+> **Next Step:** Use `/[command]` to start the next phase.
+>
+> **Handover to:** [Next Agent Name] ([emoji])
+```
+
+## Handover Map (Standard Flow)
+
+| Current Agent | Next Agent | Command |
+|---------------|------------|---------|
+| Project Architect 🏛️ | Requirements Engineer 📝 | `/sdd.requirements` |
+| Requirements Engineer 📝 | Feature Manager ✨ | `/sdd.feature` |
+| Feature Manager ✨ | Coder 💻 | `/sdd.coder [Task_ID]` |
+| Coder 💻 | QA Engineer 🔍 | `/sdd.review [Task_ID]` |
+| QA Engineer 🔍 (Approved) | Release Manager 📦 | `/sdd.log` or next task |
+| QA Engineer 🔍 (Rejected) | Coder 💻 | `/sdd.coder [Task_ID]` (fix) |
+
+## Rules
+
+1. **Never finish without handover** — The user must know exactly what to do next.
+2. **Use consistent emojis** — Each agent has their fixed emoji.
+3. **Cite the created file** — Always include the path of the generated artifact.
+4. **Be concise** — Handover is not a summary; it's direction.
+
+## Usage Example
+
+```markdown
+> "🏛️ **Project scope successfully documented.**"
+>
+> **File Created:** `.sdd-toolkit/project.md`
+>
+> **Summary:** Defined conceptual scope for NBA Stats Collector v1.0.0 project.
+>
+> **Next Step:** Use `/sdd.requirements` to detail functional requirements.
+>
+> **Handover to:** Requirements Engineer 📝
+```

package/definitions/skills/stack-interview/SKILL.md

@@ -0,0 +1,124 @@
+# SKILL.md — Stack Interview
+
+---
+name: stack-interview  
+description: Interview protocol for tech stack definition
+---
+
+## Objective
+This skill guides the interview with the user to define the project's tech stack in a structured but unbiased manner.
+
+---
+
+## When to Use
+- Tech stack is not defined in `.sdd-toolkit/requirements.md`
+- User requests stack change
+- Brownfield project needs to document existing stack
+
+---
+
+## Interview Principles
+
+### Be Collaborative (Not Imposing)
+Stack definition is a **joint decision**. You're not just an answer collector, nor a technology dictator.
+
+**Your role:**
+1. **Listen** to the user's preference
+2. **Evaluate** if the choice is adequate for the project scope (consult `project.md`)
+3. **Discuss** pros and cons when there are legitimate concerns
+4. **Arrive together** at a decision that makes sense for both
+
+**Examples of collaborative dialogue:**
+- ✅ "You mentioned MongoDB. Considering the project has many relationships between entities (per project.md), a relational database like PostgreSQL could help. What do you think? Is there a specific reason for NoSQL?"
+- ✅ "I understand you want to use React. Makes sense! For this project with many forms, have you considered any form management solution? No need to decide now, just for us to keep in mind."
+- ❌ "MongoDB is not adequate. Use PostgreSQL." (imposing)
+- ❌ "Ok, MongoDB." (too passive)
+
+### Be Agnostic (But Informed)
+- **DO NOT** list specific options as a choice menu
+- **ASK** openly: "Which framework do you plan to use?"
+- **EVALUATE** the response considering the project scope
+- **DISCUSS** if you identify possible challenges, but **RESPECT** the user's final decision
+
+### Be Efficient
+- Group related questions when possible
+- Maximum of 4-5 question rounds
+- If user doesn't know, mark as "TBD" (to be defined)
+
+---
+
+## Interview Script
+
+### Round 1: Frontend
+> "Let's define the tech stack. Starting with **Frontend**:
+> 1. Which framework/library do you plan to use? (or 'none' if server-side)
+> 2. How do you plan to style? (Pure CSS, Tailwind, Styled Components, etc.)
+> 3. Will you need state management? If so, which solution?"
+
+### Round 2: Backend
+> "Now for **Backend**:
+> 1. Which programming language?
+> 2. Which framework (if any)?
+> 3. What API style? (REST, GraphQL, gRPC)
+> 4. How will authentication work? (JWT, OAuth, sessions, etc.)"
+
+### Round 3: Data
+> "About **Database**:
+> 1. Which primary database?
+> 2. Will you use any ORM? Which one?
+> 3. How will you manage migrations?"
+
+### Round 4: Infrastructure (Optional)
+> "Finally, **Infrastructure** (can skip if you don't know yet):
+> 1. Will you use containers (Docker)?
+> 2. Which CI/CD platform?
+> 3. Where do you plan to host?"
+
+---
+
+## Response Handling
+
+| User Response | Action |
+|---------------|--------|
+| Specific technology | Document as defined |
+| "I don't know yet" / "TBD" | Document as "TBD" |
+| "None" / "Not applicable" | Document as "N/A" |
+| Unknown technology | Accept and document (don't question) |
+
+---
+
+## Output Format
+
+After the interview, document in `requirements.md`:
+
+```markdown
+## 1. Tech Stack
+
+### Frontend
+- **Framework:** [response or TBD]
+- **Styling:** [response or TBD]
+- **State:** [response or N/A]
+
+### Backend
+- **Language:** [response]
+- **Framework:** [response or None]
+- **API:** [REST / GraphQL / gRPC]
+- **Auth:** [response or TBD]
+
+### Data
+- **Database:** [response or TBD]
+- **ORM:** [response or None]
+- **Migrations:** [response or TBD]
+
+### Infrastructure
+- **Containers:** [response or TBD]
+- **CI/CD:** [response or TBD]
+- **Hosting:** [response or TBD]
+```
+
+---
+
+## Notes
+- This skill is called by the Requirements Engineer when the stack is not defined
+- Never suggest specific technologies — let the user decide
+- If the project is brownfield, also use the `detect-manifest` skill to validate

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sdd-toolkit",
-    "version": "2.1.0",
+    "version": "3.1.0",
     "description": "Instalador automatico dos agentes de desenvolvimento",
     "main": "src/index.js",
     "bin": {

package/src/index.js

@@ -9,21 +9,9 @@ const pc = require('picocolors');
 // Internal Modules
 const { loadAgents } = require('./lib/agents');
 const { setLocale, t, getLocale } = require('./lib/i18n');
-const {
-    toGeminiTOML,
-    toRooConfig,
-    toKiloMarkdown,
-    toCopilotInstructions,
-    toCursorMDC,
-    toWindsurfRules,
-    toClaudeCommand,
-    toPlainSystemPrompt,
-    toTraeRules,
-    toOpenCodeSkill,
-    toAntigravitySkill
-} = require('./lib/transformers');
 const { generateWorkflowGuide } = require('./lib/docs');
 const { view } = require('./commands/view');
+const handlers = require('./lib/handlers');
 
 async function main() {
     console.clear();
@@ -68,20 +56,30 @@ async function main() {
         if (fs.existsSync(path.join(process.cwd(), '.roo'))) tools.push('roo');
         if (fs.existsSync(path.join(process.cwd(), '.cline'))) tools.push('cline');
         if (fs.existsSync(path.join(process.cwd(), '.cursor'))) tools.push('cursor');
-        if (fs.existsSync(path.join(process.cwd(), '.windsurf'))) tools.push('windsurf');
         if (fs.existsSync(path.join(process.cwd(), '.claude'))) tools.push('claude');
-        if (fs.existsSync(path.join(process.cwd(), '.trae'))) tools.push('trae');
         if (fs.existsSync(path.join(process.cwd(), '.kilocode'))) tools.push('kilo');
-        if (fs.existsSync(path.join(process.cwd(), '.github'))) tools.push('copilot');
-        if (fs.existsSync(path.join(process.cwd(), '.roo'))) tools.push('roo');
         if (fs.existsSync(path.join(process.cwd(), '.opencode'))) tools.push('opencode');
-        if (fs.existsSync(path.join(process.cwd(), 'prompts'))) tools.push('web');
-
-        if (fs.existsSync(path.join(process.cwd(), '.antigravity'))) tools.push('antigravity');
+        if (fs.existsSync(path.join(process.cwd(), '.antigravity')) || fs.existsSync(path.join(process.cwd(), '.agent'))) tools.push('antigravity');
         if (tools.length === 0) {
             note(t('UPGRADE.NO_CONFIG'), t('UPGRADE.NO_CONFIG_TITLE'));
         } else {
             note(t('UPGRADE.DETECTED_TOOLS', tools.join(', ')), t('UPGRADE.DETECTED_TITLE'));
+            
+            // 1. Smart Scaffolding (Update folders, preserve files)
+            const s = spinner();
+            s.start(t('SCAFFOLD.LOADING'));
+            try {
+                const stats = generateWorkflowGuide(process.cwd());
+                if (stats.created > 0) {
+                     s.stop(`${t('SCAFFOLD.SUCCESS')} (${stats.created} new, ${stats.verified} verified)`);
+                } else {
+                     s.stop(t('SCAFFOLD.ALREADY_EXISTS'));
+                }
+            } catch (e) {
+                s.stop(pc.red(t('SCAFFOLD.ERROR')));
+            }
+
+            // 2. Update Agents
             await processAgentsInstallation(tools, { locale: getLocale() });
             outro(pc.green(t('UPGRADE.SUCCESS')));
             process.exit(0);
@@ -119,18 +117,13 @@ async function main() {
     const tools = await multiselect({
         message: t('SETUP.TOOL_SELECT'),
         options: [
-            { value: 'gemini', label: t('TOOLS.GEMINI'), hint: '.gemini/commands/dev' },
-            { value: 'roo', label: t('TOOLS.ROO'), hint: '.roo/commands/*.md' },
-            { value: 'cline', label: t('TOOLS.CLINE'), hint: '.cline/ & custom_modes.json' },
-            { value: 'cursor', label: t('TOOLS.CURSOR'), hint: '.cursor/commands/*.mdc' },
-            { value: 'windsurf', label: t('TOOLS.WINDSURF'), hint: '.windsurf/workflows/*.md' },
-            { value: 'claude', label: 'Claude Code', hint: '.claude/commands/agents/*.md' },
-            { value: 'trae', label: t('TOOLS.TRAE'), hint: '.trae/instructions.md' },
-            { value: 'kilo', label: t('TOOLS.KILO'), hint: '.kilocode/workflows/*.md' },
-            { value: 'copilot', label: t('TOOLS.COPILOT'), hint: '.github/prompts/*.md' },
-            { value: 'web', label: t('TOOLS.WEB'), hint: 'prompts/*.txt' },
-            { value: 'opencode', label: t('TOOLS.OPENCODE'), hint: '.opencode/skills/*' },
-            { value: 'antigravity', label: t('TOOLS.ANTIGRAVITY'), hint: '.antigravity/skills/*' }
+            { value: 'gemini', label: t('TOOLS.GEMINI'), hint: '.gemini/commands/* & skills/*' },
+            { value: 'roo', label: t('TOOLS.ROO'), hint: '.roo/skills/*' },
+            { value: 'cursor', label: t('TOOLS.CURSOR'), hint: '.cursor/commands/* & skills/*' },
+            { value: 'claude', label: 'Claude Code', hint: '.claude/commands/* & skills/* & agents/*' },
+            { value: 'kilo', label: t('TOOLS.KILO'), hint: '.kilocode/workflows/* & skills/*' },
+            { value: 'opencode', label: t('TOOLS.OPENCODE'), hint: '.opencode/skills/* & agents/*' },
+            { value: 'antigravity', label: t('TOOLS.ANTIGRAVITY'), hint: '.agent/skills/* & workflows/*' }
         ],
         required: true,
         hint: t('SETUP.TOOL_HINT')
@@ -165,167 +158,10 @@ async function processAgentsInstallation(tools, options) {
 
         s.message(t('INSTALL.INSTALLING', tools.join(', ')));
 
-        const toolHandlers = {
-            gemini: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.gemini', 'commands', 'dev');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const toml = toGeminiTOML(agent, options);
-                        const fileName = `${agent.originalName}.toml`;
-                        return fsp.writeFile(path.join(targetDir, fileName), toml);
-                    })
-                );
-            },
-            roo: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.roo', 'commands');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toOpenCodeAgent(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
-                    })
-                );
-            },
-            cline: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.cline');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toKiloMarkdown(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
-                    })
-                );
-
-                const modes = validAgents.map((agent) => toRooConfig(agent, agent.slug, options));
-                const jsonContent = JSON.stringify({ customModes: modes }, null, 2);
-                await fsp.writeFile(path.join(process.cwd(), 'cline_custom_modes.json'), jsonContent);
-            },
-            windsurf: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.windsurf', 'workflows');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toWindsurfRules(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
-                    })
-                );
-            },
-            claude: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.claude', 'commands', 'agents');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toClaudeCommand(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
-                    })
-                );
-            },
-            cursor: async (validAgents, options) => {
-                const commandsDir = path.join(process.cwd(), '.cursor', 'commands');
-                await fsp.mkdir(commandsDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const mdc = toCursorMDC(agent, options);
-                        return fsp.writeFile(path.join(commandsDir, `${agent.slug}.mdc`), mdc);
-                    })
-                );
-            },
-            kilo: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.kilocode', 'workflows');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toKiloMarkdown(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
-                    })
-                );
-            },
-            copilot: async (validAgents, options) => {
-                const githubDir = path.join(process.cwd(), '.github');
-                const promptsDir = path.join(githubDir, 'prompts');
-                await fsp.mkdir(promptsDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toCopilotInstructions(agent, options);
-                        return fsp.writeFile(path.join(promptsDir, `${agent.slug}.md`), md);
-                    })
-                );
-
-                const mainAgent = validAgents.find((a) => a.slug.includes('coder')) || validAgents[0];
-                const mainInstructions = toCopilotInstructions(mainAgent, options);
-                await fsp.writeFile(path.join(githubDir, 'prompts.md'), mainInstructions);
-            },
-            trae: async (validAgents, options) => {
-                const traeDir = path.join(process.cwd(), '.trae');
-                await fsp.mkdir(traeDir, { recursive: true });
-
-                const mainAgent = validAgents.find((a) => a.slug.includes('coder')) || validAgents[0];
-                const rules = toTraeRules(mainAgent, options);
-                await fsp.writeFile(path.join(traeDir, 'instructions.md'), rules);
-            },
-            web: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), 'prompts');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const txt = toPlainSystemPrompt(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.txt`), txt);
-                    })
-                );
-            },
-            opencode: async (validAgents, options) => {
-                const skillsDir = path.join(process.cwd(), '.opencode', 'skills');
-                
-                // Ensure base directory exists
-                await fsp.mkdir(skillsDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map(async (agent) => {
-                         // Create specific folder for the skill: .opencode/skills/[agent-slug]/
-                         // Ensure compatibility with naming rules (lowercase, alphanumeric, single hyphens)
-                         const skillName = agent.slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-                         const agentSkillDir = path.join(skillsDir, skillName);
-                         
-                         await fsp.mkdir(agentSkillDir, { recursive: true });
-
-                         const skillContent = toOpenCodeSkill(agent, options);
-                         return fsp.writeFile(path.join(agentSkillDir, 'SKILL.md'), skillContent);
-                    })
-                );
-            },
-            antigravity: async (validAgents, options) => {
-                const skillsDir = path.join(process.cwd(), '.antigravity', 'skills');
-                
-                // Ensure base directory exists (though we will mkdir for each agent)
-                await fsp.mkdir(skillsDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map(async (agent) => {
-                         // Create specific folder for the skill: .antigravity/skills/[agent-slug]/
-                         const agentSkillDir = path.join(skillsDir, agent.slug);
-                         await fsp.mkdir(agentSkillDir, { recursive: true });
-
-                         const skillContent = toAntigravitySkill(agent, options);
-                         return fsp.writeFile(path.join(agentSkillDir, 'SKILL.md'), skillContent);
-                    })
-                );
-            }
-        };
-
         for (const tool of tools) {
-            const handler = toolHandlers[tool];
-            if (handler) {
-                await handler(validAgents, options);
+            const handler = handlers[tool];
+            if (handler && typeof handler.install === 'function') {
+                await handler.install(validAgents, options);
             }
         }
 

package/src/lib/handlers/antigravity.js

@@ -0,0 +1,34 @@
+const fsp = require('fs/promises');
+const path = require('path');
+const { toAntigravitySkill, toAntigravityWorkflow } = require('../transformers');
+
+/**
+ * Handles installation for Antigravity
+ * @param {Array} agents - List of agents to install
+ * @param {Object} options - Installation options
+ */
+async function install(agents, options) {
+    const skillsDir = path.join(process.cwd(), '.agent', 'skills');
+    const workflowsDir = path.join(process.cwd(), '.agent', 'workflows');
+    
+    await fsp.mkdir(skillsDir, { recursive: true });
+    await fsp.mkdir(workflowsDir, { recursive: true });
+
+    await Promise.all(
+        agents.map(async (agent) => {
+             const skillName = agent.slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+
+             // Generate Skill: .agent/skills/[agent-slug]/SKILL.md
+             const agentSkillDir = path.join(skillsDir, skillName);
+             await fsp.mkdir(agentSkillDir, { recursive: true });
+             const skillContent = toAntigravitySkill(agent, options);
+             await fsp.writeFile(path.join(agentSkillDir, 'SKILL.md'), skillContent);
+
+             // Generate Workflow: .agent/workflows/[agent-slug].md
+             const workflowContent = toAntigravityWorkflow(agent, options);
+             await fsp.writeFile(path.join(workflowsDir, `${skillName}.md`), workflowContent);
+        })
+    );
+}
+
+module.exports = { install };

package/src/lib/handlers/claude.js

@@ -0,0 +1,40 @@
+const fsp = require('fs/promises');
+const path = require('path');
+const { toClaudeCommand, toClaudeSkill, toClaudeSubagent } = require('../transformers');
+
+/**
+ * Handles installation for Claude Code
+ * @param {Array} agents - List of agents to install
+ * @param {Object} options - Installation options
+ */
+async function install(agents, options) {
+    const commandsDir = path.join(process.cwd(), '.claude', 'commands', 'agents');
+    const skillsDir = path.join(process.cwd(), '.claude', 'skills');
+    const agentsDir = path.join(process.cwd(), '.claude', 'agents');
+    
+    await fsp.mkdir(commandsDir, { recursive: true });
+    await fsp.mkdir(skillsDir, { recursive: true });
+    await fsp.mkdir(agentsDir, { recursive: true });
+
+    await Promise.all(
+        agents.map(async (agent) => {
+            const skillName = agent.slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+
+            // Generate Command
+            const command = toClaudeCommand(agent, options);
+            await fsp.writeFile(path.join(commandsDir, `${agent.slug}.md`), command);
+
+            // Generate Skill
+            const agentSkillDir = path.join(skillsDir, skillName);
+            await fsp.mkdir(agentSkillDir, { recursive: true });
+            const skill = toClaudeSkill(agent, options);
+            await fsp.writeFile(path.join(agentSkillDir, 'SKILL.md'), skill);
+
+            // Generate Subagent
+            const subagent = toClaudeSubagent(agent, options);
+            await fsp.writeFile(path.join(agentsDir, `${skillName}.md`), subagent);
+        })
+    );
+}
+
+module.exports = { install };