specifica-br 1.2.2 → 1.5.0

package/dist/commands/help.js

@@ -1,10 +1,6 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { updateNotifierMiddleware } from '../utils/update-notifier-middleware.js';
-/**
- * Exibe o workflow completo de Spec Driven Development (SDD).
- * Mostra o fluxo detalhado desde a inicialização até a execução de tarefas.
- */
 function showCompleteHelp() {
     console.log('');
     console.log(chalk.cyan.bold('Workflow Completo de Spec Driven Development (SDD)'));
@@ -13,27 +9,50 @@ function showCompleteHelp() {
     console.log(chalk.white('   $ specifica init'));
     console.log(chalk.gray('   Cria estrutura de diretórios e templates no projeto.'));
     console.log('');
-    console.log(chalk.yellow('2. Geração de PRD:'));
+    console.log(chalk.yellow('2. Definição do Contexto:'));
+    console.log(chalk.gray('   Escolha baseada no tipo de projeto:'));
+    console.log('');
+    console.log(chalk.white('   Projeto Novo (Green Field):'));
+    console.log(chalk.white('   /gerar-visao [sua ideia]'));
+    console.log(chalk.gray('   Define Fundação (Contexto + Stack) - Role: Product Manager + Tech Lead - Foco: Visão macro'));
+    console.log('');
+    console.log(chalk.white('   Projeto em Desenvolvimento (Brown Field):'));
+    console.log(chalk.white('   /gerar-contexto'));
+    console.log(chalk.gray('   Analisa código e INFERE (Contexto + Stack) - Role: Engenheiro Senior + Arquiteto - Foco: Análise automática'));
+    console.log('');
+    console.log(chalk.yellow('3. Geração de PRD:'));
     console.log(chalk.white('   /gerar-prd [sua ideia]'));
     console.log(chalk.gray('   Define requisitos funcionais e regras de negócio da feature.'));
     console.log('');
-    console.log(chalk.yellow('3. Geração de Tech Spec:'));
+    console.log(chalk.yellow('4. Geração de Tech Spec:'));
     console.log(chalk.white('   /gerar-techspec [caminho do prd]'));
     console.log(chalk.gray('   Define arquitetura técnica, componentes e plano de implementação.'));
     console.log('');
-    console.log(chalk.yellow('4. Geração de Tarefas:'));
+    console.log(chalk.yellow('5. Geração de Tarefas:'));
     console.log(chalk.white('   /gerar-tasks [caminho do prd] [caminho do tech spec]'));
     console.log(chalk.gray('   Decompõe o plano técnico em tarefas executáveis.'));
     console.log('');
-    console.log(chalk.yellow('5. Execução de Tarefas:'));
-    console.log(chalk.white('   /executar-task [caminho da task] [prd] [tech spec]'));
+    console.log(chalk.yellow('6. Execução de Tarefas:'));
+    console.log(chalk.white('   /executar-task [caminho da task]'));
     console.log(chalk.gray('   Implementa cada tarefa individualmente seguindo a especificação.'));
     console.log('');
+    console.log(chalk.yellow('7. Code Review:'));
+    console.log(chalk.white('   /realizar-codereview'));
+    console.log(chalk.gray('   Realiza code review do código implementado.'));
+    console.log('');
+    console.log(chalk.cyan.bold('Ferramentas de IA suportadas:'));
+    console.log('');
+    console.log(chalk.white('  • ClaudeCode'));
+    console.log(chalk.white('  • Cursor'));
+    console.log(chalk.white('  • Gemini CLI'));
+    console.log(chalk.white('  • Kiro'));
+    console.log(chalk.white('  • OpenCode'));
+    console.log('');
     console.log(chalk.cyan.bold('Benefícios do SDD:'));
     console.log('');
     console.log(chalk.white('  • Documentação antes do código'));
     console.log(chalk.white('  • Redução de retrabalho'));
-    console.log(chalk.white('  • Comunicação alinhada entre times'));
+    console.log(chalk.white('  • Comunicação alinhada entre vezes'));
     console.log('');
 }
 /**
@@ -50,7 +69,7 @@ function runHelpCommand(options) {
         console.log(chalk.white('  specifica-br [options] [command]'));
         console.log('');
         console.log(chalk.cyan.bold('Options:'));
-        console.log(chalk.white('  -V, --version     output the version number'));
+        console.log(chalk.white('  -V, --version     output version number'));
         console.log(chalk.white('  -h, --help        display help for command'));
         console.log('');
         console.log(chalk.cyan.bold('Commands:'));
@@ -58,6 +77,9 @@ function runHelpCommand(options) {
         console.log(chalk.white('  help [command]    display help for command'));
         console.log(chalk.white('  upgrade           Atualiza templates e comandos (em breve)'));
         console.log('');
+        console.log(chalk.cyan.bold('Ferramentas de IA suportadas:'));
+        console.log(chalk.white('  OpenCode, ClaudeCode, Cursor, Gemini CLI, Kiro'));
+        console.log('');
         console.log(chalk.gray('Para ajuda detalhada, use: specifica-br help --completo'));
         console.log('');
     }

package/dist/commands/init.js

@@ -15,60 +15,56 @@ async function runInitCommand() {
     const fileService = new FileService();
     try {
         process.on('SIGINT', handleSigInt);
-        const directoryConventionResponse = await prompts({
+        const toolsMapping = await fileService.loadToolsMapping();
+        const choices = toolsMapping.map(tool => ({
+            title: tool.name,
+            value: tool.name
+        }));
+        const toolResponse = await prompts({
             type: 'select',
-            name: 'directoryConvention',
-            message: 'Selecione a convenção de diretórios para comandos:',
-            choices: [
-                { title: 'Recomendado (OpenCode)', value: 'opencode', description: 'Cria diretório .opencode/commands/ para uso com OpenCode' },
-                { title: 'Agnóstico (Specifica-BR)', value: 'specifica-br', description: 'Cria diretório specifica-br/commands/ para uso em qualquer IDE/IA' }
-            ],
+            name: 'toolName',
+            message: 'Selecione a ferramenta de IA:',
+            choices,
             initial: 0
         });
-        if (!directoryConventionResponse.directoryConvention) {
+        if (!toolResponse.toolName) {
             showErrorMessage('Operação cancelada pelo usuário.');
             process.exit(1);
         }
+        const selectedTool = toolsMapping.find(tool => tool.name === toolResponse.toolName);
+        if (!selectedTool) {
+            showErrorMessage('Erro: Ferramenta não encontrada no mapeamento.');
+            process.exit(1);
+        }
         const answers = {
-            directoryConvention: directoryConventionResponse.directoryConvention
+            toolName: toolResponse.toolName
         };
-        if (answers.directoryConvention === 'opencode') {
-            const toolResponse = await prompts({
-                type: 'select',
-                name: 'tool',
-                message: 'Selecione a ferramenta de IA:',
-                choices: [
-                    { title: 'OpenCode', value: 'opencode' }
-                ],
-                initial: 0
-            });
-            if (!toolResponse.tool) {
-                showErrorMessage('Operação cancelada pelo usuário.');
-                process.exit(1);
-            }
-            const modelResponse = await prompts({
-                type: 'select',
-                name: 'model',
-                message: 'Selecione o modelo de IA:',
-                choices: [
-                    { title: 'GLM 4.7', value: 'glm-4.7' }
-                ],
-                initial: 0
-            });
-            if (!modelResponse.model) {
-                showErrorMessage('Operação cancelada pelo usuário.');
-                process.exit(1);
-            }
-            answers.tool = toolResponse.tool;
-            answers.model = modelResponse.model;
-            console.log('');
-            showInfoMessage(`Ferramenta: ${answers.tool} | Modelo: ${answers.model}`);
+        console.log('');
+        showInfoMessage('Os seguintes diretórios serão criados:');
+        if (selectedTool.commands) {
+            console.log(`  Commands: ${selectedTool.commands} (7 arquivos)`);
+        }
+        if (selectedTool.skills) {
+            console.log(`  Skills:   ${selectedTool.skills} (2 skills com referências)`);
+        }
+        if (selectedTool.templates) {
+            console.log(`  Templates: ${selectedTool.templates} (7 arquivos)`);
+        }
+        console.log('');
+        const confirmResponse = await prompts({
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Deseja continuar?',
+            initial: true
+        });
+        if (!confirmResponse.confirm) {
+            showErrorMessage('Operação cancelada pelo usuário.');
+            process.exit(1);
         }
         console.log('');
         showInfoMessage('Criando estrutura de diretórios...');
-        console.log(`• Convenção selecionada: ${answers.directoryConvention}`);
-        await fileService.createStructure(answers.directoryConvention);
-        showSuccessMessage(answers.directoryConvention);
+        const copyResult = await fileService.createStructure(selectedTool);
+        showSuccessMessage(copyResult);
         showMissionMessage();
     }
     catch (error) {

package/dist/tools-mapping.json

@@ -0,0 +1,32 @@
+[
+  {
+    "name": "ClaudeCode",
+    "commands": ".claude/commands/",
+    "skills": ".claude/skills/",
+    "templates": "specs/templates/"
+  },
+  {
+    "name": "Cursor",
+    "commands": ".cursor/commands/",
+    "skills": ".cursor/skills/",
+    "templates": "specs/templates/"
+  },
+  {
+    "name": "Gemini CLI",
+    "commands": ".gemini/commands/",
+    "skills": ".agents/skills/",
+    "templates": "specs/templates/"
+  },
+  {
+    "name": "Kiro",
+    "commands": ".kiro/commands/",
+    "skills": ".kiro/skills/",
+    "templates": "specs/templates/"
+  },
+  {
+    "name": "OpenCode",
+    "commands": ".opencode/commands/",
+    "skills": ".agents/skills/",
+    "templates": "specs/templates/"
+  }
+]

package/dist/types/init.d.ts

@@ -1,20 +1,17 @@
-/**
- * Interface para as respostas do comando init.
- * Representa as escolhas do usuário durante o fluxo interativo.
- */
+export interface ToolMapping {
+    name: string;
+    commands?: string;
+    skills?: string;
+    templates?: string;
+}
 export interface InitAnswers {
-    directoryConvention: 'opencode' | 'specifica-br';
-    tool?: string;
-    model?: string;
+    toolName: string;
 }
-/**
- * Interface para configuração de templates.
- * Mapeia ferramentas e modelos para os paths de arquivos de comando.
- */
-export interface TemplateConfig {
-    [key: string]: {
-        tool: string;
-        model: string;
-        opencodeCommands: string[];
-    };
+export interface CopyResult {
+    commandsDir: string;
+    commandsCopied: string[];
+    skillsDir?: string;
+    skillsCopied: string[];
+    templatesDir: string;
+    templatesCopied: string[];
 }

package/dist/utils/file-service.d.ts

@@ -1,5 +1,7 @@
+import type { ToolMapping, CopyResult } from '../types/init.js';
 export declare class FileService {
-    createStructure(directoryConvention: 'opencode' | 'specifica-br'): Promise<void>;
-    private createDirectories;
-    private copyTemplates;
+    loadToolsMapping(): Promise<ToolMapping[]>;
+    createStructure(toolMapping: ToolMapping): Promise<CopyResult>;
+    copyDirectoryContents(sourceDir: string, destDir: string): Promise<string[]>;
+    copySkillsRecursively(sourceDir: string, destDir: string): Promise<string[]>;
 }

package/dist/utils/file-service.js

@@ -3,72 +3,184 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export class FileService {
-    async createStructure(directoryConvention) {
-        const commandsDestDir = directoryConvention === 'opencode'
-            ? path.join(process.cwd(), '.opencode', 'commands')
-            : path.join(process.cwd(), 'specifica-br', 'commands');
-        console.log(`• Criando diretórios com convenção: ${directoryConvention}`);
-        await this.createDirectories(commandsDestDir, path.join(process.cwd(), 'specs', 'templates'));
-        await this.copyTemplates(commandsDestDir);
+    async loadToolsMapping() {
+        const mappingPath = path.join(__dirname, '..', 'tools-mapping.json');
+        try {
+            await fs.access(mappingPath);
+        }
+        catch (error) {
+            throw new Error('Erro: Arquivo de mapeamento de ferramentas (tools-mapping.json) não encontrado ou inválido.');
+        }
+        let mappingContent;
+        try {
+            mappingContent = await fs.readFile(mappingPath, 'utf-8');
+        }
+        catch (error) {
+            throw new Error('Erro: Arquivo de mapeamento de ferramentas (tools-mapping.json) não encontrado ou inválido.');
+        }
+        let mappings;
+        try {
+            mappings = JSON.parse(mappingContent);
+        }
+        catch (error) {
+            throw new Error('Erro: Arquivo tools-mapping.json contém JSON inválido.');
+        }
+        if (!Array.isArray(mappings)) {
+            throw new Error('Erro: Arquivo tools-mapping.json com formato inválido.');
+        }
+        if (mappings.length !== 5) {
+            throw new Error('Erro: Arquivo tools-mapping.json com formato inválido.');
+        }
+        for (const mapping of mappings) {
+            if (typeof mapping !== 'object' || mapping === null) {
+                throw new Error('Erro: Arquivo tools-mapping.json com formato inválido.');
+            }
+            const toolMapping = mapping;
+            if (!toolMapping.name || typeof toolMapping.name !== 'string' || toolMapping.name.trim().length === 0) {
+                throw new Error('Erro: Arquivo tools-mapping.json com formato inválido.');
+            }
+            if (toolMapping.commands !== undefined && (typeof toolMapping.commands !== 'string' || toolMapping.commands.trim().length === 0)) {
+                throw new Error('Erro: Arquivo tools-mapping.json com formato inválido.');
+            }
+            if (toolMapping.skills !== undefined && (typeof toolMapping.skills !== 'string' || toolMapping.skills.trim().length === 0)) {
+                throw new Error('Erro: Arquivo tools-mapping.json com formato inválido.');
+            }
+            if (toolMapping.templates !== undefined && (typeof toolMapping.templates !== 'string' || toolMapping.templates.trim().length === 0)) {
+                throw new Error('Erro: Arquivo tools-mapping.json com formato inválido.');
+            }
+        }
+        return mappings;
     }
-    async createDirectories(commandsDestDir, templatesDestDir) {
+    async createStructure(toolMapping) {
+        const boilerplateRoot = path.join(__dirname, '..', 'boilerplate');
+        const commandsCopied = [];
+        const skillsCopied = [];
+        const templatesCopied = [];
+        if (toolMapping.commands) {
+            const sourceDir = path.join(boilerplateRoot, 'commands');
+            const destDir = path.join(process.cwd(), toolMapping.commands);
+            const exists = await fs.pathExists(sourceDir);
+            if (!exists) {
+                throw new Error('Erro: Diretorio de commands não encontrado no boilerplate.');
+            }
+            try {
+                await fs.ensureDir(destDir);
+            }
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'EACCES') {
+                    throw new Error('Erro: Sem permissão para criar diretorios.');
+                }
+                throw error;
+            }
+            const files = await this.copyDirectoryContents(sourceDir, destDir);
+            commandsCopied.push(...files);
+        }
+        if (toolMapping.skills) {
+            const sourceDir = path.join(boilerplateRoot, 'skills');
+            const destDir = path.join(process.cwd(), toolMapping.skills);
+            const exists = await fs.pathExists(sourceDir);
+            if (!exists) {
+                throw new Error('Erro: Diretorio de skills não encontrado no boilerplate.');
+            }
+            try {
+                await fs.ensureDir(destDir);
+            }
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'EACCES') {
+                    throw new Error('Erro: Sem permissão para criar diretorios.');
+                }
+                throw error;
+            }
+            const files = await this.copySkillsRecursively(sourceDir, destDir);
+            skillsCopied.push(...files);
+        }
+        if (toolMapping.templates) {
+            const sourceDir = path.join(boilerplateRoot, 'templates');
+            const destDir = path.join(process.cwd(), toolMapping.templates);
+            const exists = await fs.pathExists(sourceDir);
+            if (!exists) {
+                throw new Error('Erro: Diretorio de templates não encontrado no boilerplate.');
+            }
+            try {
+                await fs.ensureDir(destDir);
+            }
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'EACCES') {
+                    throw new Error('Erro: Sem permissão para criar diretorios.');
+                }
+                throw error;
+            }
+            const files = await this.copyDirectoryContents(sourceDir, destDir);
+            templatesCopied.push(...files);
+        }
+        const result = {
+            commandsDir: toolMapping.commands ? path.join(process.cwd(), toolMapping.commands) : '',
+            commandsCopied,
+            skillsDir: toolMapping.skills ? path.join(process.cwd(), toolMapping.skills) : undefined,
+            skillsCopied,
+            templatesDir: toolMapping.templates ? path.join(process.cwd(), toolMapping.templates) : '',
+            templatesCopied
+        };
+        return result;
+    }
+    async copyDirectoryContents(sourceDir, destDir) {
+        const copiedFiles = [];
         try {
-            await fs.ensureDir(commandsDestDir);
-            console.log(`✓ Diretório criado: ${commandsDestDir}`);
-            await fs.ensureDir(templatesDestDir);
-            console.log(`✓ Diretório criado: ${templatesDestDir}`);
+            const files = await fs.readdir(sourceDir);
+            for (const file of files) {
+                const sourcePath = path.join(sourceDir, file);
+                const destPath = path.join(destDir, file);
+                const stat = await fs.stat(sourcePath);
+                if (stat.isFile()) {
+                    try {
+                        await fs.copy(sourcePath, destPath, { overwrite: true });
+                        copiedFiles.push(file);
+                        console.log(`✓ Arquivo copiado: ${file}`);
+                    }
+                    catch (error) {
+                        if (error instanceof Error && 'code' in error && error.code === 'EACCES') {
+                            throw new Error('Erro: Sem permissão para copiar arquivos.');
+                        }
+                        throw error;
+                    }
+                }
+            }
         }
         catch (error) {
             if (error instanceof Error && 'code' in error && error.code === 'EACCES') {
-                throw new Error('Erro: Sem permissão para criar diretórios.');
+                throw new Error('Erro: Sem permissão para copiar arquivos.');
             }
             throw error;
         }
+        return copiedFiles;
     }
-    async copyTemplates(commandsDestDir) {
-        const distRoot = path.resolve(__dirname, '..', 'boilerplate');
-        const templateFiles = [
-            {
-                source: path.join(distRoot, 'opencode-commands', 'gerar-prd.md'),
-                dest: path.join(commandsDestDir, 'gerar-prd.md')
-            },
-            {
-                source: path.join(distRoot, 'opencode-commands', 'gerar-techspec.md'),
-                dest: path.join(commandsDestDir, 'gerar-techspec.md')
-            },
-            {
-                source: path.join(distRoot, 'opencode-commands', 'gerar-tasks.md'),
-                dest: path.join(commandsDestDir, 'gerar-tasks.md')
-            },
-            {
-                source: path.join(distRoot, 'opencode-commands', 'executar-task.md'),
-                dest: path.join(commandsDestDir, 'executar-task.md')
-            },
-            {
-                source: path.join(distRoot, 'specs-templates', 'prd-template.md'),
-                dest: path.join(process.cwd(), 'specs', 'templates', 'prd-template.md')
-            },
-            {
-                source: path.join(distRoot, 'specs-templates', 'techspec-template.md'),
-                dest: path.join(process.cwd(), 'specs', 'templates', 'techspec-template.md')
-            },
-            {
-                source: path.join(distRoot, 'specs-templates', 'task-template.md'),
-                dest: path.join(process.cwd(), 'specs', 'templates', 'task-template.md')
-            },
-            {
-                source: path.join(distRoot, 'specs-templates', 'tasks-template.md'),
-                dest: path.join(process.cwd(), 'specs', 'templates', 'tasks-template.md')
-            }
-        ];
-        for (const { source, dest } of templateFiles) {
-            if (await fs.pathExists(source)) {
-                await fs.copy(source, dest, { overwrite: true });
-                console.log(`✓ Arquivo copiado: ${path.basename(dest)}`);
-            }
-            else {
-                throw new Error(`Erro: Diretório de templates não encontrado em ${source}`);
+    async copySkillsRecursively(sourceDir, destDir) {
+        const copiedFiles = [];
+        try {
+            await fs.copy(sourceDir, destDir, { overwrite: true });
+            const collectFiles = async (dir, baseDir) => {
+                const items = await fs.readdir(dir);
+                for (const item of items) {
+                    const itemPath = path.join(dir, item);
+                    const stat = await fs.stat(itemPath);
+                    const relativePath = path.relative(baseDir, itemPath);
+                    if (stat.isFile()) {
+                        copiedFiles.push(relativePath);
+                        console.log(`✓ Arquivo copiado: ${relativePath}`);
+                    }
+                    else if (stat.isDirectory()) {
+                        await collectFiles(itemPath, baseDir);
+                    }
+                }
+            };
+            await collectFiles(destDir, destDir);
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'EACCES') {
+                throw new Error('Erro: Sem permissão para copiar arquivos.');
             }
+            throw error;
         }
+        return copiedFiles;
     }
 }

package/dist/utils/message-formatter.d.ts

@@ -1,4 +1,5 @@
-export declare function showSuccessMessage(directoryConvention: 'opencode' | 'specifica-br'): void;
+import type { CopyResult } from '../types/init.js';
+export declare function showSuccessMessage(copyResult: CopyResult): void;
 export declare function showMissionMessage(): void;
 export declare function showErrorMessage(message: string): void;
 export declare function showInfoMessage(message: string): void;

package/dist/utils/message-formatter.js

@@ -1,30 +1,47 @@
 import chalk from 'chalk';
-export function showSuccessMessage(directoryConvention) {
-    const commandDir = directoryConvention === 'opencode'
-        ? '.opencode/commands/'
-        : 'specifica-br/commands/';
+import path from 'path';
+export function showSuccessMessage(copyResult) {
     console.log('');
     console.log(chalk.green.bold('✓ Estrutura SDD criada com sucesso!'));
     console.log('');
     console.log(chalk.gray('Diretórios criados:'));
-    console.log(chalk.gray(`  • ${commandDir}`));
-    console.log(chalk.gray('  • specs/templates/'));
-    console.log('');
-    console.log(chalk.gray('Arquivos de comandos copiados:'));
-    console.log(chalk.gray('  • gerar-prd.md'));
-    console.log(chalk.gray('  • gerar-techspec.md'));
-    console.log(chalk.gray('  • gerar-tasks.md'));
-    console.log(chalk.gray('  • executar-task.md'));
-    console.log('');
-    console.log(chalk.gray('Arquivos de templates copiados:'));
-    console.log(chalk.gray('  • prd-template.md'));
-    console.log(chalk.gray('  • techspec-template.md'));
-    console.log(chalk.gray('  • task-template.md'));
-    console.log(chalk.gray('  • tasks-template.md'));
-    console.log('');
-    console.log(chalk.gray('Para começar, navegue até o diretório de comandos e execute:'));
-    console.log(chalk.gray(`  cd ${commandDir.split('/')[0]}`));
-    console.log('');
+    if (copyResult.commandsDir) {
+        console.log(chalk.gray(`  • ${copyResult.commandsDir}`));
+    }
+    if (copyResult.skillsDir) {
+        console.log(chalk.gray(`  • ${copyResult.skillsDir}`));
+    }
+    if (copyResult.templatesDir) {
+        console.log(chalk.gray(`  • ${copyResult.templatesDir}`));
+    }
+    console.log('');
+    if (copyResult.commandsCopied.length > 0) {
+        console.log(chalk.gray('Arquivos de comandos copiados:'));
+        copyResult.commandsCopied.forEach(file => {
+            console.log(chalk.gray(`  • ${file}`));
+        });
+        console.log('');
+    }
+    if (copyResult.skillsCopied.length > 0) {
+        console.log(chalk.gray('Arquivos de skills copiados:'));
+        copyResult.skillsCopied.forEach(file => {
+            console.log(chalk.gray(`  • ${file}`));
+        });
+        console.log('');
+    }
+    if (copyResult.templatesCopied.length > 0) {
+        console.log(chalk.gray('Arquivos de templates copiados:'));
+        copyResult.templatesCopied.forEach(file => {
+            console.log(chalk.gray(`  • ${file}`));
+        });
+        console.log('');
+    }
+    if (copyResult.commandsDir) {
+        const rootDir = copyResult.commandsDir.split(path.sep)[0];
+        console.log(chalk.gray('Para começar, navegue até o diretório de comandos:'));
+        console.log(chalk.gray(`  cd ${rootDir}`));
+        console.log('');
+    }
 }
 export function showMissionMessage() {
     console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specifica-br",
-  "version": "1.2.2",
+  "version": "1.5.0",
   "description": "Ferramenta de automação para desenvolvimento guiado por especificações (Spec Driven Development - SDD) com IA. Otimizado para o ecossistema brasileiro.",
   "repository": {
     "type": "git",