@ggailabs/cli-context 0.5.6 → 1.1.0

package/dist/.context/pt-br/skills/previce/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: zenith-previce
+description: Ciclo de desenvolvimento Zenith (Planning, Review, Execution, Validation, Confirmation, Evolution). O loop inegociável da v1.1.0.
+---
+---
+name: genesis:previce
+description: Main implementation workflow (Planejamento, Revisão, Execução, Validação, Confirmação).
+trigger: |
+  - New feature request
+  - Bug fix implementation
+  - Architectural refactoring
+---
+
+# ⚡ PREVICE Workflow - Genesis Grid AI Labs
+
+Este é o workflow mandatório para o desenvolvimento no **GG-Framework**. Ele garante governança, qualidade e alinhamento com a visão de **Guilherme Giorgi (GG)**.
+
+## Fases do Ciclo
+
+### 1. P - Planejamento (Planning)
+**Objetivo:** Definir o escopo e a estratégia técnica antes de codar.
+- **Ação:** O agente `genesis:architect` deve criar um arquivo de plano em `.context/plans/[YYYY-MM-DD]-[feature-name].md`.
+- **Conteúdo:** Objetivo, arquivos afetados, agent lineup e passos detalhados (bite-sized).
+
+### 2. R - Revisão (Review)
+**Objetivo:** Validação humana (GG) do plano técnico.
+- **Ação:** Notificar o usuário para revisar o plano gerado.
+- **Critério de Saída:** Aprovação explícita do usuário.
+
+### 3. E - Execução (Execution)
+**Objetivo:** Implementação do código seguindo o plano.
+- **Ação:** Executar os passos do plano um a um.
+- **Ação:** Executar os passos do plano um a um.
+- **Regra:** Usar agentes especialistas (`genesis:ui_specialist`, `genesis:code_archaeologist`, `genesis:penetration_tester`) conforme necessário.
+
+### 4. V - Validação (Validation)
+**Objetivo:** Garantir que a implementação está correta e segura.
+- **Ação:** Rodar testes (unitários/E2E) e realizar o check visual do Genesis Design System.
+- **Ação:** Rodar testes (unitários/E2E) e realizar o check visual do Genesis Design System.
+- **Ferramenta:** Usar `genesis:qa_specialist` para auditoria de estabilidade.
+
+### 5. C - Confirmação (Confirmation)
+**Objetivo:** Finalização e entrega.
+- **Ação:** Realizar o commit com mensagem padronizada e informar ao usuário o sucesso da tarefa.
+
+## Regras de Execução
+- **TODO Tracking:** Use um arquivo `task.md` ou similar para rastrear o progresso de cada fase.
+- **Context Preservation:** Mantenha o estado do workflow em `.context/workflow/state.json`.
+
+---
+*Genesis Grid AI Labs - Efficiency by Design.*

package/dist/.context/pt-br/skills/tdd/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: zenith:tdd
+description: Fluxo de desenvolvimento orientado a testes (Red-Green-Refactor). Use para garantir 100% de cobertura em lógica crítica.
+---
+---
+name: zenith:tdd
+description: |
+  Metodologia de implementação RED-GREEN-REFACTOR - escreva o teste que falha primeiro, 
+  implementação mínima para passar e, em seguida, refatore. Garante que os testes verifiquem o comportamento.
+
+trigger: |
+  - Iniciando implementação de nova funcionalidade
+  - Iniciando implementação de bugfix
+  - Escrevendo novo código de produção
+
+skip_when: |
+  - Revisando/modificando testes existentes → use padrões de teste
+  - Código já existe sem testes → adicione testes primeiro, depois TDD para novo código
+  - Trabalho exploratório/spike → considere brainstorming primeiro
+
+sequence:
+  after: [writing_plans]
+  before: [verification_before_completion]
+
+related:
+  similar: [verification]
+---
+
+# 🧪 Test-Driven Development (TDD)
+
+## Visão Geral
+
+Escreva o teste primeiro. Veja-o falhar. Escreva o código mínimo para passar.
+
+**Princípio Core:** Se você não viu o teste falhar, você não sabe se ele está testando a coisa certa.
+
+## O Ciclo Red-Green-Refactor
+
+1.  **RED**: Escreva um teste minimalista para a nova funcionalidade. Execute o teste e **veja-o falhar**.
+2.  **GREEN**: Escreva apenas o código necessário para fazer o teste passar. Não adicione lógica extra.
+3.  **REFACTOR**: Limpe o código, remova duplicidade e melhore nomes, mantendo os testes em verde.
+
+## Regra de Ouro Zenith
+
+```
+NENHUM CÓDIGO DE PRODUÇÃO SEM UM TESTE QUE FALHA PRIMEIRO.
+```
+
+## Padrões Mandatórios
+
+Esta skill utiliza estes padrões universais:
+- **State Tracking:** Veja [skills/patterns/state_tracking/SKILL.md](file:///.context/pt-br/skills/patterns/state_tracking/SKILL.md)
+- **Failure Recovery:** Veja [skills/patterns/failure_recovery/SKILL.md](file:///.context/pt-br/skills/patterns/failure_recovery/SKILL.md)
+- **Exit Criteria:** Veja [skills/patterns/exit_criteria/SKILL.md](file:///.context/pt-br/skills/patterns/exit_criteria/SKILL.md)
+
+Aplique TODOS os padrões ao usar esta skill.
+
+---
+*Genesis Grid - Qualidade através do Rigor Técnico.*

package/dist/.context/pt-br/skills/using_git_worktrees/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: zenith-using_git_worktrees
+description: Criação e gestão de workspaces isolados via git worktree. Use ao iniciar novas funcionalidades ou mudanças paralelas.
+---
+# 🌲 Skill: Uso de Git Worktrees (v1.1.0)
+
+## 🎯 Objetivo
+Criar e gerenciar ambientes de trabalho isolados utilizando `git worktree` para garantir que o desenvolvimento de novas funcionalidades não polua o workspace principal e permita builds limpos.
+
+## 🛠 Sequência Operacional
+
+### 1. Seleção de Diretório
+A prioridade de diretório para worktrees segue a ordem:
+1.  Pasta existente `.worktrees/` ou `worktrees/` na raiz do projeto.
+2.  Preferência definida no `PROJECT_MAP.md` ou `GEMINI.md`.
+3.  Perguntar ao usuário: `.worktrees/` (local) ou `~/.config/genesis/worktrees/<projeto>/` (global).
+
+### 2. Verificação de Segurança (Mandatório)
+Se o diretório for local (dentro do projeto):
+- **Verificar .gitignore:** `grep -q "^\.worktrees/$\|^worktrees/$" .gitignore`.
+- **Ação Corretiva:** Se não estiver no `.gitignore`, adicione imediatamente, commite e prossiga. *Nunca crie um worktree local sem proteção no git.*
+
+### 3. Criação e Setup
+```bash
+# 1. Criar o worktree
+git worktree add .worktrees/<nome-branch> -b <nome-branch>
+
+# 2. Entrar no ambiente
+cd .worktrees/<nome-branch>
+
+# 3. Setup Automático
+npm install # Detectar via package.json
+```
+
+### 4. Validação de Baseline
+- Antes de começar a codar, rode os testes: `npm test`.
+- Se os testes falharem no baseline, reporte ao usuário antes de prosseguir.
+
+## 🚫 Red Flags
+- **NUNCA** crie um worktree local sem verificar o `.gitignore`.
+- **NUNCA** pule a instalação de dependências ou o teste de baseline no novo worktree.
+- **EVITE** manter worktrees antigos ativos; use a skill de "Cleanup" ao finalizar.
+
+---
+**Protocolo:** v1.1.0 | **Soberania:** Genesis Grid AI Labs

package/dist/.context/pt-br/skills/vulnerability_scanner/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: vulnerability_scanner
+description: Princípios avançados de análise de vulnerabilidades. OWASP 2025, Segurança da Cadeia de Suprimentos (Supply Chain), mapeamento de superfície de ataque e priorização de risco.
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+# 🛡️ Vulnerability Scanner (Soberania Zenit)
+
+> Pense como um atacante, defenda como um mestre. Foco no cenário de ameaças de 2025.
+
+## 📋 Arquivos de Referência
+
+| Arquivo | Propósito |
+|------|---------|
+| `checklists.md` | OWASP Top 10, Auth, API, e Proteção de Dados. |
+
+---
+
+## 1. Mentalidade de Especialista em Segurança
+
+### Princípios Core
+
+| Princípio | Aplicação |
+|-----------|-------------|
+| **Assume Breach** | Desenvolva como se o atacante já estivesse dentro da rede. |
+| **Zero Trust** | Nunca confie, sempre verifique cada requisição. |
+| **Defense in Depth** | Múltiplas camadas de segurança, sem ponto único de falha. |
+| **Least Privilege** | Acesso mínimo necessário para cada função/agente. |
+| **Fail Secure** | Em caso de erro, bloqueie o acesso por padrão. |
+
+---
+
+## 2. OWASP Top 10: 2025 (Foco Zenith)
+
+### Categorias de Risco
+
+| Rank | Categoria | O que auditar? |
+|------|----------|-------------|
+| **A01** | Broken Access Control | Quem acessa o quê? IDOR, SSRF. |
+| **A02** | Security Misconfiguration | Configurações padrão, headers, serviços expostos. |
+| **A03** | Software Supply Chain 🆕 | Dependências, CI/CD, integridade do build. |
+| **A04** | Cryptographic Failures | Cripto fraca, segredos expostos no código. |
+| **A05** | Injection | Input de usuário alimentando comandos do sistema ou DB. |
+
+---
+
+## 3. Segurança da Cadeia de Suprimentos (A03)
+
+### Vetores de Ataque em 2025
+
+- **Dependências Maliciosas**: Audite pacotes novos (`npm audit`).
+- **Arquivos de Lock**: Garanta a integridade dos arquivos de lock nos commits.
+- **Pipeline de Build**: Quem pode modificar seus scripts de CI/CD?
+- **Typosquatting**: Verifique se o nome do pacote está correto.
+
+---
+
+## 4. Metodologia de Escaneamento Zenith
+
+1.  **RECONHECIMENTO**: Entender a stack tecnológica e pontos de entrada.
+2.  **DESCOBERTA**: Identificar padrões de código inseguros.
+3.  **ANÁLISE**: Eliminar falsos positivos e mapear a cadeia de ataque.
+4.  **RELATÓRIO**: Gerar recomendações acionáveis (Pilar VII).
+
+---
+
+## 5. Padrões de Código de Alto Risco
+
+| Padrão | Risco | O que procurar |
+|---------|------|----------|
+| **Concatatação em Queries** | Injeção SQL | `"SELECT * FROM " + input` |
+| **Execução Dinâmica** | RCE | `eval()`, `exec()`, `Function()` |
+| **Deserialização Insegura**| RCE | `pickle.loads()`, `unserialize()` |
+| **Manipulação de Path** | Traversal | Input de usuário em caminhos de arquivo |
+
+---
+
+> **Lembre-se:** Escaneamento automatizado encontra bugs. Pensamento de especialista prioriza o que importa. Sempre pergunte: "O que um atacante faria com isso?".

package/dist/.context/pt-br/skills/writing_plans/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: zenith:writing_plans
+description: Criação de planos de implementação técnica (Design Docs). Use para detalhar mudanças antes de codar.
+---
+---
+name: zenith:writing_plans
+description: |
+  Cria planos de implementação abrangentes com caminhos de arquivo exatos, exemplos de código 
+  completos e etapas de verificação para engenheiros com zero contexto de base de código.
+
+trigger: |
+  - Fase de design concluída (brainstorming/PRD/TRD validado)
+  - Necessidade de criar um detalhamento de tarefas executáveis
+  - Criando trabalho para outros engenheiros ou agentes de IA
+
+skip_when: |
+  - Design não validado → use brainstorming primeiro
+  - Requisitos ainda incertos → use previce primeiro
+  - Já possui um plano → use execução planejada
+
+sequence:
+  after: [brainstorming, previce]
+  before: [executing_plans, subagent_driven_development]
+
+related:
+  similar: [brainstorming]
+---
+
+# 📝 Planejamento de Escrita (Writing Plans)
+
+## Visão Geral
+
+Esta skill despacha um agente especializado para escrever planos de implementação abrangentes para engenheiros com zero contexto da base de código.
+
+**Anuncie no início:** "Estou usando a skill zenith:writing_plans para criar o plano de implementação."
+
+**Contexto:** Isso deve ser executado em uma worktree dedicada (criada pela skill de brainstorming).
+
+## O Processo
+
+**Passo 1: Despachar Agente de Escrita de Plano**
+
+Despache via `Task(subagent_type: "orchestrator", model: "opus")` com:
+- Instruções para criar tarefas atômicas (2-5 min cada)
+- Incluir caminhos de arquivo exatos, código completo, etapas de verificação
+- Salvar em `docs/plans/YYYY-MM-DD-<nome-da-feature>.md`
+
+**Passo 2: Validar Plano**
+
+Após o plano ser salvo, valide-o conforme os 7 Pilares da Metodologia GG.
+
+**Passo 3: Perguntar ao Usuário Sobre a Execução**
+
+Pergunte via `notify_user`: "Executar agora?" Opções:
+1. Executar agora → Despachar especialistas.
+2. Sessão paralela → Usuário abre nova sessão em worktree.
+3. Salvar para depois → Reportar local e encerrar.
+
+## Por Que Usar um Agente?
+
+**Preservação de Contexto** (ler muitos arquivos mantém o supervisor limpo) | **Poder do Modelo** (Capacidade de planejamento abrangente) | **Separação de Preocupações** (supervisor orquestra, agente planeja)
+
+## Seleção de Agentes por Tarefa
+
+| Tipo de Tarefa | Agente Zenith |
+|-----------|-------|
+| API/Serviços Backend | `backend_typescript` |
+| Frontend/UI | `frontend_specialist` |
+| Infra/CI/CD/SRE | `devops_specialist` |
+| Testes e QA | `qa_specialist` |
+| Segurança | `security_reviewer` |
+| Arqueologia/Legado | `code_archaeologist` |
+| Fallback | `architect` |
+
+## Padrões Mandatórios
+
+Esta skill utiliza estes padrões universais (Zenith Patterns):
+- **State Tracking:** Veja [skills/patterns/state_tracking/SKILL.md](file:///.context/pt-br/skills/patterns/state_tracking/SKILL.md)
+- **Failure Recovery:** Veja [skills/patterns/failure_recovery/SKILL.md](file:///.context/pt-br/skills/patterns/failure_recovery/SKILL.md)
+- **Exit Criteria:** Veja [skills/patterns/exit_criteria/SKILL.md](file:///.context/pt-br/skills/patterns/exit_criteria/SKILL.md)
+
+Aplique TODOS os padrões ao usar esta skill.
+
+---
+*Genesis Grid - Excelência em Planejamento Agentico.*

package/dist/commands/init.js

@@ -0,0 +1,159 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import { Scaffolder } from '../services/scaffolder.js';
+export function createInitCommand() {
+    return new Command('init')
+        .description('Inicializa o contexto Genesis Grid em um projeto')
+        .option('-y, --yes', 'Pular perguntas e usar valores padrão')
+        .option('-d, --discovery', 'Ativar modo Discovery (para projetos existentes)')
+        .option('-u, --ui <mode>', 'Nível de Design System (full, mix, core)', 'full')
+        .option('-l, --lang <language>', 'Idioma do contexto (pt-br, eng)', 'pt-br')
+        .option('-o, --output <path>', 'Diretório de saída para o contexto', '.context')
+        .action(async (options) => {
+        const logo = `
+ ${chalk.white(' ██████╗  ██████╗     █████╗ ██╗    ██╗      █████╗ ██████╗ ███████╗')}
+ ${chalk.gray('██╔════╝ ██╔════╝    ██╔══██╗██║    ██║     ██╔══██╗██╔══██╗██╔════╝')}
+ ${chalk.white('██║  ███╗██║  ███╗   ███████║██║    ██║     ███████║██████╔╝███████╗')}
+ ${chalk.gray('██║   ██║██║   ██║   ██╔══██║██║    ██║     ██╔══██║██╔══██╗╚════██║')}
+ ${chalk.white('╚██████╔╝╚██████╔╝██╗██║  ██║██║    ███████╗██║  ██║██████╔╝███████║')}
+ ${chalk.gray(' ╚═════╝  ╚═════╝ ╚═╝╚═╝  ╚═╝╚═╝    ╚══════╝╚═╝  ╚═╝╚═════╝ ╚══════╝')}
+            `;
+        console.log(logo);
+        console.log(`    ${chalk.magenta('Protocol')} ${chalk.white.bold('v1.1.0')} ${chalk.gray('Ready to synchronize...')}\n`);
+        let config = {
+            output: options.output,
+            projectName: 'Genesis Project',
+            framework: 'React',
+            mode: options.discovery ? 'discovery' : 'bootstrap',
+            uiMode: options.ui,
+            language: options.lang
+        };
+        if (!options.yes) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'language',
+                    message: 'Qual o idioma principal do projeto?',
+                    choices: [
+                        { name: '🇧🇷 Português (PT-BR)', value: 'pt-br' },
+                        { name: '🇺🇸 English (ENG)', value: 'eng' }
+                    ],
+                    default: 'pt-br',
+                },
+                {
+                    type: 'list',
+                    name: 'mode',
+                    message: 'O que deseja fazer?',
+                    choices: [
+                        { name: '✨ Bootstrap (Criar novo contexto do zero)', value: 'bootstrap' },
+                        { name: '🔍 Discovery (Mapear evolução de projeto existente)', value: 'discovery' }
+                    ],
+                    default: 'bootstrap',
+                },
+                {
+                    type: 'input',
+                    name: 'projectName',
+                    message: 'Qual o nome deste projeto?',
+                    default: 'Genesis Project',
+                },
+                {
+                    type: 'list',
+                    name: 'framework',
+                    message: 'Qual a Stack/Tecnologia base?',
+                    choices: ['React', 'Next.js', 'Vite/Vanilla', 'NodeJS', 'Outra'],
+                    default: 'React',
+                }
+            ]);
+            config = { ...config, ...answers };
+            // Zenith Tech Stack Orchestration
+            const engineAnswers = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'targetEngines',
+                    message: 'Quais Engines de IA você utilizará? (Orquestração de Sincronia)',
+                    choices: [
+                        { name: 'Cursor (Composer/Rules)', value: 'cursor', checked: true },
+                        { name: 'Gemini (Antigravity/Vertex)', value: 'antigravity', checked: true },
+                        { name: 'Windsurf (Cascade/Codeium)', value: 'windsurf' },
+                        { name: 'OpenAI (Codex/GPTs)', value: 'codex' },
+                        { name: 'Claude Code (Anthropic CLI)', value: 'claude' }
+                    ]
+                }
+            ]);
+            config = { ...config, ...engineAnswers };
+            // Zenith Interactive Orchestration (Deep Feed)
+            if (config.mode === 'discovery') {
+                console.log(chalk.yellow('\n🧠 Iniciando Orquestração Interativa (Deep Feed)...'));
+                const feedAnswers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'modules',
+                        message: 'Quais os principais Módulos/Domains? (ex: auth, components, api)',
+                        default: 'core, ui, auth',
+                    },
+                    {
+                        type: 'input',
+                        name: 'objective',
+                        message: 'Qual o foco da IA agora? (Milestone Objective)',
+                        default: 'Estabilização de arquitetura e novas funcionalidades.',
+                    },
+                    {
+                        type: 'input',
+                        name: 'techDebt',
+                        message: 'Existem Dívidas Técnicas (Tech Debt) críticas a reportar?',
+                        default: 'Nenhum reportada.',
+                    }
+                ]);
+                config.feed = feedAnswers;
+            }
+        }
+        const spinner = ora('Garantindo Soberania do Contexto...').start();
+        try {
+            const scaffolder = new Scaffolder(config);
+            await scaffolder.init();
+            // Se houver feed, injetar no log e no mapa
+            if (config.feed) {
+                const contextDir = path.resolve(process.cwd(), config.output);
+                const logPath = path.join(contextDir, 'docs/OPERATIONS_LOG.md');
+                const mapPath = path.join(contextDir, 'docs/PROJECT_MAP.md');
+                const feed = config.feed;
+                // Injetar no Log
+                const logContent = await fs.readFile(logPath, 'utf-8');
+                const updatedLog = logContent.replace('[Log inicializado via Discovery Mode]', `Objetivo: ${feed.objective}\nDívida Técnica: ${feed.techDebt}`).replace('[Log initialized via Discovery Mode]', `Objective: ${feed.objective}\nTech Debt: ${feed.techDebt}`);
+                await fs.writeFile(logPath, updatedLog);
+                // Atualizar PROJECT_MAP se possível (simplificado para este POC)
+                const mapContent = await fs.readFile(mapPath, 'utf-8');
+                let modulesSection = `\n## 🏛 Domain Architecture (Custom Feed)\n`;
+                feed.modules.split(',').forEach((m) => {
+                    modulesSection += `- \`src/modules/${m.trim()}\`: Módulo identificado via Discovery.\n`;
+                });
+                await fs.writeFile(mapPath, mapContent + modulesSection);
+            }
+            spinner.succeed(chalk.green('Protocolo v1.1.0 ativado em ' + chalk.bold(config.output)));
+            // Exibir Sincronização Agmóstica (Filtrada)
+            const engines = config.targetEngines || ['antigravity', 'cursor', 'windsurf', 'codex', 'claude'];
+            const syncStatus = [
+                { id: 'cursor', name: 'Cursor', color: chalk.blue },
+                { id: 'antigravity', name: 'Gemini', color: chalk.cyan },
+                { id: 'windsurf', name: 'Windsurf', color: chalk.white },
+                { id: 'codex', name: 'Codex', color: chalk.gray },
+                { id: 'claude', name: 'Claude', color: chalk.yellow }
+            ];
+            console.log(chalk.gray('\n📡 Sincronização Agmóstica (Zenith-Sync):'));
+            syncStatus.forEach(s => {
+                const status = engines.includes(s.id) ? chalk.green('Sincronizado ✅') : chalk.gray('Ignorado ⚊');
+                console.log(`   ${s.color('◈')} ${chalk.white(s.name.padEnd(8))} ${status}`);
+            });
+            console.log(chalk.gray('\n✨ Contexto alimentado e pronto para orquestração.'));
+            console.log(chalk.cyan('1. Leia o ') + chalk.white.bold('.context/docs/AGENT_HANDOFF_PROMPT.md') + chalk.cyan(' para o próximo agente.'));
+            console.log(chalk.cyan('2. Rode ') + chalk.white.bold('ggai monitor') + chalk.cyan(' para verificar a saúde do contexto.\n'));
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Falha ao ativar Zenith Protocol: ' + error.message));
+        }
+    });
+}

package/dist/commands/monitor.js

@@ -0,0 +1,34 @@
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { MonitorService } from '../services/monitor-service.js';
+export function createMonitorCommand() {
+    return new Command('monitor')
+        .description('Inicia o Hub de Contexto & Saúde Zenith (v1.1.0)')
+        .option('-c, --context <path>', 'Caminho para a pasta de contexto', '.context')
+        .option('-l, --lang <language>', 'Idioma do dashboard (pt-br, eng)', 'pt-br')
+        .action(async (options) => {
+        let contextPath = options.context;
+        // Auto-discovery: se o default não existe, tenta .context-dist ou outros padrões
+        if (contextPath === '.context' && !(await fs.pathExists(path.join(process.cwd(), contextPath)))) {
+            const alternates = ['.context-dist', '.context-clean', 'context'];
+            for (const alt of alternates) {
+                if (await fs.pathExists(path.join(process.cwd(), alt))) {
+                    contextPath = alt;
+                    break;
+                }
+            }
+        }
+        const monitor = new MonitorService(contextPath, options.lang);
+        try {
+            await monitor.start();
+        }
+        catch (error) {
+            console.error(chalk.red(`\n[Genesis Error] Contexto não encontrado.`));
+            console.log(chalk.gray(`Certifique-se de que o diretório de contexto existe ou especifique via:`));
+            console.log(chalk.cyan(`ggai monitor --context <path>\n`));
+            process.exit(1);
+        }
+    });
+}