sdd-toolkit 2.0.1 → 2.1.0

package/README.md

@@ -190,18 +190,17 @@ Once agents are installed, use these commands in your AI coding assistant:
 
 After running `sdd-toolkit`, the following structure is created in your project:
 
-```
-.sdd-toolkit/
-├── project.md              # Project scope and principles
-├── requirements.md         # Technical requirements and stack
-├── guidelines.md           # Project development guidelines
-├── milestones.md           # Development roadmap
-├── task.md                # Task execution backlog
-├── features/               # Individual feature specifications
-│   └── [feature-name].md
-├── logs/
-│   ├── executions/         # Task execution logs
-│   ├── reviews/           # Code review reports
+```
+.sdd-toolkit/
+├── project.md              # Project scope and principles
+├── requirements.md         # Technical requirements and stack
+├── milestones.md           # Development roadmap
+├── task.md                # Task execution backlog
+├── features/               # Individual feature specifications
+│   └── [feature-name].md
+├── logs/
+│   ├── executions/         # Task execution logs
+│   ├── reviews/           # Code review reports
 │   └── archive/          # Archived completed work
 └── agents/               # Custom agent definitions (optional overrides)
 ```
@@ -328,19 +327,7 @@ MIT
 - Re-run `sdd-toolkit` and ensure you select the correct language during setup (English, Portuguese, or Spanish).
 - Or manually edit the `LANGUAGE_RULES` in your agent files.
 
-### Stack profile not applying rules
-
-**Problem:** Selected stack profile rules are not being used by agents.
-
-**Solution:**
-
-- The stack profile is only applied during initial installation or upgrade. Run:
-    ```bash
-    sdd-toolkit upgrade
-    ```
-    Ensure you select the same stack profile again.
-
-### `.sdd-toolkit/` folder not created
+### `.sdd-toolkit/` folder not created
 
 **Problem:** The hidden folder structure is not created after installation.
 
@@ -356,9 +343,9 @@ MIT
 
 A: Yes! You can install agents for multiple AI tools in the same project. Each tool has its own folder structure (`.roo/`, `.cline/`, `.cursor/`, etc.) and they can coexist without conflicts.
 
-**Q: How do I update agents after initial setup?**
-
-A: Run `sdd-toolkit upgrade`. This will update all installed agents without requiring you to reconfigure your stack profile or global rules.
+**Q: How do I update agents after initial setup?**
+
+A: Run `sdd-toolkit upgrade`. This will update all installed agents without requiring you to reconfigure global rules.
 
 **Q: Can I customize agent definitions?**
 
@@ -384,10 +371,10 @@ A: Simply delete the `.sdd-toolkit/` folder and any tool-specific folders (`.roo
 
 A: No, sdd-toolkit only manages documentation and AI agent configurations. It does not track code changes, read your source files, or interfere with version control.
 
-**Q: Can I add my own stack profiles?**
-
-A: Currently, stack profiles are hardcoded in the toolkit. To add a custom profile, you can use the "Global Rules" feature during setup to inject your own conventions, or you can fork the repository and add your profile to `src/lib/profiles.js`.
-
-**Q: Is this suitable for enterprise projects?**
+**Q: How do I define my tech stack and conventions?**
+
+A: Use the Requirements Engineer agent (`/sdd.requirements`) to define your tech stack. The agent will interview you with detailed questions about frontend, backend, database, and infrastructure. Stack-specific conventions can also be added via "Global Rules" during setup or by manually editing `.sdd-toolkit/requirements.md`.
 
-A: Yes, sdd-toolkit is designed to scale. The `.sdd-toolkit/` folder can be committed to your repository, ensuring all team members use the same agent configurations and follow the same development principles defined in `guidelines.md`.
+**Q: Is this suitable for enterprise projects?**
+
+A: Yes, sdd-toolkit is designed to scale. The `.sdd-toolkit/` folder can be committed to your repository, ensuring all team members use the same agent configurations and follow the same development principles defined in `requirements.md` and `project.md`. Stack-specific conventions are automatically applied via selected profile during agent installation.

package/definitions/sdd-coder.yaml

@@ -15,15 +15,14 @@ systemPrompt: |
 
   # INPUT CONTEXT - LAYERED READING PROTOCOL
 
-  ## L1: Global Context (ALWAYS READ - 3 files)
+  ## L1: Global Context (ALWAYS READ - 2 files)
   1. Read `.sdd-toolkit/context.md` (Feature matrix + executive summary)
   2. Read `.sdd-toolkit/requirements.md` (Tech stack + business rules)
-  3. Read `.sdd-toolkit/guidelines.md` (Code conventions)
 
   ## L2: Feature Context (READ IF WORKING ON FEATURE - 3 files)
-  4. Read `.sdd-toolkit/features/[feature-slug]/index.md` (Feature overview)
-  5. Read `.sdd-toolkit/features/[feature-slug]/state.md` (Progress + context + files)
-  6. Read `.sdd-toolkit/features/[feature-slug]/[MILESTONE].md` (Tasks from Task_ID)
+  3. Read `.sdd-toolkit/features/[feature-slug]/index.md` (Feature overview)
+  4. Read `.sdd-toolkit/features/[feature-slug]/state.md` (Progress + context + files)
+  5. Read `.sdd-toolkit/features/[feature-slug]/[MILESTONE].md` (Tasks from Task_ID)
 
   ## L2.1 Validate Feature Files Existence (BEFORE READING)
   Before reading L2 files, verify that feature structure exists:

package/definitions/sdd-project.yaml

@@ -198,7 +198,6 @@ systemPrompt: |
   ├── context.md                # Global feature matrix
   ├── requirements.md           # Tech stack + business rules
   ├── project.md               # Project principles (NEW)
-  ├── guidelines.md             # Code conventions
   └── system.md                # System state (NEW)
   ```
   

package/definitions/sdd-requirements.yaml

@@ -15,9 +15,48 @@ systemPrompt: |
   1. Verify the existence of `.sdd-toolkit/project.md`.
   2. If the project is of type **Formalization (Hybrid)**, ask to see examples of error logs, current database schemas, or existing API documentation to ensure requirements respect the legacy system.
 
+  ## Stack Definition Protocol (New - Enhanced)
+  Before generating requirements, check if Tech Stack is already defined in `.sdd-toolkit/requirements.md`:
+
+  ### If Tech Stack is UNDEFINED:
+  You MUST interview the user with DETAILED questions (Mode 3 - Stack Interview):
+
+  #### Frontend Stack:
+  1. **Framework:** React, Vue, Angular, Next.js, SvelteKit, Nuxt.js, None
+  2. **Styling:** Tailwind CSS, CSS Modules, Styled Components, SCSS, None
+  3. **State Management:** Redux, Zustand, Pinia, NgRx, Context API, None
+  4. **Testing:** Jest + Testing Library, Vitest, Cypress, Playwright, None
+  5. **Build Tool:** Vite, Webpack, Next.js built-in, None
+
+  #### Backend Stack:
+  1. **Language:** JavaScript/Node.js, TypeScript, Python, Go, Java, C#, Rust, Other
+  2. **Framework:** Express, NestJS, FastAPI, Django, Spring Boot, .NET, Gin, Fiber, None
+  3. **API Style:** RESTful, GraphQL, gRPC, None
+  4. **Authentication:** JWT, OAuth 2.0, Session-based, None
+  5. **Testing:** Jest, Pytest, Go test, JUnit, NUnit, None
+
+  #### Database & Storage:
+  1. **Primary Database:** PostgreSQL, MySQL, MongoDB, SQLite, Redis, TBD
+  2. **ORM:** Prisma, SQLAlchemy, TypeORM, Mongoose, GORM, None
+  3. **Migration Tool:** Prisma Migrate, Alembic, Flyway, None
+
+  #### DevOps & Infrastructure:
+  1. **Containerization:** Docker, Podman, None
+  2. **CI/CD:** GitHub Actions, GitLab CI, Jenkins, None
+  3. **Hosting:** Vercel, Netlify, AWS, Railway, Render, None
+
+  **Interview Rules:**
+  - Ask ONE question at a time
+  - Wait for user response before asking next
+  - If user answers "TBD" or "None", document as TBD
+  - If user answers "Other", ask for clarification
+
+  ### If Tech Stack is ALREADY DEFINED:
+  Respect the defined stack and do NOT re-interview the user.
+
   ## Golden Constraints (Hard Rules)
   * **Scope Fidelity:** If something is not in `project.md`, you cannot create requirements for it. If you notice a gap, ask the user to return to the Project Architect.
-  * **Tech Agnostic:** You do not decide if the database is SQL or NoSQL. You define the need: _"The system must persist data transactionally"_.
+  * **Tech Agnostic:** You do not auto-decide if the database is SQL or NoSQL. If tech stack is NOT defined in requirements.md, use Stack Definition Protocol to ask the user. If already defined, respect the defined stack.
   * **Code Prohibition:** You never write code.
 
   ## Modes of Operation
@@ -35,37 +74,63 @@ systemPrompt: |
   ```markdown
   # 📋 Requirements Specification
 
-  ## 1. Summary and Traceability
+  ## 1. Tech Stack and Standards (Tech Constraints)
+
+  ### Frontend
+  - **Framework:** [React / Vue / Angular / Next.js / SvelteKit / Nuxt.js / None]
+  - **Styling:** [Tailwind CSS / CSS Modules / Styled Components / SCSS / None]
+  - **State Management:** [Redux / Zustand / Pinia / NgRx / Context API / None]
+  - **Testing:** [Jest + Testing Library / Vitest / Cypress / Playwright / None]
+
+  ### Backend
+  - **Language:** [JavaScript / TypeScript / Python / Go / Java / C# / Rust]
+  - **Framework:** [Express / NestJS / FastAPI / Django / Spring Boot / .NET / None]
+  - **API Style:** [RESTful / GraphQL / gRPC / None]
+  - **Authentication:** [JWT / OAuth 2.0 / Session-based / None]
+  - **Testing:** [Jest / Pytest / Go test / JUnit / NUnit / None]
+
+  ### Database & Storage
+  - **Primary Database:** [PostgreSQL / MySQL / MongoDB / SQLite / Redis / TBD]
+  - **ORM:** [Prisma / SQLAlchemy / TypeORM / Mongoose / GORM / None]
+  - **Migration Tool:** [Prisma Migrate / Alembic / Flyway / None]
+
+  ### DevOps & Infrastructure
+  - **Containerization:** [Docker / Podman / None]
+  - **CI/CD:** [GitHub Actions / GitLab CI / Jenkins / None]
+  - **Hosting:** [Vercel / Netlify / AWS / Railway / Render / None]
+
+  ## 2. Summary and Traceability
   - **Project:** [Project Name]
   - **Based on:** `.sdd-toolkit/project.md` (v.X.Y.Z)
 
-  ## 2. Functional Requirements (FR)
+  ## 3. Functional Requirements (FR)
   | ID | Module | Behavior Description | Acceptance Criteria (Checklist) |
   |:---|:---|:---|:---|
   | RF-001 | [Name] | The system must [action] when [trigger]. | - [ ] Criteria 1 <br> - [ ] Criteria 2 |
 
-  ## 3. User Stories (User Perspective)
+  ## 4. User Stories (User Perspective)
   - **As** [persona], **I want** [feature] **so that** [business value].
 
-  ## 4. Non-Functional Requirements (NFR)
+  ## 5. Non-Functional Requirements (NFR)
   - **RNF-001 [Security]:** Technical description of the need.
   - **RNF-002 [Performance]:** E.g.: Response time must not exceed 200ms.
 
-  ## 5. Business Rules (BR) and Validations
+  ## 6. Business Rules (BR) and Validations
   - **RB-001:** [Clear rule, e.g.: "Only over 18s can register"].
   - **RB-002:** [Calculation flow or system states].
 
-  ## 6. Exception Matrix (Edge Cases)
-  - **E-001:** If connection drops during upload, the system must [behavior].
+  ## 7. Exception Matrix (Edge Cases)
+  - **E-001:** If connection drops during upload, system must [behavior].
 
-  ## 7. Rationale and Discarded Items
+  ## 8. Rationale and Discarded Items
   - Justification for requirements that seemed necessary but violated scope.
   ```
 
-rules:
+  rules:
   - "**BE SPECIFIC:** If the user did not define a library, **suggest market standard** for the chosen stack (e.g., If React, suggest React Hook Form), but mark as a suggestion."
   - "**UNIQUE IDS:** Keep IDs (FR-XX, BR-XX)."
   - "**TECH FIRST:** The goal of this step is to lock technical decisions so the programmer (Tasks Agent) does not need to \"invent\" architecture."
+  - "**STACK FIRST:** If tech stack is NOT defined in requirements.md, use Stack Definition Protocol to interview user before documenting requirements. If already defined, respect the stack and do NOT re-interview."
   - "**FILE OPS:** Save strictly as `.sdd-toolkit/requirements.md`."
   - "**DECISIVENESS:** Max 3 clarifying questions. For non-critical details, make an informed assumption (standard market practice) and document it."
   - "Language Adaptability: Respond in English by default. If the user speaks in another language, mirror their language."

package/definitions/sdd-review.yaml

@@ -24,15 +24,14 @@ systemPrompt: |
 
   ## INPUT CONTEXT & WORKFLOW
 
-  ## L1: Global Context (ALWAYS READ - 3 files)
+  ## L1: Global Context (ALWAYS READ - 2 files)
   1. Read `.sdd-toolkit/context.md` (Feature matrix + executive summary)
   2. Read `.sdd-toolkit/requirements.md` (Tech stack + business rules)
-  3. Read `.sdd-toolkit/guidelines.md` (Code conventions)
 
   ## L2: Feature Context (READ IF WORKING ON FEATURE - 3 files)
-  4. Read `.sdd-toolkit/features/[feature-slug]/index.md` (Feature overview)
-  5. Read `.sdd-toolkit/features/[feature-slug]/state.md` (Progress + context + files)
-  6. Read `.sdd-toolkit/features/[feature-slug]/[MILESTONE].md` (Tasks)
+  3. Read `.sdd-toolkit/features/[feature-slug]/index.md` (Feature overview)
+  4. Read `.sdd-toolkit/features/[feature-slug]/state.md` (Progress + context + files)
+  5. Read `.sdd-toolkit/features/[feature-slug]/[MILESTONE].md` (Tasks)
 
   ## L3: Task Context (READ ON DEMAND)
   7. Read `.sdd-toolkit/logs/executions/[Task_ID].md` (Developer execution log)

package/package.json

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

package/src/index.js

@@ -8,7 +8,6 @@ const pc = require('picocolors');
 
 // Internal Modules
 const { loadAgents } = require('./lib/agents');
-const { STACK_PROFILES } = require('./lib/profiles');
 const { setLocale, t, getLocale } = require('./lib/i18n');
 const {
     toGeminiTOML,
@@ -20,7 +19,8 @@ const {
     toClaudeCommand,
     toPlainSystemPrompt,
     toTraeRules,
-    toOpenCodeAgent
+    toOpenCodeSkill,
+    toAntigravitySkill
 } = require('./lib/transformers');
 const { generateWorkflowGuide } = require('./lib/docs');
 const { view } = require('./commands/view');
@@ -72,11 +72,12 @@ async function main() {
         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(), '.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 (tools.length === 0) {
             note(t('UPGRADE.NO_CONFIG'), t('UPGRADE.NO_CONFIG_TITLE'));
         } else {
@@ -102,24 +103,7 @@ async function main() {
         s.stop(pc.red(t('SCAFFOLD.ERROR')));
     }
 
-    // 2. Feature 5: Stack Selection
-    const stackOptions = Object.entries(STACK_PROFILES).map(([key, profile]) => ({
-        value: key,
-        label: profile.label
-    }));
-
-    const stackProfile = await select({
-        message: t('SETUP.STACK_SELECT'),
-        options: stackOptions,
-        initialValue: 'generic'
-    });
-
-    if (typeof stackProfile === 'symbol') {
-        outro(pc.yellow(t('GENERAL.CANCELLED')));
-        process.exit(0);
-    }
-
-    // 3. Feature 3: Global Rules
+    // 2. Feature 3: Global Rules
     const globalRules = await text({
         message: t('SETUP.GLOBAL_RULES'),
         placeholder: t('SETUP.GLOBAL_RULES_HINT'),
@@ -145,7 +129,8 @@ async function main() {
             { 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/commands/*.md' }
+            { value: 'opencode', label: t('TOOLS.OPENCODE'), hint: '.opencode/skills/*' },
+            { value: 'antigravity', label: t('TOOLS.ANTIGRAVITY'), hint: '.antigravity/skills/*' }
         ],
         required: true,
         hint: t('SETUP.TOOL_HINT')
@@ -161,7 +146,7 @@ async function main() {
         process.exit(0);
     }
 
-    await processAgentsInstallation(tools, { stackProfile, globalRules, locale: getLocale() });
+    await processAgentsInstallation(tools, { globalRules, locale: getLocale() });
 
     outro(pc.green(t('SETUP.SUCCESS')));
 }
@@ -193,17 +178,17 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            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);
-                    })
-                );
-            },
+            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 });
@@ -230,31 +215,31 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            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 });
+            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) => {
@@ -263,22 +248,22 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            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);
-            },
+            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 });
@@ -298,51 +283,43 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            opencode: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.opencode', '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);
-                    })
-                );
-
-                // Generate AGENTS.md with interaction rules and agent location
-                const agentsMdPath = path.join(process.cwd(), 'AGENTS.md');
-                let agentsMdContent = `# Interaction Rules
-
-- Always respond to the user in the language they initially interact in; if they interact in English, respond in English, if they interact in Portuguese, respond in Portuguese.
-- If possible, display reasoning in the user's language as well.
-- Be didactic when explaining things, focus on providing complete responses and not just summaries.
-- Whenever possible, provide examples to illustrate concepts.
-
-# Allowed Commands
-
-- Never execute rm or rm -rf commands without confirming with the user.
-- Whenever possible, use more specific commands instead of generic ones.
-- Be cautious when using commands that may affect critical systems, such as shutdown or reboot.
-- For commands that may affect files or directories, always confirm with the user before executing.
-- Never execute commands that require administrative privileges (sudo, admin) without explicit permission from the user.
-- Avoid running background processes or daemons unless explicitly requested.
-- Be cautious when using commands that alter network settings, firewall configurations, or external connections.
-- Always quote file paths that contain spaces to avoid interpretation errors.
-- For package installation commands (npm install, pip install, etc.), confirm that the user has control over dependencies and versions.
-- Avoid irreversible git operations (such as force push or reset --hard) without confirmation.
-
-# Agent Location
-
-Custom agents are located in .opencode/commands/`;
-
-                let userRules = '';
-                if (options.globalRules && options.globalRules.trim()) {
-                    userRules = '\n\n# User Specified Rules\n\n' + options.globalRules.split('\n').filter(line => line.trim()).map(line => '- ' + line.trim()).join('\n');
-                }
-                agentsMdContent += userRules;
-
-                await fsp.writeFile(agentsMdPath, agentsMdContent);
-            }
+            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) {

package/src/lib/agents.js

@@ -1,9 +1,8 @@
-const fs = require('fs/promises');
-const path = require('path');
-const yaml = require('js-yaml');
-const { AgentSchema } = require('./schema');
-const { STACK_PROFILES } = require('./profiles');
-const pc = require('picocolors');
+const fs = require('fs/promises');
+const path = require('path');
+const yaml = require('js-yaml');
+const { AgentSchema } = require('./schema');
+const pc = require('picocolors');
 
 /**
  * Loads and validates all agent definitions from the definitions folder.
@@ -76,18 +75,10 @@ async function loadAgents(options = {}) {
             
             // Normalize slug
             agent.slug = file.replace(/\.ya?ml$/, '').replace(/\./g, '-');
-            agent.originalName = file.replace(/\.ya?ml$/, '');
-            agent.source = source; // Useful metadata for logs
-
-            // Feature 5: Stack Rules Injection
-            if (options.stackProfile && STACK_PROFILES[options.stackProfile]) {
-                const stackRules = STACK_PROFILES[options.stackProfile].rules;
-                if (stackRules && stackRules.length > 0) {
-                    agent.rules = [...agent.rules, ...stackRules];
-                }
-            }
-
-            // Feature 3: Global Rules Injection
+            agent.originalName = file.replace(/\.ya?ml$/, '');
+            agent.source = source; // Useful metadata for logs
+
+            // Feature 3: Global Rules Injection
             if (options.globalRules && typeof options.globalRules === 'string') {
                 const customRules = options.globalRules
                     .split('\n')

package/src/lib/docs.js

@@ -35,7 +35,6 @@ function generateWorkflowGuide(baseDir) {
     const templatesDir = path.join(__dirname, '..', '..', 'templates');
     
     const templateFiles = [
-        { src: 'guidelines.md', dest: 'guidelines.md' },
         { src: 'project.md', dest: 'project.md' },
         { src: 'requirements.md', dest: 'requirements.md' },
         { src: 'context.md', dest: 'context.md' },

package/src/lib/messages.js

@@ -25,10 +25,9 @@ const EN = {
         ERROR: 'Failed to verify workspace structure.',
     },
     SETUP: {
-        STACK_SELECT: 'What is your technology Stack profile?',
         GLOBAL_RULES: 'Do you want to add any Global Rules for ALL agents?',
         GLOBAL_RULES_HINT: 'Ex: Always reply in English; Use Conventional Commits...',
-        TOOL_SELECT: 'Which tools do you want to install the Agents for?',
+        TOOL_SELECT: 'Which tools do you want to install Agents for?',
         TOOL_HINT: 'Space to select, Enter to confirm',
         NO_TOOLS: 'No tools selected. Operation cancelled.',
         SUCCESS: 'Setup completed successfully! 🚀',
@@ -52,7 +51,8 @@ const EN = {
         KILO: 'Kilo Code',
         COPILOT: 'GitHub Copilot',
         WEB: 'OpenAI / Claude',
-        OPENCODE: 'OpenCode',
+        OPENCODE: 'OpenCode (Skills)',
+        ANTIGRAVITY: 'Antigravity (Skills)',
     },
     LANGUAGE_RULES: {
         EN: 'Always reply in English unless told otherwise.',
@@ -99,13 +99,12 @@ const PT_BR = {
         ERROR: 'Falha ao verificar estrutura do workspace.',
     },
     SETUP: {
-        STACK_SELECT: 'Qual é o perfil de tecnologia (Stack)?',
-        GLOBAL_RULES: 'Deseja adicionar Regras Globais para TODOS os agentes?',
-        GLOBAL_RULES_HINT: 'Ex: Sempre responda em Português; Use Conventional Commits...',
-        TOOL_SELECT: 'Para quais ferramentas você deseja instalar os Agentes?',
+        GLOBAL_RULES: 'Deseja adicionar alguma Regra Global para TODOS os agentes?',
+        GLOBAL_RULES_HINT: 'Ex: Sempre responder em Português; Usar Commits Convencionais...',
+        TOOL_SELECT: 'Quais ferramentas você deseja instalar os Agentes?',
         TOOL_HINT: 'Espaço para selecionar, Enter para confirmar',
         NO_TOOLS: 'Nenhuma ferramenta selecionada. Operação cancelada.',
-        SUCCESS: 'Instalação concluída com sucesso! 🚀',
+        SUCCESS: 'Configuração concluída com sucesso! 🚀',
     },
     INSTALL: {
         LOADING: 'Carregando definições...',
@@ -126,7 +125,8 @@ const PT_BR = {
         KILO: 'Kilo Code',
         COPILOT: 'GitHub Copilot',
         WEB: 'OpenAI / Claude',
-        OPENCODE: 'OpenCode',
+        OPENCODE: 'OpenCode (Skills)',
+        ANTIGRAVITY: 'Antigravity (Skills)',
     },
     LANGUAGE_RULES: {
         EN: 'Always reply in English unless told otherwise.',
@@ -173,13 +173,12 @@ const ES = {
         ERROR: 'Fallo al verificar estructura del espacio de trabajo.',
     },
     SETUP: {
-        STACK_SELECT: '¿Cuál es su perfil tecnológico (Stack)?',
-        GLOBAL_RULES: '¿Desea agregar Reglas Globales para TODOS los agentes?',
-        GLOBAL_RULES_HINT: 'Ej: Siempre responda en Español; Use Conventional Commits...',
-        TOOL_SELECT: '¿Para qué herramientas desea instalar los Agentes?',
+        GLOBAL_RULES: '¿Desea agregar alguna Regla Global para TODOS los agentes?',
+        GLOBAL_RULES_HINT: 'Ej: Siempre responder en Español; Usar Commits Convencionales...',
+        TOOL_SELECT: '¿Qué herramientas desea instalar los Agentes?',
         TOOL_HINT: 'Espacio para seleccionar, Enter para confirmar',
         NO_TOOLS: 'Ninguna herramienta seleccionada. Operación cancelada.',
-        SUCCESS: '¡Instalación completada con éxito! 🚀',
+        SUCCESS: '¡Configuración completada con éxito! 🚀',
     },
     INSTALL: {
         LOADING: 'Cargando definiciones...',
@@ -200,7 +199,8 @@ const ES = {
         KILO: 'Kilo Code',
         COPILOT: 'GitHub Copilot',
         WEB: 'OpenAI / Claude',
-        OPENCODE: 'OpenCode',
+        OPENCODE: 'OpenCode (Skills)',
+        ANTIGRAVITY: 'Antigravity (Skills)',
     },
     LANGUAGE_RULES: {
         EN: 'Always reply in English unless told otherwise.',

package/src/lib/transformers.js

@@ -252,44 +252,34 @@ ${allRules.length > 0 ? '## Constraints\n' + allRules.map(r => `- ${r}`).join('\
 `;
 }
 
+
 /**
- * Converte para OpenCode Agent (.opencode/agent/*.md)
+ * Converte para OpenCode Skill (SKILL.md)
+ * Ref: https://opencode.ai/docs/skills/
  */
-function toOpenCodeAgent(agent, options = {}) {
+function toOpenCodeSkill(agent, options = {}) {
     const languageRule = getLanguageRule(options.locale);
     const allRules = [languageRule, ...(agent.rules || [])];
 
-    // Configurar permissões baseado no tipo de agente
-    const isReadOnly = agent.slug.includes('review') || agent.slug.includes('audit') || agent.name.includes('Architect') || agent.role.includes('QA') || agent.role.includes('Review');
-    const tools = {
-        write: !isReadOnly,
-        edit: !isReadOnly,
-        bash: !isReadOnly
-    };
-
-    const frontmatter = {
-        description: agent.description || agent.role,
-        mode: 'subagent',
-        temperature: 0.3,
-        tools
-    };
-
-    const frontmatterStr = Object.entries(frontmatter)
-        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-        .join('\n');
+    // Ensure slug is compliant (lowercase, alphanumeric, single hyphens)
+    const skillName = agent.slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
 
     return `---
-${frontmatterStr}
+name: ${skillName}
+description: ${agent.description || agent.role}
+license: MIT
+compatibility: opencode
+metadata:
+  role: ${agent.role}
 ---
-
 # ${agent.name} ${agent.emoji}
 
 **Role**: ${agent.role}
 
+## Instructions
 ${agent.systemPrompt.trim()}
 
-## Rules
-${allRules.map(rule => `- ${rule}`).join('\n')}
+${allRules.length > 0 ? '## Rules & Guidelines\n' + allRules.map(r => `- ${r}`).join('\n') : ''}
 `;
 }
 
@@ -312,6 +302,29 @@ ${allRules.length > 0 ? '## Constraints\n' + allRules.map(r => `- ${r}`).join('\
 `;
 }
 
+
+/**
+ * Converte para Antigravity Skill (SKILL.md)
+ */
+function toAntigravitySkill(agent, options = {}) {
+    const languageRule = getLanguageRule(options.locale);
+    const allRules = [languageRule, ...(agent.rules || [])];
+
+    return `---
+name: ${agent.name}
+description: ${agent.description || agent.role}
+---
+# ${agent.name} ${agent.emoji}
+
+**Role**: ${agent.role}
+
+## Instructions
+${agent.systemPrompt.trim()}
+
+${allRules.length > 0 ? '## Rules & Guidelines\n' + allRules.map(r => `- ${r}`).join('\n') : ''}
+`;
+}
+
 module.exports = {
     toGeminiTOML,
     toRooConfig,
@@ -321,6 +334,7 @@ module.exports = {
     toWindsurfRules,
     toClaudeCommand,
     toPlainSystemPrompt,
-    toOpenCodeAgent,
-    toTraeRules
+    toOpenCodeSkill,
+    toTraeRules,
+    toAntigravitySkill
 };

package/src/scripts/reset.js

@@ -8,7 +8,7 @@ console.log('Your source code (src/) will NOT be touched.');
 console.log('Are you sure? (Run with --force to execute)');
 
 if (process.argv.includes('--force')) {
-    ['project.md', 'requirements.md', 'guidelines.md', 'context.md', 'system.md'].forEach(file => {
+    ['project.md', 'requirements.md', 'context.md', 'system.md'].forEach(file => {
         const p = path.join(docsDir, file);
         if (fs.existsSync(p)) {
             fs.unlinkSync(p);

package/templates/requirements.md

@@ -8,6 +8,29 @@ last_updated:
 
 ## 1. Tech Stack and Standards (Tech Constraints)
 
+### Frontend
+- **Framework:** [React / Vue / Angular / Next.js / SvelteKit / Nuxt.js / None]
+- **Styling:** [Tailwind CSS / CSS Modules / Styled Components / SCSS / None]
+- **State Management:** [Redux / Zustand / Pinia / NgRx / Context API / None]
+- **Testing:** [Jest + Testing Library / Vitest / Cypress / Playwright / None]
+
+### Backend
+- **Language:** [JavaScript / TypeScript / Python / Go / Java / C# / Rust]
+- **Framework:** [Express / NestJS / FastAPI / Django / Spring Boot / .NET / None]
+- **API Style:** [RESTful / GraphQL / gRPC / None]
+- **Authentication:** [JWT / OAuth 2.0 / Session-based / None]
+- **Testing:** [Jest / Pytest / Go test / JUnit / NUnit / None]
+
+### Database & Storage
+- **Primary Database:** [PostgreSQL / MySQL / MongoDB / SQLite / Redis / TBD]
+- **ORM:** [Prisma / SQLAlchemy / TypeORM / Mongoose / GORM / None]
+- **Migration Tool:** [Prisma Migrate / Alembic / Flyway / None]
+
+### DevOps & Infrastructure
+- **Containerization:** [Docker / Podman / None]
+- **CI/CD:** [GitHub Actions / GitLab CI / Jenkins / None]
+- **Hosting:** [Vercel / Netlify / AWS / Railway / Render / None]
+
 ## 2. Functional Requirements (FR)
 
 ## 3. Non-Functional Requirements (NFR)

package/src/lib/profiles.js

@@ -1,186 +0,0 @@
-/**
- * Technical Stack Profiles
- * Defines additional rules to be injected into agents
- */
-
-const STACK_PROFILES = {
-    // --- GENERIC ---
-    'generic': {
-        label: '🌐 Generic / None',
-        rules: []
-    },
-
-    // --- FRONTEND ---
-    'frontend-react': {
-        label: '🎨 Frontend: React + Tailwind',
-        rules: [
-            "Prefer Functional Components with Hooks.",
-            "Use Tailwind CSS for styling. Avoid inline styles.",
-            "Ensure accessibility (a11y) standards are met.",
-            "Use strict type checking if TypeScript is enabled.",
-            "Prefer React Query or SWR for data fetching."
-        ]
-    },
-    'frontend-next': {
-        label: '🎨 Frontend: Next.js (App Router)',
-        rules: [
-            "Use App Router directory structure.",
-            "Prefer Server Components by default; use 'use client' only when necessary.",
-            "Optimize images using next/image.",
-            "Use Server Actions for mutations."
-        ]
-    },
-    'frontend-vue': {
-        label: '🎨 Frontend: Vue.js 3 + Pinia',
-        rules: [
-            "Use Composition API with <script setup>.",
-            "Use Pinia for state management.",
-            "Prefer Tailwind CSS or Scoped CSS.",
-            "Follow the Vue Style Guide Priority A rules."
-        ]
-    },
-    'frontend-angular': {
-        label: '🎨 Frontend: Angular',
-        rules: [
-            "Use Standalone Components.",
-            "Prefer Signals over RxJS for synchronous state.",
-            "Strictly follow the Angular Style Guide.",
-            "Use Dependency Injection patterns."
-        ]
-    },
-    'frontend-svelte': {
-        label: '🎨 Frontend: SvelteKit',
-        rules: [
-            "Use Svelte 5 Runes syntax if available.",
-            "Leverage SvelteKit's load functions for server-side data.",
-            "Keep stores simple and derived."
-        ]
-    },
-
-    // --- BACKEND ---
-    'backend-node': {
-        label: '⚙️ Backend: Node.js (Express)',
-        rules: [
-            "Prefer Async/Await over raw Promises.",
-            "Follow Error Handling best practices (don't ignore errors).",
-            "Use Environment Variables for configuration.",
-            "Adhere to RESTful API standards."
-        ]
-    },
-    'backend-nest': {
-        label: '⚙️ Backend: NestJS',
-        rules: [
-            "Use Dependency Injection strictly.",
-            "Follow the module structure.",
-            "Use DTOs with ValidationPipe for all inputs.",
-            "Prefer TypeORM or Prisma for database interaction."
-        ]
-    },
-    'backend-python-fastapi': {
-        label: '⚙️ Backend: Python (FastAPI)',
-        rules: [
-            "Use Pydantic models for data validation.",
-            "Use Type Hints for function arguments and return values.",
-            "Implement async/await for I/O bound operations.",
-            "Follow PEP 8 style guidelines."
-        ]
-    },
-    'backend-python-django': {
-        label: '⚙️ Backend: Python (Django)',
-        rules: [
-            "Use Class-Based Views (CBVs) where appropriate.",
-            "Follow the 'Fat Models, Thin Views' philosophy.",
-            "Use Django ORM optimizations (select_related, prefetch_related).",
-            "Keep settings separated for dev/prod."
-        ]
-    },
-    'backend-java-spring': {
-        label: '⚙️ Backend: Java (Spring Boot)',
-        rules: [
-            "Use constructor injection over @Autowired.",
-            "Follow Google Java Style Guide.",
-            "Use Lombok to reduce boilerplate code.",
-            "Handle exceptions with @ControllerAdvice."
-        ]
-    },
-    'backend-csharp': {
-        label: '⚙️ Backend: C# (.NET Core)',
-        rules: [
-            "Follow Microsoft's C# Coding Conventions.",
-            "Use Async/Await all the way down.",
-            "Prefer LINQ for collection manipulation.",
-            "Use Dependency Injection via IServiceCollection."
-        ]
-    },
-    'backend-go': {
-        label: '⚙️ Backend: Go (Golang)',
-        rules: [
-            "Handle errors explicitly (if err != nil).",
-            "Follow strict formatting (gofmt).",
-            "Prefer standard library over external dependencies when possible.",
-            "Use context for cancellation and timeouts."
-        ]
-    },
-
-    // --- MOBILE ---
-    'mobile-react-native': {
-        label: '📱 Mobile: React Native',
-        rules: [
-            "Use Functional Components and Hooks.",
-            "Avoid bridge passing heavy data.",
-            "Optimize lists with FlatList or FlashList.",
-            "Style using StyleSheet objects or styled-components."
-        ]
-    },
-    'mobile-flutter': {
-        label: '📱 Mobile: Flutter',
-        rules: [
-            "Use const constructors whenever possible.",
-            "Prefer Composition over Inheritance.",
-            "Manage state with Riverpod or BLoC.",
-            "Follow Effective Dart guidelines."
-        ]
-    },
-    'mobile-ios': {
-        label: '📱 Mobile: iOS (SwiftUI)',
-        rules: [
-            "Use MVVM pattern.",
-            "Prefer Structs over Classes for data models.",
-            "Use strict concurrency checking.",
-            "Follow Apple's Human Interface Guidelines."
-        ]
-    },
-    'mobile-android': {
-        label: '📱 Mobile: Android (Kotlin Compose)',
-        rules: [
-            "Use Jetpack Compose for UI.",
-            "Follow Material Design 3 guidelines.",
-            "Use Coroutines and Flow for async work.",
-            "Implement Hilt for Dependency Injection."
-        ]
-    },
-
-    // --- DATA & AI ---
-    'data-python': {
-        label: '📊 Data Science: Python',
-        rules: [
-            "Use Pandas vectorization over loops.",
-            "Document notebooks with Markdown cells explaining logic.",
-            "Use Type Hints even in scripts.",
-            "Prefer Polars for large datasets if possible."
-        ]
-    },
-
-    // --- INFRASTRUCTURE ---
-    'infra-terraform': {
-        label: '☁️ Infra: Terraform',
-        rules: [
-            "Use modules for reusable resources.",
-            "Keep state remote and locked.",
-            "Format code with `terraform fmt`.",
-            "Avoid hardcoding values; use variables."
-        ]
-    }
-};
-
-module.exports = { STACK_PROFILES };

package/templates/guidelines.md

@@ -1,9 +0,0 @@
-# 📜 Project Guidelines
-
-## 🏗️ Architecture Patterns
-
-## 💻 Code Conventions
-
-## 🛠️ Tech Stack & Versions
-
-## 🛡️ Security & Performance