bps-kit 1.0.7 → 1.0.8

package/README.md

@@ -9,17 +9,30 @@ Seu principal diferencial é o **Skill Vault System**: o sistema resolve o limit
 Você pode instanciar o "cérebro" da Inteligência Artificial em qualquer repositório executando o cli diretamente:
 
 ```bash
-# Para a stack Web tradicional (39 Skills ultra eficientes)
-npx bps-kit --normal
+# Modo Essencial (Windsurf/Cursor - Web/React/Next - 39 Skills)
+npx bps-kit@latest --normal
 
-# Para a stack Completa Avançada (65 Skills: Python, Pentest, DevOps, Data)
-npx bps-kit --extra
+# Modo Extra (Windsurf/Cursor - Clout/Sec/Python/QA - 65 Skills)
+npx bps-kit@latest --extra
+
+# Modo Economia Extrema (Windsurf/Cursor - Apenas 11 Skills Cognitivas)
+npx bps-kit@latest --basic
+
+# Integrar para VS Code (GitHub Copilot)
+# Adicione a flag --vscode com qualquer um dos perfis acima:
+npx bps-kit@latest --basic --vscode
 ```
 
-### O que acontece após a instalação?
+### O que acontece após a instalação? (Windsurf / Cursor)
 - A pasta `.agents/` será criada na raiz do seu repositório.
 - Nela residirá o seu `GEMINI.md` master, as pastas de `agents`, `scripts`, `workflows`, `skills` (Ativas) e `vault` (Inativas + Index).
-- A IA que ler sua base de código (ex: Antigravity no editor Windsurf ou Cursor) passará instantaneamente a obedecer essas diretrizes, possuindo validação lint e audit out-of-the-box.
+
+### O que acontece após a instalação? (VS Code / Copilot)
+Se você adicionou a flag `--vscode`, a arquitetura compilada será moldada paras as regras nativas da nuvem do GitHub:
+- As regras-materna e as Workflows irão para o `.github/copilot-instructions.md`.
+- As Skills ativas selecionadas receberão glob patterns (`applyTo: "**/*"`) com extensão `.instructions.md` dentro de `.github/instructions/`.
+- As 20 Personas originais serão fundidas no documento único `.github/AGENTS.md`.
+- E as outras milhares de skills irão para a pasta oculta de segurança `.copilot-vault/` para não saturar seu contexto do chat interno da IDE, além de um index traduzido.
 
 ### 🪄 Autocalibragem de Base de Código (Workflow Analyzer)
 O BPS Kit inclui uma workflow customizada! Após rodar o npx no projeto, apenas diga para a IA no seu chat:

package/bin/cli.js

@@ -9,8 +9,10 @@ const { program } = require('commander');
 program
     .version('1.0.0')
     .description('BPS Kit Installer - The NextGen Modular AI Brain Setup')
-    .option('-n, --normal', 'Instala apenas as skills essenciais (39 skills, ideal para Web/React/Next)')
+    .option('-b, --basic', 'Modo economia extrema (11 skills apenas o core analítico, ideal para Copilot)')
+    .option('-n, --normal', 'Instala as skills essenciais (39 skills, ideal para Web/React/Next)')
     .option('-e, --extra', 'Instala as skills avançadas Premium (65 skills, inclui Python, QA, Cloud e Sec)')
+    .option('--vscode', 'Converte a estrutura final herdada do Cursor/Windsurf (.agents) para o formato do VS Code GitHub Copilot (.github)')
     .parse(process.argv);
 
 const options = program.opts();
@@ -27,10 +29,12 @@ async function runInstaller() {
 
     // Determinar o mode (default normal se nao passar args)
     let mode = 'normal';
-    if (options.extra) {
+    if (options.basic) {
+        mode = 'basic';
+    } else if (options.extra) {
         mode = 'extra';
-    } else if (!options.normal && !options.extra) {
-        console.log(chalk.yellow('⚠️  Nenhum perfil explicitado (--normal ou --extra). Utilizando default: --normal\\n'));
+    } else if (!options.normal && !options.extra && !options.basic) {
+        console.log(chalk.yellow('⚠️  Nenhum perfil explicitado (--basic, --normal ou --extra). Utilizando default: --normal\n'));
     }
 
     const spinner = ora('Montando diretórios base...').start();
@@ -78,25 +82,32 @@ async function runInstaller() {
 
         spinner.text = `Injetando pacotes de skills do perfil [${chalk.yellow(mode)}]...`;
 
-        // Primeiro copia normais
-        await fs.copy(
-            path.join(TEMPLATES_DIR, 'skills_normal'),
-            skillsDest
-        );
+        // Copiar pacote baseado no mode
+        if (mode === 'basic') {
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_basic'), skillsDest);
+        } else if (mode === 'normal') {
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_normal'), skillsDest);
+        } else if (mode === 'extra') {
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_normal'), skillsDest);
+            await fs.copy(path.join(TEMPLATES_DIR, 'skills_extra'), skillsDest);
+        }
 
-        // Se extra, copia as complementares
-        if (mode === 'extra') {
-            await fs.copy(
-                path.join(TEMPLATES_DIR, 'skills_extra'),
-                skillsDest
-            );
+        // 5. Conversor para VS Code se solicitado
+        if (options.vscode) {
+            spinner.text = `Transformando arquitetura para padrão GitHub Copilot (VS Code)...`;
+            const { convertToVsCode } = require('../src/scripts/convert_to_vscode');
+            await convertToVsCode(DEST_AGENTS, DEST_BASE);
         }
 
         spinner.succeed(chalk.green('Cérebro de IA instanciado com sucesso!'));
 
+        let finalCount = '39';
+        if (mode === 'basic') finalCount = '11';
+        if (mode === 'extra') finalCount = '65';
+
         console.log(chalk.cyan('\n============== [ RESUMO DA INSTALAÇÃO ] =============='));
         console.log(chalk.white(`Perfil Carregado : `) + chalk.greenBright(mode.toUpperCase()));
-        console.log(chalk.white(`Skills Ativas    : `) + chalk.greenBright(mode === 'extra' ? '65' : '39'));
+        console.log(chalk.white(`Skills Ativas    : `) + chalk.greenBright(finalCount));
         console.log(chalk.white(`Skills no Vault  : `) + chalk.greenBright('1197'));
         console.log(chalk.cyan('======================================================'));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bps-kit",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "BPS Kit - The Ultimate Antigravity Brain",
   "bin": {
     "bps-kit": "./bin/cli.js"

package/templates/VAULT_INDEX.md

@@ -1,7 +1,7 @@
 # 🗄️ Vault Index
 
-> 1197 skills in `./.agents/vault/`.
-> To use: `view_file ./.agents/vault/{skill-name}/SKILL.md`
+> 1197 skills in `./.agents/antigravity/vault/`.
+> To use: `view_file ./.agents/antigravity/vault/{skill-name}/SKILL.md`
 
 ## Web & Frontend (53)
 3d-web-experience angular angular-best-practices angular-migration angular-state-management angular-ui-patterns animejs-animation antigravity-design-expert antigravity-workflows baseline-ui chrome-extension-developer cloudflare-workers-expert design-md design-orchestration design-spells frontend-dev-guidelines frontend-mobile-development-component-scaffold frontend-mobile-security-xss-scan frontend-security-coder frontend-slides frontend-ui-dark-ts html-injection-testing nextjs-app-router-patterns radix-ui-design-system react-best-practices react-flow-architect react-flow-node-ts react-modernization react-native-architecture react-nextjs-development react-state-management react-ui-patterns spline-3d-integration tailwind-design-system threejs-animation threejs-fundamentals threejs-geometry threejs-interaction threejs-lighting threejs-loaders threejs-materials threejs-postprocessing threejs-shaders threejs-skills threejs-textures ui-skills ui-ux-pro-max ui-visual-validator web-artifacts-builder web-design-guidelines web-scraper web-security-testing webflow-automation

package/templates/agents-template/rules/GEMINI.md

@@ -67,16 +67,16 @@ Agent activated → Check frontmatter "skills:" → Read SKILL.md (INDEX) → Re
 ## 🧠 Skill Auto-Routing System (v8.0.0 — Vault Edition)
 
 ### Architecture
-- **Active skills** (~65): in `./.agents/skills/` — always in context
-- **Vault skills** (~1200+): in `./.agents/vault/` — discoverable via index
+- **Active skills** (~65): in `./.agents/antigravity/skills/` — always in context
+- **Vault skills** (~1200+): in `./.agents/antigravity/vault/` — discoverable via index
 
 ### Core Rule — Skills First
 After invoking any skill, explicitly say: '📖 Using skill: [skill-name]' before proceeding. If no skill was used, say: '⚠️ No skill used — responding from base knowledge.'
 
 ### Routing Flow
 1. Check if an **active skill** covers the request → use it directly
-2. If not → open `./.agents/skills/VAULT_INDEX.md` to find a vault skill
-3. If found → `view_file ./.agents/vault/{name}/SKILL.md`
+2. If not → open `./.agents/antigravity/skills/VAULT_INDEX.md` to find a vault skill
+3. If found → `view_file ./.agents/antigravity/vault/{name}/SKILL.md`
 4. If nothing found → respond from base knowledge
 
 ### Intent → Skill Routing Map (Active Skills)

package/templates/agents-template/scripts/convert_to_vscode.js

@@ -0,0 +1,87 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Converte toda a estrutura .agents importada para .github estrutural do Copilot
+ * @param {string} destAgents O diretorio destino onde a copy crua (.agents) aportou
+ * @param {string} destBase A raiz do repositorio final
+ */
+async function convertToVsCode(destAgents, destBase) {
+    const gitHubDir = path.join(destBase, '.github');
+    const copilotInstructionsDir = path.join(gitHubDir, 'instructions');
+
+    await fs.ensureDir(copilotInstructionsDir);
+
+    console.log(chalk.dim('   [VS Code] Convertendo arquivos para sintaxe do Copilot...'));
+
+    // 1. Converter a rule master GEMINI.md em copilot-instructions.md
+    const geminiPath = path.join(destAgents, 'rules', 'GEMINI.md');
+    if (await fs.pathExists(geminiPath)) {
+        let content = await fs.readFile(geminiPath, 'utf8');
+        // Adaptamos os caminhos na rule principal para o contexto do .github/ do VS Code
+        content = content.replace(/\.\/\.agents\/skills\//g, './.github/instructions/');
+        content = content.replace(/\.\/\.agents\/vault\//g, './.copilot-vault/');
+        content = content.replace(/\.\/\.agents\/rules\/GEMINI\.md/g, './.github/copilot-instructions.md');
+
+        // As workflows no VS Code estao desabrigadas da pasta nativa, sugerimos le-las do vault ou inline
+        content += `\n\n## 🔄 Workflows Base\nAs workflows antigas de Cursor (/brainstorm, etc) agora devem ser invocadas naturalmente no chat: "Rode o fluxo de brainstorm". Consulte o AGENTS.md para contexto.\n`;
+
+        await fs.writeFile(path.join(gitHubDir, 'copilot-instructions.md'), content);
+    }
+
+    // 2. Converter as skills nativas (ativas) em glob .instructions.md
+    const skillsDest = path.join(destAgents, 'skills');
+    if (await fs.pathExists(skillsDest)) {
+        const skillsDirs = await fs.readdir(skillsDest);
+        for (const skillName of skillsDirs) {
+            const skillFile = path.join(skillsDest, skillName, 'SKILL.md');
+            if (await fs.pathExists(skillFile)) {
+                let content = await fs.readFile(skillFile, 'utf8');
+
+                // Injetamos um frontmatter basico aceitavel pelo Copilot apontando para tudo (**/*) 
+                // para que a Skill ative independente do arquivo no Workspace se for convocada.
+                const vsCodeContent = `---
+description: ${skillName.replace(/-/g, ' ')}
+applyTo: "**/*"
+---
+${content}`;
+                await fs.writeFile(path.join(copilotInstructionsDir, `${skillName}.instructions.md`), vsCodeContent);
+            }
+        }
+    }
+
+    // 3. Converter o Vault Index (Tudo que esta no index vira uma mera instruction text base local)
+    const vaultIndexSrc = path.join(destAgents, 'VAULT_INDEX.md');
+    if (await fs.pathExists(vaultIndexSrc)) {
+        let content = await fs.readFile(vaultIndexSrc, 'utf8');
+        content = content.replace(/\.\/\.agents\/vault\//g, './.copilot-vault/');
+        await fs.writeFile(path.join(copilotInstructionsDir, 'VAULT_INDEX.instructions.md'), content);
+    }
+
+    // 4. Mover o Vault inteiro para uma pasta customizada oculta que nao polua a base restrita do Git / do Copilot local
+    const vaultSrc = path.join(destAgents, 'vault');
+    const copilotVaultDir = path.join(destBase, '.copilot-vault');
+    if (await fs.pathExists(vaultSrc)) {
+        await fs.move(vaultSrc, copilotVaultDir, { overwrite: true });
+    }
+
+    // 5. Consolidar as 20 personas (AGENTS) num unico arquivao master na root do github chamado AGENTS.md
+    const agentsSrc = path.join(destAgents, 'agents');
+    if (await fs.pathExists(agentsSrc)) {
+        const agentFiles = await fs.readdir(agentsSrc);
+        let consolidatedAgents = `# 🤖 Antigravity Copilot Agents Roster\n\n`;
+        for (const agent of agentFiles) {
+            if (agent.endsWith('.md')) {
+                const content = await fs.readFile(path.join(agentsSrc, agent), 'utf8');
+                consolidatedAgents += `\n## Agent: ${agent.replace('.md', '')}\n${content}\n---\n`;
+            }
+        }
+        await fs.writeFile(path.join(gitHubDir, 'AGENTS.md'), consolidatedAgents);
+    }
+
+    // Limpeza pesada! Como o ambiente ja foi migrado de .agents para .github e .copilot-vault, delete a origem da instalacao hibrida.
+    await fs.remove(destAgents);
+}
+
+module.exports = { convertToVsCode };

package/templates/skills_basic/behavioral-modes/SKILL.md

@@ -0,0 +1,247 @@
+---
+name: behavioral-modes
+description: "AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Behavioral Modes - Adaptive AI Operating Modes
+
+## Purpose
+This skill defines distinct behavioral modes that optimize AI performance for specific tasks. Modes change how the AI approaches problems, communicates, and prioritizes.
+
+---
+
+## Available Modes
+
+### 1. 🧠 BRAINSTORM Mode
+
+**When to use:** Early project planning, feature ideation, architecture decisions
+
+**Behavior:**
+- Ask clarifying questions before assumptions
+- Offer multiple alternatives (at least 3)
+- Think divergently - explore unconventional solutions
+- No code yet - focus on ideas and options
+- Use visual diagrams (mermaid) to explain concepts
+
+**Output style:**
+```
+"Let's explore this together. Here are some approaches:
+
+Option A: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+Option B: [description]
+  ✅ Pros: ...
+  ❌ Cons: ...
+
+What resonates with you? Or should we explore a different direction?"
+```
+
+---
+
+### 2. ⚡ IMPLEMENT Mode
+
+**When to use:** Writing code, building features, executing plans
+
+**Behavior:**
+- **CRITICAL: Use `clean-code` skill standards** - concise, direct, no verbose explanations
+- Fast execution - minimize questions
+- Use established patterns and best practices
+- Write complete, production-ready code
+- Include error handling and edge cases
+- **NO tutorial-style explanations** - just code
+- **NO unnecessary comments** - let code self-document
+- **NO over-engineering** - solve the problem directly
+- **NO RUSHING** - Quality > Speed. Read ALL references before coding.
+
+**Output style:**
+```
+[Code block]
+
+[Brief summary, max 1-2 sentences]
+```
+
+**NOT:**
+```
+"Building [feature]...
+
+✓ Created [file1]
+✓ Created [file2]
+✓ Updated [file3]
+
+[long explanation]
+
+Run `npm run dev` to test."
+```
+
+---
+
+### 3. 🔍 DEBUG Mode
+
+**When to use:** Fixing bugs, troubleshooting errors, investigating issues
+
+**Behavior:**
+- Ask for error messages and reproduction steps
+- Think systematically - check logs, trace data flow
+- Form hypothesis → test → verify
+- Explain the root cause, not just the fix
+- Prevent future occurrences
+
+**Output style:**
+```
+"Investigating...
+
+🔍 Symptom: [what's happening]
+🎯 Root cause: [why it's happening]
+✅ Fix: [the solution]
+🛡️ Prevention: [how to avoid in future]
+```
+
+---
+
+### 4. 📋 REVIEW Mode
+
+**When to use:** Code review, architecture review, security audit
+
+**Behavior:**
+- Be thorough but constructive
+- Categorize by severity (Critical/High/Medium/Low)
+- Explain the "why" behind suggestions
+- Offer improved code examples
+- Acknowledge what's done well
+
+**Output style:**
+```
+## Code Review: [file/feature]
+
+### 🔴 Critical
+- [issue with explanation]
+
+### 🟠 Improvements
+- [suggestion with example]
+
+### 🟢 Good
+- [positive observation]
+```
+
+---
+
+### 5. 📚 TEACH Mode
+
+**When to use:** Explaining concepts, documentation, onboarding
+
+**Behavior:**
+- Explain from fundamentals
+- Use analogies and examples
+- Progress from simple to complex
+- Include practical exercises
+- Check understanding
+
+**Output style:**
+```
+## Understanding [Concept]
+
+### What is it?
+[Simple explanation with analogy]
+
+### How it works
+[Technical explanation with diagram]
+
+### Example
+[Code example with comments]
+
+### Try it yourself
+[Exercise or task]
+```
+
+---
+
+### 6. 🚀 SHIP Mode
+
+**When to use:** Production deployment, final polish, release preparation
+
+**Behavior:**
+- Focus on stability over features
+- Check for missing error handling
+- Verify environment configs
+- Run all tests
+- Create deployment checklist
+
+**Output style:**
+```
+## Pre-Ship Checklist
+
+### ✅ Code Quality
+- [ ] No TypeScript errors
+- [ ] ESLint passing
+- [ ] All tests passing
+
+### ✅ Security
+- [ ] No exposed secrets
+- [ ] Input validation complete
+
+### ✅ Performance
+- [ ] Bundle size acceptable
+- [ ] No console.logs
+
+### 🚀 Ready to deploy
+```
+
+---
+
+## Mode Detection
+
+The AI should automatically detect the appropriate mode based on:
+
+| Trigger | Mode |
+|---------|------|
+| "what if", "ideas", "options" | BRAINSTORM |
+| "build", "create", "add" | IMPLEMENT |
+| "not working", "error", "bug" | DEBUG |
+| "review", "check", "audit" | REVIEW |
+| "explain", "how does", "learn" | TEACH |
+| "deploy", "release", "production" | SHIP |
+
+---
+
+## Multi-Agent Collaboration Patterns (2025)
+
+Modern architectures optimized for agent-to-agent collaboration:
+
+### 1. 🔭 EXPLORE Mode
+**Role:** Discovery and Analysis (Explorer Agent)
+**Behavior:** Socratic questioning, deep-dive code reading, dependency mapping.
+**Output:** `discovery-report.json`, architectural visualization.
+
+### 2. 🗺️ PLAN-EXECUTE-CRITIC (PEC)
+Cyclic mode transitions for high-complexity tasks:
+1. **Planner:** Decomposes the task into atomic steps (`task.md`).
+2. **Executor:** Performs the actual coding (`IMPLEMENT`).
+3. **Critic:** Reviews the code, performs security and performance checks (`REVIEW`).
+
+### 3. 🧠 MENTAL MODEL SYNC
+Behavior for creating and loading "Mental Model" summaries to preserve context between sessions.
+
+---
+
+## Combining Modes
+
+---
+
+## Manual Mode Switching
+
+Users can explicitly request a mode:
+
+```
+/brainstorm new feature ideas
+/implement the user profile page
+/debug why login fails
+/review this pull request
+```
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.