@thiagodiogo/pscode 1.0.0 → 2.0.0

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);

package/pscode/content/dixi/claude-runtime/skills/pstld-arch-guardian.md

@@ -0,0 +1,101 @@
+# pstld-arch-guardian
+
+## Trigger
+
+Esta skill é auto-invocada **antes de aplicar uma edição** em arquivos que se enquadrem em:
+
+- Java: `src/**/infrastructure/**`
+- React/Next: `src/features/**`, `src/app/**`, `src/pages/**`
+
+---
+
+## Comportamento
+
+### 1. Detectar stack do projeto
+
+Leia `.pscode-dixi.yaml` na raiz do projeto e extraia o campo `family`.
+
+- Se o arquivo **não existir** ou `family` for `null` ou não reconhecido → **não faça nenhuma verificação**, prossiga normalmente.
+- Se `family: java` → aplique verificação hexagonal (seção 2).
+- Se `family: react` → aplique verificação feature-sliced (seção 3).
+
+---
+
+### 2. Verificação hexagonal (Java)
+
+Aplicável quando `family: java` e o arquivo editado está em `src/**/infrastructure/**`.
+
+**Bloqueio — import direto de domain sem porta:**
+
+Verifique se o novo conteúdo do arquivo contém imports de pacotes como:
+- `import ...domain.model.*`
+- `import ...domain.entity.*`
+- `import ...domain.service.*`
+
+...sem passar por uma interface de porta (`domain.port.in.*` ou `domain.port.out.*`).
+
+Se detectar esta violação:
+
+> ❌ **Violação hexagonal detectada**
+>
+> O arquivo `[caminho do arquivo]` importa diretamente de `domain/` sem usar uma porta.
+> A regra de dependência exige que `infrastructure` acesse `domain` apenas via interfaces de porta.
+>
+> Consulte `pastelsdd/context/architecture.md` para a lista de imports permitidos.
+>
+> **A edição foi bloqueada.** Refatore para usar a porta adequada antes de continuar.
+
+**Permitido — import via porta:**
+
+Se o arquivo importa apenas de `domain.port.in.*` ou `domain.port.out.*`, permita a edição sem mensagem.
+
+**Fora de infrastructure:**
+
+Se o arquivo não está em `src/**/infrastructure/**`, não aplique nenhuma verificação hexagonal.
+
+---
+
+### 3. Verificação feature-sliced (React/Next)
+
+Aplicável quando `family: react`.
+
+#### 3a. Import cruzado entre features (bloqueio)
+
+Se o arquivo editado está em `src/features/<feature-a>/` e o novo conteúdo importa de outro diretório sob `src/features/` (ex: `../feature-b/`, `../../features/feature-b/`):
+
+> ❌ **Violação feature-sliced detectada**
+>
+> O arquivo `[caminho]` importa de outra feature (`[feature-b]`).
+> Features devem ser independentes entre si — imports cruzados criam acoplamento proibido.
+>
+> Use `src/shared/` para código reutilizado entre features.
+> Consulte `pastelsdd/context/architecture.md`.
+>
+> **A edição foi bloqueada.**
+
+**Permitido:** imports dentro da mesma feature ou de `src/shared/`.
+
+#### 3b. Lógica de negócio inline em páginas (warning)
+
+Se o arquivo editado está em `src/app/**` ou `src/pages/**` e o novo conteúdo contém qualquer um dos sinais abaixo:
+- Hook `useState` + `useEffect` com corpo de mais de 10 linhas no mesmo componente
+- Função de transformação/validação de dados definida inline no componente (não em hook separado)
+
+Emita aviso (não bloqueie):
+
+> ⚠️ **Atenção — lógica de negócio em página detectada**
+>
+> O componente em `[caminho]` parece conter lógica de negócio inline.
+> Considere extrair para um custom hook em `src/features/` ou `src/shared/hooks/`.
+>
+> Consulte `pastelsdd/context/architecture.md` para o padrão recomendado.
+>
+> A edição foi aplicada, mas revise antes de finalizar.
+
+---
+
+## Comportamento seguro
+
+- Se `.pscode-dixi.yaml` não existe → nenhuma ação, nenhum erro.
+- Se `family` tem valor desconhecido → nenhuma ação.
+- Em nenhuma hipótese esta skill modifica arquivos fora do arquivo-alvo da edição original.

package/pscode/content/dixi/claude-runtime/skills/pstld-commit-crafter.md

@@ -0,0 +1,98 @@
+# pstld-commit-crafter
+
+## Trigger
+
+Esta skill é auto-invocada quando o usuário mencionar **commit** no prompt ou solicitar fazer commit:
+
+- "commit", "fazer commit", "commitar", "cria um commit", "faz o commit", "git commit"
+
+Ative **antes** de executar qualquer `git commit`.
+
+---
+
+## Comportamento
+
+### 1. Detectar stack para inferência de escopo
+
+Leia `.pscode-dixi.yaml` na raiz do projeto e extraia `family`.
+
+**Se `family: java`:**
+- Inspecione os arquivos modificados via `git status` / `git diff --name-only`.
+- Identifique o bounded context pelo diretório após o base package.
+  - Ex: `src/main/java/com/empresa/payment/` → escopo `payment`
+  - Ex: `src/main/java/com/empresa/order/domain/` → escopo `order`
+
+**Se `family: react`:**
+- Identifique o nome da feature pelo diretório em `src/features/`.
+  - Ex: `src/features/user-management/` → escopo `user-management`
+  - Ex: `src/features/checkout/` → escopo `checkout`
+
+**Se `.pscode-dixi.yaml` não existir ou `family` for `null`:**
+- Infira o escopo pelo diretório principal dos arquivos modificados.
+  - Ex: maioria em `src/services/billing/` → escopo `billing`
+  - Ex: maioria em `src/` → escopo do módulo mais frequente nos caminhos
+
+---
+
+### 2. Verificar ticket JIRA
+
+Leia `pastelsdd/jira.yaml` na raiz do projeto.
+
+- Se o arquivo **não existir** ou tiver `configured: false`: mensagem sem ticket JIRA (vá para seção 3).
+- Se tiver `project_key` configurado: o ticket **é obrigatório**.
+
+**Ticket presente no prompt:** use diretamente (ex: usuário mencionou "PROJ-42").
+
+**Ticket ausente no prompt:** pergunte ao usuário:
+
+> Qual o número do ticket JIRA? (ex: 42)
+> O project key configurado é `[PROJECT_KEY]`.
+
+Aguarde a resposta antes de continuar. Monte o sufixo `[PROJECT_KEY-NNN]` com o número fornecido.
+
+---
+
+### 3. Montar a mensagem de commit
+
+Identifique o tipo baseado nos arquivos modificados e no contexto:
+
+| Tipo | Quando usar |
+|------|-------------|
+| `feat` | nova funcionalidade |
+| `fix` | correção de bug |
+| `refactor` | mudança sem alterar comportamento |
+| `test` | adição/correção de testes |
+| `docs` | documentação apenas |
+| `chore` | configuração, build, dependências |
+
+Gere a mensagem no formato:
+
+```
+tipo(escopo): descrição concisa em português ou inglês [PROJECT_KEY-NNN]
+```
+
+Sem ticket quando `pastelsdd/jira.yaml` não configurado:
+
+```
+tipo(escopo): descrição concisa
+```
+
+**Exemplos:**
+- `feat(payment): adiciona validação de cartão de crédito [PROJ-99]`
+- `fix(user-management): corrige redirect após logout [APP-12]`
+- `refactor(order): extrai lógica de cálculo para OrderPricingService [PROJ-55]`
+- `test(checkout): cobre cenário de pedido sem estoque [SHOP-7]`
+
+---
+
+### 4. Apresentar a mensagem ao usuário
+
+Exiba a mensagem proposta e pergunte:
+
+> Mensagem de commit proposta:
+> ```
+> tipo(escopo): descrição [PROJECT_KEY-NNN]
+> ```
+> Deseja usar esta mensagem ou ajustar?
+
+Se o usuário aprovar, execute o commit. Se quiser ajustar, aplique a correção e confirme novamente.

package/pscode/content/dixi/claude-runtime/skills/pstld-jira-context.md

@@ -0,0 +1,64 @@
+# pstld-jira-context
+
+## Trigger
+
+Esta skill é auto-invocada quando o prompt do usuário contém uma string no formato `[A-Z]+-\d+`:
+
+- Exemplos: `PROJ-123`, `MYAPP-42`, `BE-7`, `PAYMENT-1001`
+- A ativação ocorre **antes de gerar a resposta**, para enriquecer o contexto.
+
+Se o prompt não contém nenhum padrão `[A-Z]+-\d+`, a skill não é ativada.
+
+---
+
+## Comportamento
+
+### 1. Verificar configuração JIRA
+
+Leia `pastelsdd/jira.yaml` na raiz do projeto.
+
+**Se o arquivo não existir ou tiver `configured: false`:**
+
+Exiba o seguinte aviso **uma única vez por sessão** (não repita em prompts subsequentes):
+
+> ℹ️ Integração JIRA não configurada — edite `pastelsdd/jira.yaml` para habilitar.
+
+Prossiga sem buscar contexto do ticket.
+
+**Se tiver `configured: true`:** continue para a seção 2.
+
+---
+
+### 2. Buscar contexto do ticket via MCP
+
+Use a ferramenta `mcp__atlassian__getJiraIssue` com a chave detectada no prompt (ex: `PROJ-123`).
+
+**Se o ticket for encontrado**, injete as seguintes informações como contexto adicional **antes** de gerar a resposta:
+
+> **Contexto JIRA — [CHAVE]**
+>
+> **Título:** [título do ticket]
+>
+> **Descrição:**
+> [descrição do ticket]
+>
+> **Critérios de aceite:**
+> [critérios de aceite, se disponíveis]
+
+Em seguida, prossiga normalmente para responder ao prompt do usuário.
+
+---
+
+### 3. Tratamento de erro
+
+**Se `mcp__atlassian__getJiraIssue` retornar erro** (ticket inexistente, permissão negada, MCP indisponível):
+
+> ⚠️ Não foi possível obter contexto de `[CHAVE]`: [mensagem de erro resumida]. Prosseguindo sem contexto JIRA.
+
+Não bloqueie a resposta — prossiga normalmente.
+
+---
+
+## Controle de sessão
+
+O aviso "Integração JIRA não configurada" deve ser exibido **no máximo uma vez por sessão**. Se já foi exibido, omita-o em ativações subsequentes e prossiga em silêncio.

package/pscode/content/dixi/context/java/architecture.md

@@ -0,0 +1,143 @@
+# Arquitetura — Java/Spring (Hexagonal)
+
+## Estrutura de pacotes obrigatória
+
+```
+com.example.app/
+├── domain/
+│   ├── model/          # Entidades, value objects, agregados
+│   ├── port/
+│   │   ├── in/         # Use case interfaces (portas de entrada)
+│   │   └── out/        # Repository, gateway interfaces (portas de saída)
+│   └── exception/      # Exceções de domínio
+├── application/
+│   └── usecase/        # Implementações dos use cases
+└── infrastructure/
+    └── adapter/
+        ├── in/         # Controllers REST, consumers de mensagem
+        └── out/        # Implementations de repository, clientes HTTP
+```
+
+## Regras de dependência
+
+```
+infrastructure → application → domain
+```
+
+- `domain` não importa nada externo ao próprio domínio
+- `application` importa apenas `domain`
+- `infrastructure` importa `application` e `domain`, mas nunca ao contrário
+- Frameworks Spring (anotações, contexto) pertencem à camada `infrastructure`
+
+## Exemplos por camada
+
+### Domain — modelo
+
+```java
+// domain/model/Pedido.java
+public class Pedido {
+    private final PedidoId id;
+    private final List<ItemPedido> itens;
+    private StatusPedido status;
+
+    public void confirmar() {
+        if (itens.isEmpty()) throw new PedidoVazioException();
+        this.status = StatusPedido.CONFIRMADO;
+    }
+}
+```
+
+### Domain — porta de entrada
+
+```java
+// domain/port/in/ConfirmarPedidoUseCase.java
+public interface ConfirmarPedidoUseCase {
+    Pedido confirmar(PedidoId pedidoId);
+}
+```
+
+### Domain — porta de saída
+
+```java
+// domain/port/out/PedidoRepository.java
+public interface PedidoRepository {
+    Optional<Pedido> findById(PedidoId id);
+    Pedido save(Pedido pedido);
+}
+```
+
+### Application — use case
+
+```java
+// application/usecase/ConfirmarPedidoService.java
+@Service
+public class ConfirmarPedidoService implements ConfirmarPedidoUseCase {
+    private final PedidoRepository repository;
+
+    @Override
+    public Pedido confirmar(PedidoId pedidoId) {
+        Pedido pedido = repository.findById(pedidoId)
+            .orElseThrow(() -> new PedidoNaoEncontradoException(pedidoId));
+        pedido.confirmar();
+        return repository.save(pedido);
+    }
+}
+```
+
+### Infrastructure — adapter de entrada
+
+```java
+// infrastructure/adapter/in/PedidoController.java
+@RestController
+@RequestMapping("/pedidos")
+public class PedidoController {
+    private final ConfirmarPedidoUseCase confirmarPedido;
+
+    @PostMapping("/{id}/confirmar")
+    public ResponseEntity<PedidoResponse> confirmar(@PathVariable String id) {
+        Pedido pedido = confirmarPedido.confirmar(new PedidoId(id));
+        return ResponseEntity.ok(PedidoMapper.toResponse(pedido));
+    }
+}
+```
+
+### Infrastructure — adapter de saída
+
+```java
+// infrastructure/adapter/out/PedidoJpaRepository.java
+@Repository
+public class PedidoJpaRepository implements PedidoRepository {
+    private final PedidoJpaEntityRepository jpa;
+
+    @Override
+    public Optional<Pedido> findById(PedidoId id) {
+        return jpa.findById(id.value()).map(PedidoMapper::toDomain);
+    }
+}
+```
+
+## Regras adicionais
+
+- **Sem lógica de negócio em controllers ou repositories** — toda regra de negócio fica em `domain` ou `application`
+- **Entidades de domínio são imutáveis por padrão** — use construtores e métodos explícitos, evite setters
+- **Mappers** ficam em `infrastructure` para converter entre entidades de domínio e entidades JPA/DTOs
+- **Anotações Spring** (`@Service`, `@Repository`, `@RestController`) pertencem à infraestrutura, não ao domínio
+
+## Skeleton e guardrails automáticos (profile dixi)
+
+`pscode init --profile dixi` cria automaticamente o skeleton de pastas hexagonal com `.gitkeep` em cada diretório e gera `src/test/java/{basePackage}/ArchitectureTest.java` com três regras ArchUnit pré-configuradas:
+
+1. `domain` não depende de `infrastructure`
+2. `application` não depende de `infrastructure`
+3. `infrastructure.adapter.in` não depende de `infrastructure.adapter.out`
+
+O `basePackage` é detectado automaticamente do `pom.xml` (`groupId` + `artifactId` sem hífens). Adicione a dependência ArchUnit ao `pom.xml` para ativar as verificações:
+
+```xml
+<dependency>
+  <groupId>com.tngtech.archunit</groupId>
+  <artifactId>archunit-junit5</artifactId>
+  <version>1.3.0</version>
+  <scope>test</scope>
+</dependency>
+```