@thiagodiogo/pscode 1.0.0 → 1.0.1

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

@@ -0,0 +1,119 @@
+# Arquitetura — React/Next.js (Feature-Sliced Design)
+
+## Camadas (de baixo para cima)
+
+```
+pages / app          ← Next.js routes, composição de features
+features             ← unidades funcionais independentes
+entities             ← modelos de negócio reutilizáveis
+shared               ← utilitários, UI base, types globais
+```
+
+Camadas superiores podem importar das inferiores. **Camadas inferiores nunca importam das superiores.**
+
+## Estrutura de pastas
+
+```
+src/
+├── app/                    # Next.js App Router (ou pages/)
+│   ├── layout.tsx
+│   └── checkout/
+│       └── page.tsx        # Apenas composição de features
+├── features/
+│   ├── checkout/           # Feature autocontida
+│   │   ├── components/     # Componentes internos da feature
+│   │   ├── hooks/          # Hooks internos
+│   │   ├── services/       # Chamadas de API da feature
+│   │   ├── types/          # Tipos TypeScript da feature
+│   │   └── index.ts        # Barrel export — única entrada pública
+│   └── auth/
+│       └── index.ts
+├── entities/
+│   ├── product/
+│   │   ├── model.ts        # Tipos e schemas da entidade
+│   │   └── index.ts
+│   └── user/
+│       └── index.ts
+└── shared/
+    ├── ui/                 # Componentes base (Button, Input, Modal)
+    ├── lib/                # Utilitários e helpers
+    ├── api/                # Cliente HTTP base (axios, fetch wrapper)
+    └── types/              # Tipos globais compartilhados
+```
+
+## Regras fundamentais
+
+### No cross-import entre features
+
+Features **não podem importar umas das outras** diretamente:
+
+```typescript
+// ❌ PROIBIDO
+import { useCart } from '../cart'; // feature cart importando de outra feature
+
+// ✅ CORRETO — mova o dado compartilhado para entities
+import { Product } from '@/entities/product';
+```
+
+Se duas features precisam de algo em comum, mova esse algo para `entities` ou `shared`.
+
+### Barrel export como contrato público
+
+Tudo que sai de uma feature deve passar pelo `index.ts`:
+
+```typescript
+// features/checkout/index.ts
+export { CheckoutPage } from './components/CheckoutPage';
+export { useCheckoutForm } from './hooks/useCheckoutForm';
+export type { CheckoutFormData } from './types';
+// Services e hooks internos NÃO são exportados
+```
+
+Externos à feature importam **apenas do barrel**:
+
+```typescript
+// ✅ CORRETO
+import { CheckoutPage } from '@/features/checkout';
+
+// ❌ PROIBIDO — acesso direto a módulo interno
+import { CheckoutPage } from '@/features/checkout/components/CheckoutPage';
+```
+
+### Pages/App são apenas composição
+
+Pages não contêm lógica de negócio — apenas montam features:
+
+```typescript
+// app/checkout/page.tsx
+import { CheckoutPage } from '@/features/checkout';
+import { AuthGuard } from '@/features/auth';
+
+export default function Page() {
+  return (
+    <AuthGuard>
+      <CheckoutPage />
+    </AuthGuard>
+  );
+}
+```
+
+## Quando criar uma nova feature
+
+Crie uma nova feature quando:
+- A funcionalidade tem um domínio claramente delimitado
+- Possui componentes, hooks e serviços próprios
+- Não é reutilizável por natureza (se for reutilizável, considere `entities` ou `shared`)
+
+## Skeleton e guardrails automáticos (profile dixi)
+
+`pscode init --profile dixi` cria automaticamente a estrutura feature-sliced com `.gitkeep` nos diretórios folha e `features/README.md` com as convenções documentadas. Também instala `eslint-architecture.mjs` na raiz com regras `no-restricted-imports` para:
+
+- Isolar features entre si (features não importam umas das outras)
+- Impedir que páginas importem lógica de negócio diretamente
+
+Para ativar as regras no ESLint, adicione ao `eslint.config.js`:
+
+```js
+import architectureRules from './eslint-architecture.mjs';
+export default [...existingConfig, ...architectureRules];
+```

package/pscode/content/dixi/context/react/naming.md

@@ -0,0 +1,129 @@
+# Convenções de Nomenclatura — React/Next.js
+
+## Resumo rápido
+
+| Tipo                  | Convenção          | Exemplos                                     |
+|-----------------------|--------------------|----------------------------------------------|
+| Componente React      | `PascalCase`       | `CheckoutForm`, `UserAvatar`, `ProductCard`  |
+| Hook                  | `use` + PascalCase | `useCheckoutForm`, `useAuth`, `useProductList`|
+| Service / função util | `camelCase`        | `submitCheckout`, `formatCurrency`, `parseDate`|
+| Arquivo de componente | `kebab-case.tsx`   | `checkout-form.tsx`, `user-avatar.tsx`       |
+| Arquivo de hook       | `use-*.ts`         | `use-checkout-form.ts`, `use-auth.ts`        |
+| Arquivo de service    | `*-service.ts`     | `checkout-service.ts`, `auth-service.ts`     |
+| Constante             | `SCREAMING_SNAKE`  | `MAX_ITEMS`, `API_BASE_URL`, `DEFAULT_TIMEOUT`|
+| Tipo / Interface      | `PascalCase`       | `CheckoutFormData`, `UserProfile`, `ApiError`|
+| Enum                  | `PascalCase` (valor `SCREAMING_SNAKE`) | `enum Status { ACTIVE = 'ACTIVE' }` |
+
+## Componentes React
+
+**PascalCase** — sempre.
+
+```typescript
+// ✅ Correto
+export function CheckoutForm() { ... }
+export const UserAvatar: React.FC<Props> = () => { ... }
+
+// ❌ Errado
+export function checkoutForm() { ... }
+export function checkout_form() { ... }
+```
+
+Arquivos de componente em **kebab-case**:
+```
+checkout-form.tsx     ✅
+CheckoutForm.tsx      ❌ (exceto se a convenção do projeto usar PascalCase em arquivos)
+```
+
+## Hooks
+
+`use` + PascalCase. O nome deve descrever o que o hook faz ou gerencia.
+
+```typescript
+// ✅ Correto
+function useCheckoutForm() { ... }
+function useProductList(categoryId: string) { ... }
+function useAuth() { ... }
+
+// ❌ Errado
+function checkoutFormHook() { ... }
+function UseCheckoutForm() { ... }    // PascalCase não é hook
+function useGetProductList() { ... }  // evite "get" — já está implícito
+```
+
+## Services (funções de acesso a API ou lógica assíncrona)
+
+**camelCase** para a função, arquivo em **kebab-case**:
+
+```typescript
+// checkout-service.ts
+export async function submitCheckout(data: CheckoutData): Promise<OrderResponse> { ... }
+export async function fetchCheckoutSummary(cartId: string): Promise<Summary> { ... }
+
+// ❌ Errado
+export async function SubmitCheckout() { ... }     // PascalCase é componente
+export async function submit_checkout() { ... }    // snake_case não é JS/TS
+```
+
+## Constantes
+
+**SCREAMING_SNAKE_CASE** para valores imutáveis de escopo global ou de módulo:
+
+```typescript
+// ✅ Correto
+const MAX_RETRY_ATTEMPTS = 3;
+const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL;
+const DEFAULT_PAGE_SIZE = 20;
+
+// ❌ Errado
+const maxRetryAttempts = 3;    // parece variável local mutável
+const MaxRetryAttempts = 3;    // PascalCase é componente ou tipo
+```
+
+## Tipos e Interfaces
+
+**PascalCase**, com sufixo descritivo quando necessário para clareza:
+
+```typescript
+// ✅ Correto
+type CheckoutFormData = { email: string; items: CartItem[] };
+interface UserProfile { id: string; name: string }
+type ApiError = { code: string; message: string };
+
+// Use sufixos quando o nome base é ambíguo
+type CheckoutRequest = { ... };   // DTO de entrada
+type CheckoutResponse = { ... };  // DTO de saída
+type CheckoutState = { ... };     // estado do componente/hook
+```
+
+## Props de componentes
+
+Sufixo `Props` no tipo:
+
+```typescript
+type CheckoutFormProps = {
+  onSubmit: (data: CheckoutFormData) => void;
+  initialValues?: Partial<CheckoutFormData>;
+};
+
+function CheckoutForm({ onSubmit, initialValues }: CheckoutFormProps) { ... }
+```
+
+## Handlers de eventos
+
+Prefixo `handle` para funções internas; prefixo `on` para props de callback:
+
+```typescript
+// Props (contrato externo)
+type CardProps = {
+  onSelect: (id: string) => void;    // prefixo "on"
+  onDelete: () => void;
+};
+
+// Handlers internos
+function ProductCard({ onSelect }: CardProps) {
+  function handleClick() {           // prefixo "handle"
+    onSelect(product.id);
+  }
+  return <div onClick={handleClick} />;
+}
+```

package/pscode/content/dixi/context/react/testing.md

@@ -0,0 +1,141 @@
+# Testes — React/Next.js
+
+## Pirâmide de testes
+
+```
+         [E2E — Playwright]           ← fluxos críticos de usuário
+       [Componentes — RTL]            ← comportamento visível ao usuário
+   [Unitários — Vitest]               ← hooks, services, utils (maioria)
+```
+
+## Nível 1 — Testes unitários (hooks, services, utils)
+
+Testam lógica pura sem renderizar componentes.
+
+**Ferramenta:** Vitest
+
+**Onde ficam:** ao lado do arquivo testado (`*.test.ts`) ou em `__tests__/`
+
+```typescript
+// features/checkout/hooks/useCheckoutForm.test.ts
+import { renderHook, act } from '@testing-library/react';
+import { useCheckoutForm } from './useCheckoutForm';
+
+describe('useCheckoutForm', () => {
+  it('deve inicializar com campos vazios', () => {
+    const { result } = renderHook(() => useCheckoutForm());
+    expect(result.current.values.email).toBe('');
+  });
+
+  it('deve validar email inválido', async () => {
+    const { result } = renderHook(() => useCheckoutForm());
+    await act(async () => {
+      result.current.setField('email', 'nao-e-email');
+      await result.current.validate();
+    });
+    expect(result.current.errors.email).toBeDefined();
+  });
+});
+```
+
+```typescript
+// features/checkout/services/checkoutService.test.ts
+import { vi, describe, it, expect } from 'vitest';
+import { submitCheckout } from './checkoutService';
+import { apiClient } from '@/shared/api';
+
+vi.mock('@/shared/api');
+
+describe('submitCheckout', () => {
+  it('deve chamar a API com os dados corretos', async () => {
+    const mockPost = vi.mocked(apiClient.post).mockResolvedValue({ data: { orderId: '123' } });
+    const result = await submitCheckout({ email: 'test@test.com', items: [] });
+    expect(mockPost).toHaveBeenCalledWith('/checkout', expect.objectContaining({ email: 'test@test.com' }));
+    expect(result.orderId).toBe('123');
+  });
+});
+```
+
+## Nível 2 — Testes de componentes (React Testing Library)
+
+Testam o comportamento do componente do ponto de vista do usuário, não a implementação.
+
+**Ferramenta:** React Testing Library (RTL) + Vitest
+
+**Princípio:** Consulte elementos como o usuário os veria (por role, label, texto — não por classe CSS ou estrutura interna)
+
+```typescript
+// features/checkout/components/CheckoutForm.test.tsx
+import { render, screen, userEvent } from '@testing-library/react';
+import { CheckoutForm } from './CheckoutForm';
+
+describe('CheckoutForm', () => {
+  it('deve exibir erro quando email está vazio e o form é enviado', async () => {
+    render(<CheckoutForm onSubmit={vi.fn()} />);
+
+    await userEvent.click(screen.getByRole('button', { name: /confirmar/i }));
+
+    expect(screen.getByText(/email é obrigatório/i)).toBeInTheDocument();
+  });
+
+  it('deve chamar onSubmit com dados corretos quando form é válido', async () => {
+    const onSubmit = vi.fn();
+    render(<CheckoutForm onSubmit={onSubmit} />);
+
+    await userEvent.type(screen.getByLabelText(/e-mail/i), 'user@example.com');
+    await userEvent.click(screen.getByRole('button', { name: /confirmar/i }));
+
+    expect(onSubmit).toHaveBeenCalledWith(expect.objectContaining({ email: 'user@example.com' }));
+  });
+});
+```
+
+## Nível 3 — Testes E2E (Playwright)
+
+Testam fluxos críticos de ponta a ponta no browser real.
+
+**Ferramenta:** Playwright
+
+**Onde ficam:** `e2e/` na raiz do projeto
+
+**Escopo:** apenas fluxos críticos de negócio (login, checkout, fluxo principal)
+
+```typescript
+// e2e/checkout.spec.ts
+import { test, expect } from '@playwright/test';
+
+test('usuário consegue completar o checkout', async ({ page }) => {
+  await page.goto('/checkout');
+  await page.getByLabel('E-mail').fill('user@example.com');
+  await page.getByRole('button', { name: 'Confirmar pedido' }).click();
+
+  await expect(page.getByText('Pedido confirmado!')).toBeVisible();
+  await expect(page).toHaveURL(/\/confirmacao/);
+});
+```
+
+## Configuração
+
+```typescript
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setup.ts'],
+    coverage: {
+      reporter: ['text', 'lcov'],
+      exclude: ['**/*.test.*', 'e2e/**', 'src/test/**'],
+    },
+  },
+});
+```
+
+## O que NÃO testar
+
+- Lógica de estilo (CSS, classes) — use Storybook para isso
+- Detalhes de implementação interna (state do componente, refs)
+- Snapshots de componentes complexos — ficam desatualizados rapidamente

package/pscode/content/dixi/context/shared/commits.md

@@ -0,0 +1,47 @@
+# Convenção de Commits
+
+## Formato obrigatório
+
+```
+tipo(escopo): descrição imperativa [PROJ-123]
+```
+
+**Exemplos válidos:**
+```
+feat(pagamento): adicionar integração com gateway PIX [PAY-456]
+fix(auth): corrigir expiração de token JWT [AUTH-789]
+refactor(pedido): extrair lógica de cálculo de frete [ORD-321]
+test(usuario): adicionar testes de integração para cadastro [USR-100]
+docs(readme): atualizar instruções de setup local
+chore(deps): atualizar Spring Boot para 3.2.0
+```
+
+## Tipos válidos
+
+| Tipo       | Quando usar                                        |
+|------------|----------------------------------------------------|
+| `feat`     | Nova funcionalidade                                |
+| `fix`      | Correção de bug                                    |
+| `refactor` | Mudança de código sem alterar comportamento externo|
+| `test`     | Adição ou modificação de testes                    |
+| `docs`     | Documentação apenas                                |
+| `chore`    | Tarefas de manutenção, deps, build, CI             |
+
+## Regras de escopo
+
+O escopo deve corresponder ao módulo, bounded context ou feature afetada.
+
+- Java/Spring: nome do bounded context ou pacote de domínio (ex: `pagamento`, `pedido`, `usuario`)
+- React/Next.js: nome da feature ou camada (ex: `checkout`, `auth`, `shared`)
+
+## Ticket JIRA obrigatório
+
+- **Obrigatório** em todos os commits **exceto** `docs` e `chore`
+- Formato: `[PROJ-NNN]` ao final da primeira linha
+- O ticket deve estar em estado "Em Desenvolvimento" ou "Em Revisão" antes do commit
+
+## Mensagem no imperativo
+
+Use verbos no imperativo: "adicionar", "corrigir", "remover", "atualizar" (não "adicionado", "corrigido").
+
+A mensagem deve completar a frase: *"Se aplicado, este commit vai [mensagem]"*

package/pscode/content/dixi/context/shared/dev-flow.md

@@ -0,0 +1,53 @@
+# Fluxo de Desenvolvimento
+
+## Visão geral
+
+```
+RFC → Design → Tasks → Apply → Revisão → Deploy
+```
+
+Use `/pstld:rfc` para iniciar o fluxo, `/pstld:dod` para validar antes de abrir o PR.
+
+## Quando criar RFC
+
+Crie uma RFC quando a mudança:
+
+- Afeta a arquitetura de um módulo ou a interface entre módulos
+- Introduz uma nova dependência externa
+- Muda o contrato de uma API pública
+- Demora mais de 1 dia de implementação
+
+Vá direto para task quando:
+
+- É um bug fix isolado com causa clara
+- É uma tarefa mecânica sem impacto arquitetural (atualização de cópia, ajuste de estilo, etc.)
+- É uma task de refactor de escopo delimitado aprovada previamente
+
+## Fase RFC
+
+1. Use `/pstld:rfc` para gerar o rascunho da RFC
+2. A RFC deve conter: contexto, problema, solução proposta, alternativas consideradas, trade-offs
+3. Solicite revisão dos tech leads antes de avançar
+4. RFC aprovada → avançar para Design
+
+## Fase Design
+
+1. Use `/ps:propose` para gerar o design e as specs
+2. O design deve ser revisado antes de iniciar a implementação
+3. Specs descrevem comportamento esperado (não implementação)
+
+## Fase Tasks + Apply
+
+1. Use `/ps:apply` para iniciar a implementação
+2. Marque cada task como concluída ao terminar
+3. Mantenha o escopo — não adicione tarefas não planejadas sem atualizar o design
+
+## Validação antes do PR
+
+Execute `/pstld:dod` para verificar o DoD antes de abrir o PR.
+
+O slash command verifica automaticamente:
+- Testes passando
+- Cobertura mantida
+- Ticket JIRA referenciado nos commits
+- Checklist de DoD completo

package/pscode/content/dixi/context/shared/dod.md

@@ -0,0 +1,38 @@
+# Definition of Done
+
+## Feature
+
+Uma feature está pronta quando:
+
+- [ ] RFC aprovada pelos tech leads (quando mudança significativa)
+- [ ] Design revisado e aceito antes da implementação
+- [ ] Todas as tasks do `/ps:apply` marcadas como concluídas
+- [ ] Testes passando (unitários, integração e E2E conforme pirâmide)
+- [ ] Cobertura de testes mantida ou melhorada
+- [ ] PR aprovado por pelo menos 1 revisor
+- [ ] CHANGELOG ou changeset atualizado
+- [ ] Ticket JIRA movido para "Em Teste"
+
+## Bug Fix
+
+Um bug fix está pronto quando:
+
+- [ ] Root cause identificado e documentado no PR ou ticket JIRA
+- [ ] Teste de regressão adicionado que reproduz o bug antes da correção
+- [ ] Correção implementada e testes passando
+- [ ] PR aprovado por pelo menos 1 revisor
+- [ ] Ticket JIRA movido para "Em Teste"
+
+## Refactor
+
+Um refactor está pronto quando:
+
+- [ ] Comportamento externo preservado (testes existentes continuam passando sem modificação)
+- [ ] Cobertura de testes mantida ou melhorada
+- [ ] Nenhuma lógica de negócio foi alterada (se houver, deve virar um `feat` ou `fix`)
+- [ ] PR aprovado por pelo menos 1 revisor
+- [ ] Sem regressões em funcionalidades adjacentes
+
+## Critério de "Em Produção"
+
+O ciclo só fecha quando a feature ou fix está deployada e monitorada por pelo menos 24h sem alertas.

package/pscode/content/dixi/context/shared/pr-flow.md

@@ -0,0 +1,53 @@
+# Fluxo de Pull Request
+
+## Template de PR
+
+```markdown
+## O que muda
+<!-- Descreva de forma concisa o que este PR altera -->
+
+## Por que
+<!-- Explique a motivação. Referencie o ticket JIRA: [PROJ-123] -->
+
+## Como testar
+<!-- Passo a passo para o revisor validar manualmente -->
+1. 
+2. 
+3. 
+
+## Checklist
+- [ ] Testes adicionados/atualizados
+- [ ] Cobertura mantida ou melhorada
+- [ ] DoD verificado (`/pstld:dod`)
+- [ ] Sem TODOs temporários deixados no código
+- [ ] Documentação atualizada (se aplicável)
+```
+
+## Referenciando tickets JIRA
+
+- Inclua `[PROJ-123]` no título do PR
+- Use `Closes PROJ-123` ou `Refs PROJ-123` na descrição quando a integração JIRA estiver configurada
+- O ticket deve estar em "Em Revisão" quando o PR for aberto
+
+## Processo de revisão
+
+1. Abra o PR apontando para a branch de destino (geralmente `main` ou `develop`)
+2. Solicite revisão de pelo menos 1 membro do time
+3. Responda todos os comentários antes de fazer merge
+4. Após aprovação, faça squash merge ou merge commit conforme a convenção do projeto
+
+## Critérios de merge
+
+Um PR pode ser mergeado quando:
+
+- CI passou (build, lint, testes, cobertura)
+- Pelo menos 1 aprovação de revisor
+- Todos os comentários resolvidos
+- Sem conflitos com a branch de destino
+- DoD verificado
+
+## Tamanho ideal de PR
+
+Prefira PRs com menos de 400 linhas modificadas. PRs grandes aumentam o tempo de revisão e o risco de bugs passarem despercebidos.
+
+Se o PR estiver muito grande, considere quebrá-lo em partes menores com dependência sequencial.

package/pscode/content/dixi/kit/java/.editorconfig

@@ -0,0 +1,25 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.java]
+indent_style = space
+indent_size = 4
+charset = utf-8
+end_of_line = lf
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+
+[*.xml]
+indent_style = space
+indent_size = 4
+
+[*.properties]
+indent_style = space
+indent_size = 4

package/pscode/content/dixi/kit/java/.github/workflows/ci-java.yml

@@ -0,0 +1,68 @@
+name: CI Java
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: temurin
+          cache: maven
+      - name: Compile
+        run: mvn compile
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: temurin
+          cache: maven
+      - name: Run tests
+        run: mvn test
+
+  archunit:
+    name: ArchUnit
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: temurin
+          cache: maven
+      - name: Run architecture tests
+        run: mvn test -Dtest=ArchitectureTest
+
+  coverage:
+    name: Coverage
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: temurin
+          cache: maven
+      - name: Generate coverage report
+        run: mvn jacoco:report
+      - name: Upload coverage artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: jacoco-report
+          path: target/site/jacoco/

package/pscode/content/dixi/kit/java/.husky/commit-msg

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+npx --no-install commitlint --edit "$1"