devsquad 1.0.0

package/templates/.claude/skills/react/setup.md

@@ -0,0 +1,153 @@
+# React — Setup completo (Vite + TS)
+
+Complementa o **SKILL.md** com arquivos base: API, auth e rotas.
+
+## src/services/api.ts
+
+```typescript
+import axios from 'axios';
+
+const api = axios.create({
+  baseURL: import.meta.env.VITE_API_URL ?? 'http://localhost:3000/api/v1',
+  withCredentials: true,
+});
+
+api.interceptors.request.use((config) => {
+  const token = localStorage.getItem('access_token');
+  if (token) config.headers.Authorization = `Bearer ${token}`;
+  return config;
+});
+
+api.interceptors.response.use(
+  (r) => r,
+  async (error) => {
+    // Opcional: refresh token + fila de retries — alinhar com backend
+    if (error.response?.status === 401) {
+      localStorage.removeItem('access_token');
+      window.location.href = '/login';
+    }
+    return Promise.reject(error);
+  },
+);
+
+export default api;
+```
+
+## src/contexts/AuthContext.tsx
+
+```typescript
+import {
+  createContext,
+  useContext,
+  useState,
+  useCallback,
+  type ReactNode,
+} from 'react';
+import api from '../services/api';
+
+type User = { id: string; email: string; name: string };
+
+type AuthContextValue = {
+  user: User | null;
+  loading: boolean;
+  login: (email: string, password: string) => Promise<void>;
+  logout: () => void;
+};
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  const login = useCallback(async (email: string, password: string) => {
+    setLoading(true);
+    try {
+      const { data } = await api.post('/auth/login', { email, password });
+      localStorage.setItem('access_token', data.access_token);
+      setUser(data.user);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const logout = useCallback(() => {
+    localStorage.removeItem('access_token');
+    setUser(null);
+  }, []);
+
+  return (
+    <AuthContext.Provider value={{ user, loading, login, logout }}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth() {
+  const ctx = useContext(AuthContext);
+  if (!ctx) throw new Error('useAuth outside AuthProvider');
+  return ctx;
+}
+```
+
+## src/routes/PrivateRoute.tsx
+
+```typescript
+import { Navigate, Outlet } from 'react-router-dom';
+import { useAuth } from '../contexts/AuthContext';
+
+export function PrivateRoute() {
+  const { user, loading } = useAuth();
+  if (loading) return <div>Carregando…</div>;
+  if (!user) return <Navigate to="/login" replace />;
+  return <Outlet />;
+}
+```
+
+## src/routes/AppRoutes.tsx
+
+```typescript
+import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
+import { AuthProvider } from '../contexts/AuthContext';
+import { PrivateRoute } from './PrivateRoute';
+// import LoginPage from '../pages/login/LoginPage';
+// import DashboardPage from '../pages/dashboard/DashboardPage';
+
+export function AppRoutes() {
+  return (
+    <BrowserRouter>
+      <AuthProvider>
+        <Routes>
+          <Route path="/login" element={<div>Login</div>} />
+          <Route element={<PrivateRoute />}>
+            <Route path="/" element={<div>Dashboard</div>} />
+          </Route>
+          <Route path="*" element={<Navigate to="/" replace />} />
+        </Routes>
+      </AuthProvider>
+    </BrowserRouter>
+  );
+}
+```
+
+## src/main.tsx
+
+```typescript
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { AppRoutes } from './routes/AppRoutes';
+import './index.css';
+
+const queryClient = new QueryClient();
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <QueryClientProvider client={queryClient}>
+      <AppRoutes />
+    </QueryClientProvider>
+  </StrictMode>,
+);
+```
+
+Substitua os placeholders de página pelos componentes reais em `pages/`.

package/templates/.claude/skills/react-native/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: react-native-mobile
+description: Setup e arquitetura mobile com React Native + Expo + NativeWind. Use quando o desenvolvedor precisar inicializar ou trabalhar no app mobile, configurar Expo Router, armazenamento seguro de tokens, navegação ou build com EAS.
+---
+
+# React Native + Expo + NativeWind
+
+## Setup rápido
+
+```bash
+npx create-expo-app@latest nome-do-app --template blank-typescript
+cd nome-do-app
+npx expo install expo-router expo-linking expo-constants expo-status-bar react-native-screens react-native-safe-area-context expo-secure-store
+npm install nativewind tailwindcss && npx tailwindcss init
+npm install axios react-hook-form zod @hookform/resolvers
+```
+
+## Configuração NativeWind
+
+```javascript
+// tailwind.config.js
+module.exports = {
+  content: ['./app/**/*.{js,jsx,ts,tsx}', './components/**/*.{js,jsx,ts,tsx}'],
+  presets: [require('nativewind/preset')],
+}
+```
+
+```javascript
+// babel.config.js
+module.exports = function(api) {
+  api.cache(true);
+  return {
+    presets: [['babel-preset-expo', { jsxImportSource: 'nativewind' }], 'nativewind/babel'],
+  };
+};
+```
+
+## Estrutura (Expo Router)
+
+```
+app/
+├── _layout.tsx         ← Root layout com AuthProvider
+├── (auth)/
+│   ├── _layout.tsx     ← Redireciona para (app) se autenticado
+│   └── login.tsx
+└── (app)/
+    ├── _layout.tsx     ← Tab bar ou Stack layout
+    └── index.tsx       ← Dashboard
+components/ui/          ← Button, Input, Card
+services/
+├── api.ts              ← Axios + interceptors
+└── storage.service.ts  ← SecureStore (NUNCA AsyncStorage para tokens)
+contexts/AuthContext.tsx
+```
+
+## Regra crítica de segurança
+
+```typescript
+// ✅ CORRETO — SecureStore usa Keychain (iOS) e Keystore (Android)
+import * as SecureStore from 'expo-secure-store';
+await SecureStore.setItemAsync('access_token', token);
+
+// ❌ ERRADO — AsyncStorage é texto plano acessível com root
+import AsyncStorage from '@react-native-async-storage/async-storage';
+await AsyncStorage.setItem('access_token', token); // NUNCA para tokens
+```
+
+> 🔒 OWASP M9 — Insecure Data Storage: Use `expo-secure-store` para qualquer dado sensível.
+
+## .env.local.example
+
+```env
+# IP da máquina na rede local — localhost não funciona no dispositivo físico
+# Windows: ipconfig | Mac/Linux: ifconfig
+EXPO_PUBLIC_API_URL=http://192.168.X.X:3000/api/v1
+```
+
+## Arquivos detalhados desta skill
+
+- **setup.md** — AuthContext, api.ts, storage.service.ts, layouts Expo Router completos
+
+Leia `setup.md` para implementar a estrutura base completa.

package/templates/.claude/skills/react-native/setup.md

@@ -0,0 +1,150 @@
+# React Native (Expo) — Setup completo
+
+Complementa o **SKILL.md** com API, armazenamento seguro e integração com Expo Router.
+
+## services/storage.service.ts
+
+```typescript
+import * as SecureStore from 'expo-secure-store';
+
+const KEYS = { access: 'access_token', refresh: 'refresh_token' } as const;
+
+export async function setTokens(access: string, refresh?: string) {
+  await SecureStore.setItemAsync(KEYS.access, access);
+  if (refresh) await SecureStore.setItemAsync(KEYS.refresh, refresh);
+}
+
+export async function getAccessToken() {
+  return SecureStore.getItemAsync(KEYS.access);
+}
+
+export async function clearTokens() {
+  await SecureStore.deleteItemAsync(KEYS.access);
+  await SecureStore.deleteItemAsync(KEYS.refresh);
+}
+```
+
+## services/api.ts
+
+```typescript
+import axios from 'axios';
+import { getAccessToken, clearTokens } from './storage.service';
+
+const api = axios.create({
+  baseURL: process.env.EXPO_PUBLIC_API_URL,
+  timeout: 15000,
+});
+
+api.interceptors.request.use(async (config) => {
+  const token = await getAccessToken();
+  if (token) config.headers.Authorization = `Bearer ${token}`;
+  return config;
+});
+
+api.interceptors.response.use(
+  (r) => r,
+  async (error) => {
+    if (error.response?.status === 401) {
+      await clearTokens();
+      // Redirecionar via router — ex.: router.replace('/(auth)/login')
+    }
+    return Promise.reject(error);
+  },
+);
+
+export default api;
+```
+
+## contexts/AuthContext.tsx
+
+```typescript
+import {
+  createContext,
+  useContext,
+  useState,
+  useCallback,
+  type ReactNode,
+} from 'react';
+import api from '../services/api';
+import * as storage from '../services/storage.service';
+
+type User = { id: string; email: string; name: string };
+
+type AuthContextValue = {
+  user: User | null;
+  loading: boolean;
+  signIn: (email: string, password: string) => Promise<void>;
+  signOut: () => Promise<void>;
+};
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  const signIn = useCallback(async (email: string, password: string) => {
+    setLoading(true);
+    try {
+      const { data } = await api.post('/auth/login', { email, password });
+      await storage.setTokens(data.access_token, data.refresh_token);
+      setUser(data.user);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const signOut = useCallback(async () => {
+    await storage.clearTokens();
+    setUser(null);
+  }, []);
+
+  return (
+    <AuthContext.Provider value={{ user, loading, signIn, signOut }}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth() {
+  const ctx = useContext(AuthContext);
+  if (!ctx) throw new Error('useAuth outside AuthProvider');
+  return ctx;
+}
+```
+
+## app/_layout.tsx (raiz)
+
+```typescript
+import { Stack } from 'expo-router';
+import { AuthProvider } from '../contexts/AuthContext';
+
+export default function RootLayout() {
+  return (
+    <AuthProvider>
+      <Stack screenOptions={{ headerShown: false }} />
+    </AuthProvider>
+  );
+}
+```
+
+## app/(auth)/login.tsx (exemplo mínimo)
+
+```typescript
+import { View, Text, TextInput, Pressable } from 'react-native';
+import { useAuth } from '../../contexts/AuthContext';
+
+export default function Login() {
+  const { signIn, loading } = useAuth();
+  return (
+    <View style={{ padding: 24 }}>
+      <Text>Login</Text>
+      <Pressable onPress={() => signIn('a@b.com', 'password')} disabled={loading}>
+        <Text>Entrar</Text>
+      </Pressable>
+    </View>
+  );
+}
+```
+
+Ajuste formulário com `react-hook-form` + `zod` conforme o SKILL.md. Use **`EXPO_PUBLIC_API_URL`** com IP da máquina em dispositivo físico.

package/templates/.claude/skills/security/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: security-owasp
+description: Checklist e implementações de segurança baseadas no OWASP Top 10 para NestJS + React. Use quando o desenvolvedor precisar revisar segurança, implementar autenticação segura, configurar proteções HTTP, validar inputs ou quando qualquer questão de segurança surgir no desenvolvimento.
+---
+
+# Segurança — OWASP Top 10
+
+Referência: https://owasp.org/Top10/
+
+## Checklist rápido por módulo
+
+### Ao criar qualquer módulo de autenticação
+- [ ] **A01** — Guards em todas as rotas protegidas + RBAC
+- [ ] **A02** — bcrypt salt >= 12, nunca retornar senha na resposta
+- [ ] **A03** — DTO com class-validator, `whitelist: true` no ValidationPipe
+- [ ] **A04** — Rate limiting com ThrottlerGuard (login: 5 tentativas/15min)
+- [ ] **A05** — Helmet ativo, CORS explícito, secrets em `.env`
+- [ ] **A07** — JWT access 15min + refresh 7d com rotation
+- [ ] **A09** — Logs sem dados sensíveis (sem email, senha ou token)
+
+### Ao criar qualquer endpoint de dados
+- [ ] UUID nos IDs (evita enumeração — A01)
+- [ ] Ownership validation (usuário só acessa seus dados)
+- [ ] Soft delete (nunca delete físico em produção)
+- [ ] Paginação (nunca retorne todos os registros)
+
+## Implementações críticas
+
+### A01 — Broken Access Control
+
+```typescript
+// Ownership validation — obrigatório em qualquer PATCH/DELETE
+@Patch(':id')
+@UseGuards(JwtAuthGuard)
+async update(@Param('id') id: string, @CurrentUser() user: User) {
+  if (id !== user.id && user.role !== 'ADMIN') {
+    throw new ForbiddenException('Acesso negado');
+  }
+  // ...
+}
+```
+
+### A02 — Cryptographic Failures
+
+```typescript
+// Sempre bcrypt com salt >= 12
+const hash = await bcrypt.hash(password, 12);
+const valid = await bcrypt.compare(plain, hash);
+// Nunca MD5, SHA1, ou texto plano
+```
+
+### A03 — Injection
+
+```typescript
+// DTO com validação — nunca confie no input do usuário
+export class CreateUserDto {
+  @IsEmail() email: string;
+  @IsString() @MinLength(8) @MaxLength(128) password: string;
+  @IsString() @MaxLength(100) name: string;
+}
+// Prisma usa queries parametrizadas por padrão — nunca use $queryRaw com string
+```
+
+### A07 — Identification Failures
+
+```typescript
+// Rate limit específico em rotas de auth
+@Post('login')
+@Throttle({ default: { ttl: 900000, limit: 5 } }) // 5 tentativas / 15min
+login() {}
+
+// Mesma mensagem para email/senha inválidos — evita user enumeration
+throw new UnauthorizedException('Credenciais inválidas');
+```
+
+## Arquivos detalhados desta skill
+
+- **owasp-full.md** — Todos os 10 itens com código completo e exemplos
+
+Leia `owasp-full.md` para revisão aprofundada de segurança.

package/templates/.claude/skills/security/owasp-full.md

@@ -0,0 +1,66 @@
+# OWASP Top 10 — referência estendida (NestJS + React)
+
+Fonte: https://owasp.org/Top10/
+
+Use com a skill **security** (`SKILL.md`) para checklist rápido. Aqui: um gancho por categoria + ação típica na stack DevSquad.
+
+---
+
+## A01 — Broken Access Control
+
+- **Backend:** `@UseGuards(JwtAuthGuard)` + validar ownership em `PATCH`/`DELETE` (recurso pertence ao `user.id` ou role admin).
+- **Frontend:** rotas privadas; não confiar só no UI — API deve negar.
+
+## A02 — Cryptographic Failures
+
+- Senhas: `bcrypt` salt ≥ 12; HTTPS em produção.
+- Tokens: access curto; refresh com rotation; secrets só em env.
+- **Mobile:** `expo-secure-store` para tokens — nunca AsyncStorage.
+
+## A03 — Injection
+
+- DTOs + `class-validator`; `ValidationPipe` com `whitelist: true`.
+- Prisma: usar API tipada; evitar `$queryRaw` com concatenação de string.
+
+## A04 — Insecure Design
+
+- Threat modeling leve em features sensíveis (auth, pagamento, PII).
+- Rate limit em login e endpoints caros.
+
+## A05 — Security Misconfiguration
+
+- `helmet`, CORS explícito, desativar stack traces ao cliente em prod.
+- Headers e CSP conforme necessidade do front.
+
+## A06 — Vulnerable and Outdated Components
+
+- `npm audit` / dependabot; pin de versões críticas; atualizar LTS.
+
+## A07 — Identification and Authentication Failures
+
+- JWT access ~15m, refresh ~7d, rotation de refresh.
+- Mensagem genérica em login falho (evitar enumeração de usuários).
+
+## A08 — Software and Data Integrity Failures
+
+- CI com lockfile; revisar scripts de deploy; assinatura de releases se aplicável.
+
+## A09 — Security Logging and Monitoring Failures
+
+- Logs estruturados sem PII/secrets; alertas em picos de 401/429.
+
+## A10 — Server-Side Request Forgery (SSRF)
+
+- Validar URLs permitidas em integrações que façam fetch server-side; allowlist de hosts.
+
+---
+
+## React (cliente)
+
+- Não armazenar refresh em localStorage em apps de alto risco sem avaliação; preferir httpOnly cookie se o backend suportar.
+- Sanitizar HTML se usar `dangerouslySetInnerHTML` (evitar XSS).
+
+## Onde aprofundar no repositório
+
+- NestJS: `nestjs/security.md`, `nestjs/auth.md`
+- Skill **nestjs** + **database** para Prisma e multi-tenant com cuidado em A01.

package/templates/CLAUDE.md

@@ -0,0 +1,65 @@
+# DevSquad
+
+Você é o **DevSquad**, um agente especializado em inicializar e arquitetar sistemas profissionais.
+
+## Stack de referência
+- Backend: NestJS + Prisma + PostgreSQL
+- Frontend: React + TypeScript + TailwindCSS
+- Mobile: React Native + Expo + NativeWind
+- Auth: JWT (access 15min + refresh 7d)
+- Segurança: OWASP Top 10
+- Versionamento: Git Flow + Conventional Commits
+
+## Regras universais (sempre aplicar)
+
+**Código**
+- Nunca retorne senha em respostas de API
+- IDs sempre em UUID (não sequencial)
+- Variáveis sensíveis sempre em `.env`, nunca hardcoded
+- DTOs com class-validator em todos os inputs
+
+**Commits**
+- Padrão: `tipo(escopo): descrição` — ex: `feat(auth): adicionar JWT`
+- Branches: `feature/CK-{id}-{slug}` a partir do `develop`
+
+**Modo guia (sempre ativo)**
+Ao gerar qualquer código, explique a decisão com este padrão:
+```
+✅ O QUÊ — [o que está sendo criado]
+📖 POR QUÊ — [razão técnica]
+🔒 SEGURANÇA — [referência OWASP se aplicável]
+```
+
+## Onboarding de novo projeto
+
+Ao receber `/devsquad init`, faça estas 10 perguntas antes de gerar qualquer coisa:
+
+```
+1. Nome do projeto?
+2. Web, mobile ou ambos?
+3. Qual problema resolve? (1-3 frases)
+4. Quais são os perfis de usuário? (ex: admin, cliente)
+5. Terá autenticação social? (Google, GitHub...)
+6. Terá upload de arquivos?
+7. Terá pagamentos?
+8. Terá notificações? (email, push, SMS)
+9. Solo ou equipe?
+10. Já tem protótipo no Figma ou vai criar do zero?
+```
+
+Após as respostas, gere: estrutura de pastas, checklist de setup, tasks do ClickUp por sprint e branches Git iniciais.
+
+## Skills disponíveis
+
+Carregue a skill correspondente conforme a necessidade do desenvolvedor:
+
+- `/devsquad backend` → `.claude/skills/nestjs/`
+- `/devsquad frontend` → `.claude/skills/react/`
+- `/devsquad mobile` → `.claude/skills/react-native/`
+- `/devsquad git` → `.claude/skills/git/`
+- `/devsquad security` → `.claude/skills/security/`
+- `/devsquad database` → `.claude/skills/database/`
+- `/devsquad postman` → `.claude/skills/postman/`
+- `/devsquad docs` → `.claude/skills/docs/`
+- `/devsquad clickup` → `.claude/skills/clickup/`
+- `/devsquad figma` → `.claude/skills/figma/`