@thiagodiogo/pscode 1.0.0 → 1.0.1

package/pscode/content/dixi/claude-runtime/commands/adr.md

@@ -0,0 +1,75 @@
+# /pstld:adr — Geração de Architecture Decision Record
+
+Você é um arquiteto técnico criando um ADR (Architecture Decision Record) formal para documentar uma decisão arquitetural.
+
+## Passos
+
+1. **Colete a decisão**
+
+   Se o usuário descreveu a decisão como argumento, use-a. Caso contrário, pergunte:
+   - Qual decisão arquitetural precisa ser documentada?
+   - Por que essa decisão está sendo tomada agora?
+   - Quais alternativas foram ou poderiam ser consideradas?
+
+2. **Contextualize com o projeto** (opcional)
+
+   - Leia `.pscode-dixi.yaml` se existir para identificar stack e família do projeto.
+   - Isso ajuda a formatar o ADR com referências corretas à arquitetura do projeto.
+
+3. **Gere o ADR**
+
+   Crie o documento no seguinte formato:
+
+   ```markdown
+   # ADR-NNN: <título descritivo e conciso>
+
+   **Status:** Aceita | Proposta | Obsoleta | Substituída por ADR-XXX
+   **Data:** <data atual>
+   **Contexto:** <stack/módulo afetado, se aplicável>
+
+   ## Contexto
+
+   <Descreve a situação atual, o problema a resolver e as forças em jogo.
+   Inclui restrições técnicas, de negócio ou operacionais relevantes.>
+
+   ## Decisão
+
+   <Enuncia a decisão tomada de forma afirmativa e clara.
+   Ex: "Usaremos X para Y porque Z.">
+
+   ## Alternativas Consideradas
+
+   ### Opção A: <nome>
+   - **Prós:** ...
+   - **Contras:** ...
+
+   ### Opção B: <nome>
+   - **Prós:** ...
+   - **Contras:** ...
+
+   ## Consequências
+
+   ### Positivas
+   - ...
+
+   ### Negativas / Trade-offs
+   - ...
+
+   ### Neutras / Observações
+   - ...
+
+   ## Referências
+   - <links, docs, issues relacionadas>
+   ```
+
+4. **Numbering**
+
+   Pergunte ao usuário qual número usar para o ADR (ADR-001, ADR-002, etc.) ou sugira verificar o diretório `docs/adr/` para o próximo número disponível.
+
+5. **Salvar o arquivo**
+
+   Pergunte se o usuário quer salvar o ADR em:
+   - `docs/adr/ADR-NNN-<slug>.md` (padrão recomendado)
+   - Outro local preferido pelo time
+
+   Se o usuário confirmar, crie o arquivo no local indicado.

package/pscode/content/dixi/claude-runtime/commands/arch-check.md

@@ -0,0 +1,64 @@
+# /pstld:arch-check — Verificação de conformidade arquitetural
+
+Você é um guardião de arquitetura verificando se o código atual respeita as regras definidas para o projeto.
+
+## Passos
+
+1. **Leia o contexto do projeto**
+
+   - Leia `.pscode-dixi.yaml` na raiz do projeto para determinar `stack` e `family`.
+   - Leia `pastelsdd/context/architecture.md` para carregar as regras arquiteturais vigentes.
+   - Se `pastelsdd/context/architecture.md` não existir, informe o usuário e sugira `pscode init --profile dixi` para instalar os context docs.
+
+2. **Determine o escopo da verificação**
+
+   Se o usuário especificou um escopo (arquivo, módulo, camada), foque nele.
+   Caso contrário, pergunte: verificação pontual (mudança atual) ou varredura ampla (módulo/serviço)?
+
+3. **Execute a verificação de acordo com a stack**
+
+   ### Java / Spring (Arquitetura Hexagonal)
+
+   Verifique as seguintes regras (conforme `pastelsdd/context/architecture.md`):
+
+   - **Regra de dependência:** `infrastructure → application → domain`. Imports proibidos:
+     - `domain.*` importando `application.*` ou `infrastructure.*`
+     - `application.*` importando `infrastructure.*`
+   - **Nomenclatura por camada:** entidades sem sufixo em `domain/entity/`, use cases em `application/usecase/`, ports em `application/port/in/` e `application/port/out/`, adapters em `infrastructure/adapter/`
+   - **Pureza do domínio:** `domain/` sem anotações de framework (Spring, JPA, etc.)
+   - **Acesso via interfaces:** adapters acessam `application` somente via ports
+
+   ### React / Next.js (Feature-Sliced Design)
+
+   Verifique as seguintes regras (conforme `pastelsdd/context/architecture.md`):
+
+   - **Isolamento de features:** imports cruzados entre features são proibidos (feature A não importa de feature B)
+   - **Camadas permitidas:** `app → pages → widgets → features → entities → shared`
+   - **Shared é agnóstico:** `shared/` não importa de nenhuma outra camada
+   - **Lógica em pages/app:** lógica de negócio inline em `pages/` ou `app/` é um warning
+
+   ### Stack não detectada
+
+   Execute verificações genéricas: acoplamento excessivo, imports circulares, violações de separação de responsabilidades visíveis no código.
+
+4. **Reporte os resultados**
+
+   ```markdown
+   ## Resultado da Verificação Arquitetural
+
+   **Stack:** <detectada>
+   **Escopo:** <arquivos/módulos analisados>
+
+   ### Violações Encontradas
+   | Arquivo | Linha | Regra Violada | Severidade |
+   |---------|-------|---------------|------------|
+   | ...     | ...   | ...           | ERRO/WARN  |
+
+   ### Conformidades Verificadas ✅
+   - <regra OK>
+
+   ### Recomendações
+   - <ação corretiva para cada violação>
+   ```
+
+5. **Se não houver violações**, confirme que o código está em conformidade com `pastelsdd/context/architecture.md`.

package/pscode/content/dixi/claude-runtime/commands/dod.md

@@ -0,0 +1,66 @@
+# /pstld:dod — Verificação de Definition of Done
+
+Você é um quality gate verificando se o item de trabalho corrente atende todos os critérios de Definition of Done do projeto.
+
+## Passos
+
+1. **Leia os critérios de DoD**
+
+   - Leia `pastelsdd/context/dod.md` para carregar os critérios oficiais de DoD do projeto.
+   - Se `pastelsdd/context/dod.md` não existir, informe o usuário:
+     ```
+     ℹ️  Arquivo pastelsdd/context/dod.md não encontrado.
+     Execute pscode init --profile dixi para instalar os context docs da Dixi.
+     Enquanto isso, usarei critérios genéricos de DoD.
+     ```
+     Use os critérios genéricos listados no passo 3.
+
+2. **Identifique o item em progresso**
+
+   Pergunte ao usuário (se não fornecido como argumento):
+   - Qual é o item sendo avaliado? (nome da feature, ticket JIRA, change do pscode)
+   - Há contexto adicional relevante (PR aberto, branch, change name)?
+
+3. **Verifique cada critério**
+
+   Para cada critério em `pastelsdd/context/dod.md` (ou os genéricos abaixo), avalie o estado atual:
+
+   **Critérios genéricos (usados quando dod.md não existe):**
+   - Código implementado e funcionando
+   - Testes unitários escritos e passando
+   - Testes de integração cobrindo o fluxo principal
+   - Code review realizado ou solicitado
+   - Documentação atualizada (se aplicável)
+   - Sem violações de arquitetura detectadas
+   - Build passando sem erros
+   - Deploy em ambiente de testes validado
+
+4. **Produza o relatório de DoD**
+
+   ```markdown
+   ## Definition of Done — <nome do item>
+
+   **Data:** <data atual>
+   **Fonte dos critérios:** pastelsdd/context/dod.md | critérios genéricos
+
+   | Critério | Status | Observação |
+   |----------|--------|------------|
+   | <critério 1> | ✅ Atendido | ... |
+   | <critério 2> | ❌ Pendente | <o que falta> |
+   | <critério 3> | ⚠️ Parcial  | <o que está incompleto> |
+
+   ### Resumo
+   - ✅ Atendidos: N
+   - ❌ Pendentes: N
+   - ⚠️ Parciais: N
+
+   ### Próximos Passos
+   <lista das ações necessárias para completar os critérios pendentes>
+
+   **Conclusão:** ✅ Pronto para entrega | ❌ Não está pronto — N critérios pendentes
+   ```
+
+5. **Orientação final**
+
+   - Se todos os critérios estiverem atendidos: sugira `/ps:complete` para arquivar a change.
+   - Se houver pendências: liste as ações prioritárias para concluir o item.

package/pscode/content/dixi/claude-runtime/commands/jira-draft.md

@@ -0,0 +1,80 @@
+# /pstld:jira-draft — Criar rascunho de issue JIRA
+
+Você é um assistente de integração JIRA criando uma issue a partir do contexto da change atual.
+
+## Passos
+
+1. **Leia a configuração JIRA local**
+
+   Leia o arquivo `pastelsdd/jira.yaml` na raiz do projeto.
+
+   - **Se o arquivo não existir ou `configured: false`:**
+     ```
+     ℹ️  Integração JIRA não configurada.
+     Execute /pstld:jira-setup para configurar o projeto, tipo de issue e transição "done".
+     ```
+     Encerre aqui.
+
+2. **Identifique a change ativa**
+
+   Verifique se há uma change ativa em `pscode/changes/`. Se houver exatamente uma, use-a. Se houver várias, peça ao usuário para especificar. Se não houver nenhuma, solicite título e descrição manualmente.
+
+   - **Se a change for identificada:** leia `proposal.md` e `.pscode.yaml` para extrair título e contexto.
+   - **Se não houver change:** solicite título e descrição ao usuário antes de continuar.
+
+3. **Verifique disponibilidade do MCP Atlassian**
+
+   Tente obter informações do usuário autenticado:
+
+   ```tool
+   mcp__atlassian__get_current_user
+   ```
+
+   - **Se falhar:**
+     ```
+     ⚠️  MCP Atlassian não está disponível nesta sessão.
+     Verifique se o servidor MCP está configurado em .mcp.json e reinicie o Claude Code.
+     ```
+     Encerre aqui.
+
+4. **Crie a issue JIRA**
+
+   Use os dados de `jira.yaml` (`projectKey`, `defaultIssueType`) e o contexto da change para criar a issue:
+
+   ```tool
+   mcp__atlassian__create_issue
+     project: <projectKey de jira.yaml>
+     summary: <título da change>
+     description: <descrição derivada do proposal.md ou fornecida pelo usuário>
+     issuetype: <defaultIssueType de jira.yaml>
+   ```
+
+5. **Vincule a issue à change**
+
+   Se a issue for criada com sucesso e a change for identificada, grave o `jiraIssueKey` no `.pscode.yaml` da change:
+
+   - Leia o `.pscode.yaml` atual
+   - Adicione ou atualize o campo `jiraIssueKey` com a chave retornada (ex: `PROJ-123`)
+   - Salve o arquivo
+
+6. **Exiba o resultado**
+
+   ```markdown
+   ## Issue JIRA Criada ✅
+
+   **Issue:** <jiraIssueKey>
+   **Título:** <summary>
+   **Projeto:** <projectKey>
+   **Tipo:** <defaultIssueType>
+   **Link:** <url da issue>
+
+   O campo `jiraIssueKey` foi gravado em `.pscode.yaml`.
+   Ao executar `pscode complete`, a issue será transitada para "done" automaticamente.
+   ```
+
+7. **Tratamento de erros**
+
+   Para qualquer falha não coberta acima, exiba uma mensagem descritiva e sugira:
+   - Verificar conectividade de rede
+   - Confirmar permissões do token Atlassian
+   - Verificar `projectKey` e `defaultIssueType` em `pastelsdd/jira.yaml`

package/pscode/content/dixi/claude-runtime/commands/jira-setup.md

@@ -0,0 +1,105 @@
+# /pstld:jira-setup — Configurar integração JIRA
+
+Você é um assistente de configuração JIRA guiando o desenvolvedor na criação ou atualização de `pastelsdd/jira.yaml`.
+
+## Passos
+
+1. **Verifique disponibilidade do MCP Atlassian**
+
+   Tente obter informações do usuário autenticado:
+
+   ```tool
+   mcp__atlassian__get_current_user
+   ```
+
+   - **Se falhar:**
+     ```
+     ⚠️  MCP Atlassian não está disponível nesta sessão.
+     Para configurar, adicione ao .mcp.json do projeto:
+
+     {
+       "mcpServers": {
+         "atlassian": {
+           "command": "npx",
+           "args": ["-y", "mcp-remote", "https://mcp.atlassian.com/v1/sse"]
+         }
+       }
+     }
+
+     Reinicie o Claude Code após adicionar a configuração.
+     ```
+     Encerre aqui.
+
+2. **Leia configuração existente (se houver)**
+
+   Tente ler `pastelsdd/jira.yaml`. Se existir e tiver valores, exiba-os como ponto de partida:
+   ```
+   Configuração atual encontrada:
+     Projeto: <projectKey>
+     Tipo de issue: <defaultIssueType>
+     Transição "done": <transitions.done>
+   ```
+
+3. **Selecione o projeto JIRA**
+
+   Liste os projetos acessíveis:
+
+   ```tool
+   mcp__atlassian__list_projects
+   ```
+
+   Apresente a lista ao usuário e peça para selecionar o projeto padrão para novas issues.
+   Se já houver um `projectKey` configurado, destaque-o como opção atual.
+
+4. **Selecione o tipo de issue padrão**
+
+   Liste os tipos de issue disponíveis para o projeto selecionado:
+
+   ```tool
+   mcp__atlassian__get_issue_types
+     project: <projectKey selecionado>
+   ```
+
+   Apresente a lista. O tipo padrão usual é "Story" ou "Task" — destaque se disponível.
+
+5. **Selecione a transição "done"**
+
+   Liste as transições disponíveis no workflow do projeto:
+
+   ```tool
+   mcp__atlassian__get_transitions
+     project: <projectKey selecionado>
+   ```
+
+   Apresente as transições e peça ao usuário para identificar qual representa "concluído/done".
+   Grave o **ID numérico** da transição escolhida (não o nome, pois IDs são estáveis).
+
+6. **Grave pastelsdd/jira.yaml**
+
+   Crie ou sobrescreva o arquivo com as escolhas:
+
+   ```yaml
+   project_key: "<projectKey>"
+   default_issue_type: "<defaultIssueType>"
+   configured: true
+   transitions:
+     done: "<ID da transição done>"
+   ```
+
+   Preserve quaisquer campos adicionais existentes no arquivo que não foram alterados.
+
+7. **Exiba resumo da configuração**
+
+   ```markdown
+   ## Integração JIRA Configurada ✅
+
+   **Projeto:** <projectKey>
+   **Tipo de issue padrão:** <defaultIssueType>
+   **Transição "done":** <nome> (ID: <id>)
+
+   ### Próximos passos
+   - Use /pstld:jira-draft para criar uma issue JIRA a partir da change atual
+   - Adicione `jiraIssueKey` ao .pscode.yaml de uma change para vinculá-la a uma issue existente
+   - Ao executar `pscode complete`, a issue vinculada será transitada para "done" automaticamente
+   - Use /pstld:jira-sync para verificar a conexão a qualquer momento
+   ```

package/pscode/content/dixi/claude-runtime/commands/jira-sync.md

@@ -0,0 +1,69 @@
+# /pstld:jira-sync — Verificação e sincronização com JIRA
+
+Você é um assistente de integração JIRA verificando a configuração e conexão com o projeto atual.
+
+## Passos
+
+1. **Leia a configuração JIRA local**
+
+   Leia o arquivo `pastelsdd/jira.yaml` na raiz do projeto.
+
+   - **Se o arquivo não existir:** informe o usuário de forma amigável:
+     ```
+     ℹ️  Integração JIRA não configurada.
+     Para configurar, rode: /pstld:jira-setup
+     O arquivo pastelsdd/jira.yaml será criado com suas preferências.
+     ```
+     Encerre aqui.
+
+   - **Se `configured: false`:** informe:
+     ```
+     ⚠️  Integração JIRA presente mas não ativada (configured: false).
+     Edite pastelsdd/jira.yaml e defina configured: true após preencher os campos.
+     ```
+     Mostre o conteúdo atual do arquivo para o usuário revisar. Encerre aqui.
+
+2. **Teste a conexão via MCP Atlassian**
+
+   Se `configured: true`, tente obter informações do usuário autenticado:
+
+   ```tool
+   mcp__atlassian__get_current_user
+   ```
+
+   - **Se o MCP não estiver disponível ou falhar:** informe:
+     ```
+     ⚠️  MCP Atlassian não está disponível nesta sessão.
+     Verifique se o MCP está configurado em .mcp.json e reinicie o Claude Code.
+     Configuração esperada: pastelsdd/jira.yaml → cloudId: <seu-cloud-id>
+     ```
+     Encerre aqui.
+
+3. **Exiba o status da integração**
+
+   Produza um resumo claro:
+
+   ```markdown
+   ## Status da Integração JIRA ✅
+
+   **Usuário autenticado:** <nome do usuário>
+   **Cloud ID:** <cloudId de pastelsdd/jira.yaml>
+   **Projeto padrão:** <projectKey de pastelsdd/jira.yaml>
+   **Tipo de issue padrão:** <defaultIssueType>
+
+   ### Verificações
+   - ✅ pastelsdd/jira.yaml encontrado e configurado
+   - ✅ MCP Atlassian disponível e autenticado
+   - ✅ Conexão com JIRA estabelecida
+
+   ### Próximos passos
+   - Use /pstld:jira-draft para criar um rascunho de issue JIRA
+   - Vincule uma change ao JIRA adicionando jiraIssueKey ao .pscode.yaml
+   ```
+
+4. **Exibição de erros inesperados**
+
+   Para qualquer falha não coberta acima, mostre uma mensagem descritiva e sugira verificar:
+   - A conectividade de rede
+   - As permissões do token Atlassian
+   - O `cloudId` em `pastelsdd/jira.yaml`

package/pscode/content/dixi/claude-runtime/commands/rfc.md

@@ -0,0 +1,73 @@
+# /pstld:rfc — Abertura de RFC estruturado
+
+Você é um arquiteto técnico conduzindo um processo de RFC (Request for Comments) estruturado para o projeto atual.
+
+## Passos
+
+1. **Leia o contexto do projeto**
+
+   - Leia `.pscode-dixi.yaml` na raiz do projeto para determinar `stack` e `family` (java | react | null).
+   - Leia `pastelsdd/context/dev-flow.md` para entender o fluxo de desenvolvimento e as etapas do RFC.
+   - Se `pastelsdd/context/` não existir, continue com orientações genéricas e informe o usuário que os context docs não estão instalados (sugira `pscode init --profile dixi`).
+
+2. **Colete o escopo da mudança**
+
+   Pergunte ao usuário (se não fornecido como argumento):
+   - Qual é o problema ou oportunidade que motiva a mudança?
+   - Qual é o escopo estimado (componente, módulo, serviço, cross-cutting)?
+   - Há restrições de prazo ou dependências externas?
+
+3. **Gere o documento RFC**
+
+   Produza um documento RFC com a seguinte estrutura:
+
+   ```markdown
+   # RFC: <título descritivo>
+
+   **Status:** Rascunho
+   **Autor:** <solicitar ao usuário>
+   **Data:** <data atual>
+   **Stack:** <detectada via .pscode-dixi.yaml ou "não detectada">
+
+   ## Problema
+   <descrição clara do problema ou oportunidade>
+
+   ## Contexto
+   <situação atual, histórico relevante, dependências>
+
+   ## Solução Proposta
+   <descrição da abordagem escolhida>
+
+   ## Alternativas Consideradas
+   | Alternativa | Prós | Contras |
+   |-------------|------|---------|
+   | ...         | ...  | ...     |
+
+   ## Impacto Arquitetural
+   <camadas afetadas, contratos modificados, migrações necessárias>
+   <adaptar com base na stack: hexagonal (Java) ou feature-sliced (React) conforme dev-flow.md>
+
+   ## Plano de Implementação
+   <fases, dependências, marcos>
+
+   ## Critérios de Aceitação
+   - [ ] ...
+
+   ## Riscos
+   | Risco | Probabilidade | Mitigação |
+   |-------|---------------|-----------|
+   | ...   | ...           | ...       |
+
+   ## Referências
+   - pastelsdd/context/dev-flow.md
+   ```
+
+4. **Adapte por stack**
+
+   - **Java/Spring:** mencione impacto em camadas hexagonais (domain/application/infrastructure) e ports afetados.
+   - **React/Next:** mencione impacto em features, shared e páginas (feature-sliced).
+   - **Null/desconhecida:** use seções genéricas sem referência a padrões específicos.
+
+5. **Próximos passos**
+
+   Ao final, liste as próximas ações: refinamento com o time, criação de change via `pscode propose`, ou implementação direta.

package/pscode/content/dixi/claude-runtime/hooks/arch-guard.mjs

@@ -0,0 +1,101 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+function readStdin() {
+  try {
+    return readFileSync(0, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+const cwd = process.cwd();
+const dixiYamlPath = join(cwd, '.pscode-dixi.yaml');
+
+// Gate: exit 0 silently when .pscode-dixi.yaml is absent (non-Dixi projects unaffected)
+if (!existsSync(dixiYamlPath)) {
+  process.exit(0);
+}
+
+let family = null;
+try {
+  const yaml = readFileSync(dixiYamlPath, 'utf-8');
+  const m = yaml.match(/^family:\s*(\S+)/m);
+  if (m) family = m[1].trim();
+} catch {
+  process.exit(0);
+}
+
+if (family !== 'java' && family !== 'react') {
+  process.exit(0);
+}
+
+let input = {};
+try {
+  const raw = readStdin();
+  if (raw.trim()) input = JSON.parse(raw);
+} catch {
+  process.exit(0);
+}
+
+const toolInput = input.tool_input ?? {};
+const rawFilePath = String(toolInput.file_path ?? '');
+const newContent = String(toolInput.new_string ?? toolInput.content ?? '');
+const filePath = rawFilePath.replace(/\\/g, '/');
+
+if (family === 'java') {
+  // Check files in src/**/infrastructure/**
+  if (/\/infrastructure\//.test(filePath)) {
+    const importLines = newContent.split('\n').filter(l => /^\s*import\s+/.test(l));
+    // Violation: import from domain.* but NOT domain.port.*
+    const hasDirectDomainImport = importLines.some(
+      l => /\.domain\./.test(l) && !/\.domain\.port/.test(l)
+    );
+    if (hasDirectDomainImport) {
+      process.stdout.write(
+        `Violação hexagonal: ${rawFilePath} importa diretamente de domain sem porta. Consulte pastelsdd/context/architecture.md\n`
+      );
+      process.exit(2);
+    }
+  }
+  process.exit(0);
+}
+
+if (family === 'react') {
+  // Cross-feature import check for files in src/features/**
+  const featureMatch = filePath.match(/\/features\/([^/]+)/);
+  if (featureMatch) {
+    const currentFeature = featureMatch[1];
+    const importRegex = /from\s+['"]([^'"]+)['"]/g;
+    let m;
+    while ((m = importRegex.exec(newContent)) !== null) {
+      const importPath = m[1];
+      const featureInImport = importPath.match(/features\/([^/']+)/);
+      if (featureInImport && featureInImport[1] !== currentFeature) {
+        process.stdout.write(
+          `Violação feature-sliced: importação cruzada entre features. Consulte pastelsdd/context/architecture.md\n`
+        );
+        process.exit(2);
+      }
+    }
+  }
+
+  // Warning: combined useState+useEffect with large body in src/app/** or src/pages/**
+  if (/\/(app|pages)\//.test(filePath)) {
+    const lines = newContent.split('\n');
+    if (
+      lines.length > 10 &&
+      /useState/.test(newContent) &&
+      /useEffect/.test(newContent)
+    ) {
+      process.stdout.write(
+        `Aviso: lógica inline detectada em page/app. Considere extrair para um hook ou service.\n`
+      );
+      process.exit(1);
+    }
+  }
+
+  process.exit(0);
+}
+
+process.exit(0);

package/pscode/content/dixi/claude-runtime/hooks/jira-context.mjs

@@ -0,0 +1,60 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+function readStdin() {
+  try {
+    return readFileSync(0, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+const cwd = process.cwd();
+
+let input = {};
+try {
+  const raw = readStdin();
+  if (raw.trim()) input = JSON.parse(raw);
+} catch {
+  process.exit(0);
+}
+
+const prompt = String(input.prompt ?? '');
+const ticketMatch = prompt.match(/[A-Z]+-\d+/);
+if (!ticketMatch) {
+  process.exit(0);
+}
+
+const jiraYamlPath = join(cwd, 'pastelsdd', 'jira.yaml');
+if (!existsSync(jiraYamlPath)) {
+  process.exit(0);
+}
+
+let jiraContent = '';
+try {
+  jiraContent = readFileSync(jiraYamlPath, 'utf-8');
+} catch {
+  process.exit(0);
+}
+
+const projectKeyMatch = jiraContent.match(/^project_key:\s*(\S+)/m);
+if (!projectKeyMatch) {
+  process.exit(0);
+}
+
+const ticket = ticketMatch[0];
+const projectKey = projectKeyMatch[1];
+const boardUrlMatch = jiraContent.match(/^board_url:\s*(.+)/m);
+const boardUrl = boardUrlMatch ? boardUrlMatch[1].trim() : null;
+
+const lines = [
+  `[Contexto JIRA]`,
+  `Ticket detectado: ${ticket}`,
+  `Projeto: ${projectKey}`,
+];
+if (boardUrl) {
+  lines.push(`Board: ${boardUrl}`);
+}
+
+process.stdout.write(lines.join('\n') + '\n');
+process.exit(0);