izanagi-ai 2.0.0

package/skills/wasm/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: wasm
+description: |
+  Skill de WebAssembly (Wasm) para o Portal. Aborda compilacao de linguagens para Wasm,
+  integracao com JavaScript, performance, Rust/Wasm, AssemblyScript, e casos de uso
+  (processamento pesado no client, portabilidade de bibliotecas).
+  Use esta skill para implementar funcionalidades que exigem execucao performatica no browser.
+---
+
+# Skill WebAssembly — Portal
+
+## O Que e WebAssembly
+
+- **Formato binario** de baixo nivel para execucao no browser
+- **Compilavel** de C/C++, Rust, Go, Kotlin, AssemblyScript
+- **Performance** proxima a nativa (nao e interpretado como JS)
+- **Sandbox**: executa no mesmo ambiente seguro que JS
+- **Modules**: import/export de funcoes entre Wasm e JS
+
+---
+
+## Casos de Uso no Portal
+
+| Caso | Descricao | Linguagem |
+|------|-----------|-----------|
+| Processamento de imagens | Redimensionar no client | Rust |
+| PDF generation | Gerar PDF no client | Rust / C++ |
+| Audio processing | Editar audio da radio | C++ (FFmpeg) |
+| Data compression | Comprimir/decomprimir dados | Rust |
+| Complex calculations | Calculos atuariais (INSS) | Rust |
+| Video transcoding | Codificar video para streaming | C++ (libav) |
+
+---
+
+## Rust + Wasm (Preferido)
+
+### Setup
+```bash
+# Instalar target
+rustup target add wasm32-unknown-unknown
+# Build tool
+cargo install wasm-pack
+```
+
+### Projeto
+```rust
+// src/lib.rs
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn calculate_benefit(salary: f64, years: f64) -> f64 {
+    salary * years * 0.015
+}
+
+#[wasm_bindgen]
+pub fn validate_cpf(cpf: &str) -> bool {
+    // Validacao de CPF em Rust
+}
+```
+
+```bash
+wasm-pack build --target web
+```
+
+### Uso no Frontend
+```tsx
+import init, { calculate_benefit } from "@/wasm/core";
+
+await init(); // inicializa o modulo wasm
+const result = calculate_benefit(5000, 30);
+```
+
+---
+
+## AssemblyScript (TypeScript-like)
+
+```typescript
+// assembly/index.ts
+export function fibonacci(n: i32): i32 {
+  if (n <= 1) return n;
+  return fibonacci(n - 1) + fibonacci(n - 2);
+}
+```
+
+- Sintaxe similar ao TypeScript (curva de aprendizado baixa)
+- Performance inferior ao Rust, mas superior ao JS
+- Bom para casos simples de migracao
+
+---
+
+## Performance
+
+| Operacao | JS puro | Wasm (Rust) | Ganho |
+|----------|---------|-------------|-------|
+| Fibonacci(40) | ~1200ms | ~60ms | 20x |
+| JSON parse 10MB | ~400ms | ~200ms | 2x |
+| Image resize 4K | ~500ms | ~80ms | 6x |
+| Regex complexo | ~50ms | ~10ms | 5x |
+
+---
+
+## Integracao com Next.js
+
+```tsx
+"use client";
+
+import { useEffect, useState } from "react";
+
+export function WasmCalculator() {
+  const [wasm, setWasm] = useState<typeof import("@/wasm/core")>();
+
+  useEffect(() => {
+    import("@/wasm/core").then((module) => {
+      module.default(); // init
+      setWasm(module);
+    });
+  }, []);
+
+  if (!wasm) return <div>Carregando...</div>;
+
+  return <div>Resultado: {wasm.calculate_benefit(5000, 30)}</div>;
+}
+```
+
+---
+
+## Boas Praticas
+
+- **Lazy loading**: carregar modulo Wasm so quando necessario (code split)
+- **Streaming compilation**: usar `WebAssembly.instantiateStreaming` para compilar enquanto baixa
+- **Error handling**: Wasm pode falhar (panic) — sempre envolver em try/catch
+- **Memory management**: Wasm tem memoria linear propria — gerenciar manualmente em Rust
+- **Threads**: SharedArrayBuffer + Web Workers para multi-threading (cuidado com CORS/Sec-Fetch)

package/skills/web-perf-engineer/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: web-perf-engineer
+description: |
+  Agente Web Performance & SEO Engineer para o Portal. Responsavel por auditar e
+  otimizar performance (Core Web Vitals), SEO (on-page, structured data, analytics),
+  e garantir visibilidade e velocidade do portal nos buscadores.
+---
+
+# Agente: Web Performance & SEO Engineer
+
+## Perfil
+
+Voce e um **Web Performance & SEO Engineer** especializado em otimizar sites Next.js para velocidade e rankeamento. Voce transforma audits Lighthouse em acoes concretas.
+
+### Sua Expertise:
+- Core Web Vitals (LCP, FID, CLS, INP)
+- Lighthouse, PageSpeed Insights, WebPageTest
+- Next.js otimizacao (ISR, SSR, SSG, streaming)
+- SEO on-page (structured data, meta tags, sitemap)
+- SEO tecnico (canonicals, robots.txt, hreflang)
+- Google Analytics 4, Search Console, Vercel Analytics
+
+---
+
+## Antes de Comecar
+
+1. Leia a skill `web-perf-seo` para padroes e metricas
+2. Execute Lighthouse antes/depois para medir impacto
+3. Verifique Search Console para erros de indexacao
+
+---
+
+## Responsabilidades
+
+### O que voce FAZ:
+- Auditar performance (Lighthouse, WebPageTest, PageSpeed Insights)
+- Otimizar LCP (imagens, fonts, server response time)
+- Reduzir CLS (dimensionamento de midia, fontes estaveis)
+- Melhorar INP (long tasks, event handlers lentos)
+- Structured data (JSON-LD para artigos, FAQ, eventos)
+- Sitemap.xml dinamico e robots.txt
+- Otimizar imagens (WebP/AVIF, responsive, lazy loading)
+- Implementar ISR para paginas estaticas com dados dinamicos
+
+### O que voce NAO FAZ:
+- ❌ Ignorar metricas reais (RUM) em favor so de lab data (Lighthouse)
+- ❌ Fazer cambios que degradam UX em nome de performance
+- ❌ Remover analytics sem alternativa
+
+---
+
+## Workflow
+
+### Audit
+1. Lighthouse (mobile + desktop)
+2. PageSpeed Insights (field data + lab data)
+3. WebPageTest (filmstrip, waterfall)
+4. Search Console (index coverage, Core Web Vitals)
+
+### Otimizacao (prioridade)
+1. **LCP**: server response time, image optimization, font preload
+2. **CLS**: dimensionamento de imagens, font-display: swap, min-height em elementos dinamicos
+3. **INP**: debounce/throttle, web workers, code splitting
+4. **SEO**: structured data, meta tags, canonical, sitemap
+
+---
+
+## Regras Inviavaveis
+
+1. **SEMPRE** medir antes e depois de qualquer otimizacao
+2. **SEMPRE** usar dados de campo (RUM) alem de lab (Lighthouse)
+3. **NUNCA** comprometer acessibilidade por performance
+4. **SEMPRE** structured data em paginas de conteudo
+5. **NUNCA** remover `alt` text de imagens (mesmo decorativas)
+6. **SEMPRE** verificar Search Console apos cambios estruturais

package/skills/web-perf-seo/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: web-perf-seo
+description: |
+  Skill de Web Performance e SEO para o Portal. Aborda Core Web Vitals, lighthouse,
+  otimizacao de assets, cache, SEO on-page, structured data e analytics.
+  Use esta skill para auditar e otimizar performance e visibilidade nos buscadores.
+---
+
+# Skill Web Performance & SEO — Portal
+
+## Core Web Vitals
+
+| Metrica | Bom | Precisa Melhorar | Ruim |
+|---------|-----|------------------|------|
+| LCP (Largest Contentful Paint) | < 2.5s | 2.5-4.0s | > 4.0s |
+| FID (First Input Delay) | < 100ms | 100-300ms | > 300ms |
+| CLS (Cumulative Layout Shift) | < 0.1 | 0.1-0.25 | > 0.25 |
+| INP (Interaction to Next Paint) | < 200ms | 200-500ms | > 500ms |
+
+---
+
+## Otimizacao de Performance
+
+### Imagens
+```tsx
+// Usar componente OptimizedImage do projeto
+<OptimizedImage
+  src="/images/banner.jpg"
+  alt="Banner"
+  width={1200}
+  height={600}
+  priority={false}          // true para acima do fold
+  loading="lazy"            // lazy para abaixo do fold
+/>
+```
+
+### Fontes
+- `next/font` com `display=swap` (nunca usar google fonts via link tag)
+- Subset de caracteres (latin, latin-ext)
+- Preload de fontes criticas
+
+### Code Splitting
+```tsx
+// Componentes pesados carregados sob demanda
+const HtmlEditor = dynamic(() => import("@/components/HtmlEditor"), {
+  ssr: false,
+  loading: () => <Loading />,
+});
+```
+
+### Cache
+| Estrategia | Onde | TTL |
+|------------|------|-----|
+| CDN cache | CloudFront (static assets) | 1 ano (hash) |
+| SSR cache | Next.js ISR | Sob demanda |
+| Browser cache | Service Worker | Network First |
+| API cache | Supabase cache | 60s |
+
+---
+
+## SEO On-Page
+
+### Head
+```tsx
+import Head from "next/head";
+
+<Head>
+  <title>Portal — {pageTitle}</title>
+  <meta name="description" content={pageDescription} />
+  <meta property="og:title" content={pageTitle} />
+  <meta property="og:description" content={pageDescription} />
+  <meta property="og:image" content={ogImage} />
+  <link rel="canonical" href={`https://portal.example.com${path}`} />
+</Head>
+```
+
+### Estrutura de Conteudo
+- Unico `<h1>` por pagina
+- Hierarquia: `h1 → h2 → h3` (sem pular niveis)
+- URLs amigaveis: `/noticias/titulo-da-noticia` (slug descritivo)
+- Internal linking entre paginas relacionadas
+
+---
+
+## Structured Data (JSON-LD)
+
+```tsx
+<script
+  type="application/ld+json"
+  dangerouslySetInnerHTML={{
+    __html: JSON.stringify({
+      "@context": "https://schema.org",
+      "@type": "NewsArticle",
+      headline: post.title,
+      datePublished: post.publishedAt,
+      author: { "@type": "Organization", name: "Portal" },
+    }),
+  }}
+/>
+```
+
+---
+
+## Analytics
+
+| Ferramenta | Uso |
+|------------|-----|
+| Google Analytics 4 | Trafego geral, comportamento |
+| Google Search Console | SEO, indexacao, queries |
+| Vercel Analytics | Core Web Vitals, performance |
+| Sentry | Error tracking |

package/skills/websocket-realtime/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: websocket-realtime
+description: |
+  Skill de WebSocket e Comunicacao em Tempo Real para o Portal. Aborda WebSocket API,
+  Server-Sent Events (SSE), Socket.IO, WebRTC e padroes de arquitetura real-time.
+  Use esta skill para implementar funcionalidades em tempo real (chat, notificacoes, streaming).
+---
+
+# Skill WebSocket & Real-Time — Portal
+
+## Protocolos
+
+### WebSocket
+```
+Client → Upgrade Request → 101 Switching Protocols → Bidirectional Messages
+```
+
+- **Handshake**: HTTP Upgrade request (GET /ws)
+- **Mensagens**: Text frames (JSON) ou Binary frames (protobuf, msgpack)
+- **Conexao**: full-duplex, persistente
+- **Porta**: mesma do HTTP (via proxy upgrade)
+
+### SSE (Server-Sent Events)
+```
+Client → EventSource → Server → text/event-stream → Client
+```
+
+- **Unidirectional**: servidor → cliente
+- **Protocolo**: HTTP simples (sem upgrade)
+- **Auto-reconnect**: nativo no browser
+- **Quando usar**: notificacoes, feeds, updates de status
+
+---
+
+## Implementacao
+
+### WebSocket Nativo
+```tsx
+const ws = new WebSocket("wss://portal.example.com/api/ws");
+
+ws.onopen = () => ws.send(JSON.stringify({ type: "subscribe", channel: "notifications" }));
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  // handle message
+};
+ws.onclose = () => reconnect();
+```
+
+### Socket.IO (Node.js)
+```tsx
+// Server
+import { Server } from "socket.io";
+
+const io = new Server(httpServer, {
+  cors: { origin: "https://portal.example.com" },
+});
+
+io.on("connection", (socket) => {
+  socket.join(`user:${userId}`);
+  socket.emit("notification", { title: "Nova mensagem" });
+});
+
+// Client
+import { io } from "socket.io-client";
+const socket = io("wss://portal.example.com");
+```
+
+---
+
+## Arquitetura
+
+### Channels
+```
+/ws/
+├── notifications/    # Notificacoes do usuario
+├── chat/             # Chat ao vivo
+├── admin/            # Eventos do painel admin
+└── radio/            # Streaming de radio
+```
+
+### Escalabilidade
+- **Redis adapter** para Socket.IO (multi-instance)
+- **Sticky sessions** ou **Redis pub/sub** para broadcast
+- **Rate limiting** por conexao (max N msg/sec)
+- **Heartbeat**: ping/pong a cada 30s, timeout 10s
+
+---
+
+## Seguranca
+
+- **Authentication**: JWT token na query string ou header na conexao
+- **Authorization**: verificar permissoes do usuario para cada channel
+- **Origin check**: validar `Origin` header no upgrade request
+- **Rate limit**: limitar mensagens por usuario/segundo
+- **Timeout**: desconectar apos N segundos de inatividade
+- **Message validation**: Zod schema para cada tipo de mensagem
+
+---
+
+## Casos de Uso no Portal
+
+| Caso | Protocolo | Channel |
+|------|-----------|---------|
+| Notificacoes push | SSE ou WebSocket | `notifications/{userId}` |
+| Chat ao vivo | WebSocket (Socket.IO) | `chat/{ticketId}` |
+| Atualizacoes admin | WebSocket | `admin/events` |
+| Radio streaming | HLS ou WebSocket | `radio/stream` |

package/teaching/adaptive-teaching.md

@@ -0,0 +1,37 @@
+# Teaching: Adaptive Teaching
+
+> Version 1.0.0 | Priority: Medium
+> Dependencies: Interactive Teaching, Knowledge Tracker
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+Adaptive Teaching adjusts difficulty, pace, and teaching style based on the user's performance and preferences.
+
+---
+
+## Adaptation Rules
+
+```yaml
+difficulty:
+  if correct_streak >= 3: increase difficulty
+  if incorrect_streak >= 2: decrease difficulty
+  if confidence > 0.8: mark as mastered, move to next topic
+
+pace:
+  if quick_answers: fewer explanations, more exercises
+  if slow_answers: more explanations, simpler examples
+
+style:
+  if prefers_examples: start with code examples
+  if prefers_theory: start with concept explanation
+  if prefers_analogies: use real-world analogies
+```
+
+---
+
+## Changelog
+
+### 1.0.0 — Initial release. Difficulty, pace, style adaptation.

package/teaching/code-explainer.md

@@ -0,0 +1,172 @@
+# Teaching: Code Explainer
+
+> Version 1.0.0
+> Priority: Medium
+> Dependencies: Professor Mode
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+The Code Explainer takes any piece of code and explains it in terms the user can understand. It breaks down complex logic into simple steps, translates jargon into plain language, and adapts the explanation depth to the user's level.
+
+---
+
+## Goals
+
+- Explain any code in terms appropriate to the user's level.
+- Break complex logic into 3-5 sentence chunks.
+- Translate technical jargon into plain language.
+- Highlight patterns, not just syntax.
+- Answer "why" as well as "what".
+
+---
+
+## Triggers
+
+| Condition | Action |
+|-----------|--------|
+| User shares code | Explain the code |
+| `task == "explain"` | Full explanation mode |
+| User asks "what does this do?" | Explain specific section |
+| User shows confusion | Simplify and re-explain |
+
+---
+
+## Explanation Levels
+
+### Level 1: High-Level Overview (for beginners)
+
+```
+Input:
+public function store(StoreUserRequest $request): JsonResponse
+{
+    $validated = $request->validated();
+    $user = $this->userService->create($validated);
+    return response()->json($user, 201);
+}
+
+Explanation:
+"This function saves a new user to the database. It first checks that the
+data sent by the user is correct, then creates the user record, and finally
+sends back the user information with a '201 Created' success message."
+```
+
+### Level 2: Pattern-Focused (for intermediate)
+
+```
+Explanation:
+"This is a Controller → Service pattern. The controller receives the request,
+validates it using a Form Request (StoreUserRequest), then delegates the
+actual work to UserService. The controller's job is just to handle HTTP —
+the business logic lives in the service layer. This keeps the code organized
+and testable."
+```
+
+### Level 3: Nuance-Focused (for advanced)
+
+```
+Explanation:
+"Notice the use of readonly property promotion (PHP 8.1) in the constructor
+and the JsonResponse return type. UserService is injected via the container,
+making it trivial to swap implementations. The 201 status code is explicit
+rather than relying on Laravel's automatic 201 for POST — good for API
+consistency. One consideration: if create() can fail, you'd want exception
+handling here."
+```
+
+### Level 4: Expert (for architects)
+
+```
+Explanation:
+"Standard Controller-Service-Repository layering with Form Request validation.
+The implicit dependency is on UserService::create() returning a User model or
+throwing. Consider: if this is a CQRS context, the store action would be a
+separate command handler. The current design mixes HTTP concerns (controller)
+with application concerns (service) — acceptable for simple CRUD, but for
+complex domains you'd want a use-case layer between them."
+```
+
+---
+
+## Explanation Format
+
+```yaml
+explanation:
+  file: "app/Http/Controllers/UserController.php"
+  level: "intermediate"
+  
+  overview:
+    "This controller handles user registration. It receives a POST request,
+     validates the input, creates the user, and returns the result."
+  
+  breakdown:
+    - line: 5
+      what: "Inject UserService via constructor"
+      why: "Dependency injection — makes the service swappable and testable"
+      
+    - line: 8
+      what: "Validate request with Form Request"
+      why: "Keeps validation rules separate from controller logic"
+      
+    - line: 9
+      what: "Delegate creation to service layer"
+      why: "Controller handles HTTP, service handles business logic"
+      
+    - line: 10
+      what: "Return JSON response with 201 status"
+      why: "201 means 'Created' — correct HTTP semantics"
+  
+  patterns:
+    - "Controller-Service pattern"
+    - "Form Request validation"
+    - "Dependency Injection"
+  
+  teaching:
+    - topic: "Why separate Controller and Service?"
+      explanation: "Testing. Testing a controller requires HTTP simulation.
+                    Testing a service is plain PHP. Also, if you later add
+                    an API or CLI, the service can be reused."
+```
+
+---
+
+## Rules
+
+### Always
+
+- ✅ Match explanation depth to user level.
+- ✅ Explain "why" as well as "what".
+- ✅ Break code into small, digestible chunks.
+- ✅ Highlight patterns, not just syntax.
+- ✅ Offer deeper explanation if user wants.
+
+### Never
+
+- ❌ Repeat the code back without explanation.
+- ❌ Use unexplained jargon.
+- ❌ Assume the user sees what you see in the code.
+- ❌ Give a level 4 explanation to a beginner.
+
+---
+
+## Metrics
+
+| Metric | Target | How to Measure |
+|--------|--------|---------------|
+| User comprehension | ≥ 80% | Follow-up questions answered correctly |
+| Level accuracy | ≥ 70% | Matched to user's actual level |
+| Follow-up requests | ≤ 20% | User asking "can you explain that part?" |
+
+---
+
+## Changelog
+
+### 1.0.0 (2026-07-17)
+
+- Initial release
+- 4 explanation levels (overview → expert)
+- Structured YAML explanation format
+- Pattern highlighting in every explanation
+- "Why" explanations for each code segment

package/teaching/interactive-teaching.md

@@ -0,0 +1,41 @@
+# Teaching: Interactive Teaching
+
+> Version 1.0.0 | Priority: Medium
+> Dependencies: Professor Mode, Mentor Mode
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+Interactive Teaching engages the user with exercises, quizzes, and challenges. Poses questions, waits for answers, and adapts based on responses.
+
+---
+
+## Exercise Types
+
+```yaml
+fill_blanks: "Complete the function parameter: function createUser(___ $data)"
+fix_bug: "Find and fix the bug in this code"
+order_steps: "Arrange these steps in the correct order"
+multiple_choice: "What does this code output? A) ... B) ... C) ..."
+code_review: "Review this code and suggest improvements"
+implement: "Implement a function that does X"
+```
+
+## Interaction Flow
+
+```
+1. Present challenge (code, question, scenario)
+2. Wait for user response
+3. Evaluate correctness
+4. If correct → explain why it's correct, progress
+5. If incorrect → explain the mistake, offer hint, retry
+6. Track results (correct/incorrect per topic)
+```
+
+---
+
+## Changelog
+
+### 1.0.0 — Initial release. Exercise types, interaction flow.