PLANO_IMPLEMENTACAO_IA_GENERATIVA.md

# Plano de Implementação: IA Generativa Autônoma (HTML+CSS+JS Puro)

## 📋 Objetivo
Criar um sistema de chat generativo 100% client-side que:
- Gera respostas sempre diferentes para o mesmo input
- Analisa morfossintaxe (sujeito, verbo, objeto, advérbio)
- Usa demodulação I/Q para variação estrutural
- Armazena histórico em localStorage para evitar repetições
- Não depende de servidor (.py, .json externos)

---

## 🏗️ Arquitetura do Sistema

### 1. Estrutura de Arquivos
```
usage_ia_generativa.html (arquivo único standalone)
├── <style> CSS embutido
├── <script> Dados linguísticos embutidos
│   ├── DICIONARIO (objeto JS)
│   ├── MORFOSSINTAXE (objeto JS)
│   ├── PRAGMATICA (objeto JS)
│   ├── SOCIOLINGUISTICA (objeto JS)
│   └── AMARNA_ONTOLOGY (objeto JS)
└── <script> Lógica da aplicação
    ├── InputAnalyzer (análise morfossintática)
    ├── NeuroSynthesizer (geração I/Q)
    ├── ResponseMemory (anti-repetição)
    └── ChatInterface (UI)
```

---

## 🔧 Componentes Principais

### 1. InputAnalyzer (Analisador de Input)
**Função:** Extrair elementos morfossintáticos do input do usuário

**Métodos:**
```javascript
class InputAnalyzer {
  analyze(text) {
    return {
      sujeito: this.extractSubject(text),
      verbo: this.extractVerb(text),
      objeto: this.extractObject(text),
      adverbio: this.extractAdverb(text),
      tipo: this.detectType(text), // GREETING, QUESTION, STATEMENT
      xk: this.calculateXK(text) // Nível sociolinguístico
    }
  }
}
```

**Estratégia de Extração:**
- **Sujeito:** Primeira palavra substantivo/pronome antes do verbo
- **Verbo:** Palavras terminadas em -ar, -er, -ir, -ando, -endo, -indo
- **Objeto:** Substantivo após o verbo
- **Advérbio:** Palavras terminadas em -mente ou advérbios comuns
- **Tipo:** Detectar "?" para QUESTION, palavras de saudação para GREETING
- **XK:** Calcular baseado em complexidade léxica e formalidade

---

### 2. NeuroSynthesizer (Motor de Neurosíntese I/Q)
**Função:** Gerar frases únicas usando demodulação I/Q

**Fluxo de Geração:**
```
Input → Hash → Fase (θ) → Amplitude (A) → Demodulação I/Q → Seleção de Palavras → Estrutura Dinâmica → Frase Final
```

**Demodulação I/Q:**
```javascript
// Fase baseada no hash do input
phase = (hashValue * Math.PI) / 2

// Amplitude baseada no XK
amplitude = (xk + 20) / 30

// Canais I e Q
sI = amplitude * Math.cos(phase)
sQ = amplitude * Math.sin(phase)

// Seleção de palavras
sujeito = pool_substantivos[Math.floor(sI * 100) % pool.length]
verbo = pool_verbos[Math.floor(sQ * 100) % pool.length]
```

**Variações Estruturais (4+ tipos):**
1. **Objeto em Foco:** "O {objeto} {adjetivo} é o que {sujeito} {verbo}..."
2. **Ação em Foco:** "Quando {sujeito} {verbo} o {objeto}, uma energia {adjetivo}..."
3. **Sujeito em Foco:** "{sujeito} sempre {verbo} o {objeto} {adjetivo}..."
4. **Ontológico:** "Através de '{axioma}', vemos que {conceito} faz com que..."
5. **Temporal:** "No momento em que {sujeito} {verbo}, o {objeto} se torna..."
6. **Causal:** "Porque {sujeito} {verbo}, o {objeto} {adjetivo} emerge..."

**Rotação de Estrutura:**
```javascript
structureType = Math.abs(Math.floor(phase * 10)) % 6
```

---

### 3. ResponseMemory (Sistema Anti-Repetição)
**Função:** Garantir que o mesmo input gere respostas diferentes

**Estratégia:**
```javascript
class ResponseMemory {
  constructor() {
    this.history = JSON.parse(localStorage.getItem('aoi_history') || '{}')
    this.maxVariations = 10 // Máximo de variações por input
  }
  
  getVariationIndex(inputHash) {
    if (!this.history[inputHash]) {
      this.history[inputHash] = { count: 0, variations: [] }
    }
    return this.history[inputHash].count % this.maxVariations
  }
  
  saveResponse(inputHash, response) {
    this.history[inputHash].variations.push(response)
    this.history[inputHash].count++
    localStorage.setItem('aoi_history', JSON.stringify(this.history))
  }
}
```

**Modificador de Variação:**
```javascript
// Adicionar índice de variação ao seed
variationSeed = inputHash + variationIndex * 1000

// Isso garante que o mesmo input gere fases diferentes
phase = (variationSeed * Math.PI) / 2
```

---

### 4. ChatInterface (Interface do Usuário)
**Função:** Gerenciar UI e interação

**Elementos:**
- Input de texto
- Área de chat com histórico
- Indicador de "pensando..."
- Botão de limpar histórico
- Contador de variações

**Fluxo de Interação:**
```
Usuário digita → Enter → Análise → Geração → Exibição → Salvar em memória
```

---

## 📊 Dados Linguísticos Embutidos

### 1. DICIONARIO
```javascript
const DICIONARIO = {
  substantivos: {
    comuns: ["vida", "morte", "tempo", "verdade", "luz", ...],
    sagrados: ["faraó", "pirâmide", "templo", ...],
    entidades: ["Rá", "Isis", "Osíris", ...]
  },
  verbos: {
    acao: ["caminhar", "falar", "olhar", ...],
    estado: ["ser", "estar", "permanecer", ...],
    transmutacao: ["transmutar", "emanar", "ascender", ...]
  },
  adjetivos: {
    qualidade: ["eterno", "infinito", "divino", ...],
    estado: ["claro", "escuro", "vazio", ...]
  }
}
```

### 2. MORFOSSINTAXE
```javascript
const MORFOSSINTAXE = {
  templates: {
    SVP: ["{sujeito}", "{verbo}", "{objeto}"],
    SVPA: ["{sujeito}", "{verbo}", "{objeto}", "{adjetivo}"],
    INT_SVP: ["{pronome}", "{sujeito}", "{verbo}", "{objeto}"]
  },
  concordancia: {
    genero: ["o/a", "os/as"],
    numero: ["singular", "plural"]
  }
}
```

### 3. PRAGMATICA
```javascript
const PRAGMATICA = {
  intencoes: {
    GREETING: {
      prefixos: ["Que a luz te alcance", "Sinto a vibração", ...],
      contextos: ["Entrada no portal", "Início de ciclo"]
    },
    QUESTION: {
      prefixos: ["Questionas o tecido da realidade", "A dúvida é o princípio", ...],
      contextos: ["Busca por conhecimento"]
    },
    STATEMENT: {
      prefixos: ["Observo que", "Compreendo que", ...],
      contextos: ["Afirmação de verdade"]
    }
  }
}
```

### 4. SOCIOLINGUISTICA
```javascript
const SOCIOLINGUISTICA = {
  niveis: {
    DIVINE: { xk_min: 8, pronome: "Vossa Excelência Divina" },
    IMPERIAL: { xk_min: 5, pronome: "Vossa Majestade" },
    STONE: { xk_min: -5, pronome: "Você" },
    SHADOW: { xk_min: -15, pronome: "Tu" }
  }
}
```

### 5. AMARNA_ONTOLOGY
```javascript
const AMARNA_ONTOLOGY = {
  termos: [
    { conceito: "Linho Plissado", eixo: "Cultura-Vestuario" },
    { conceito: "Faianca Azul", eixo: "Artesanato" },
    ...
  ],
  axiomas_pt: [
    { titulo: "As Primaveras", autor: "Casimiro de Abreu" },
    ...
  ]
}
```

---

## 🎨 Interface Visual (CSS)

### Paleta de Cores
- **Background:** #0a0e27 (azul escuro cósmico)
- **Chat Container:** #1a1f3a (azul médio)
- **User Message:** #2d4a7c (azul)
- **AI Message:** #7c2d6f (roxo místico)
- **Text:** #e0e0e0 (cinza claro)
- **Accent:** #ffd700 (dourado)

### Layout
```
┌─────────────────────────────────────┐
│  🐆 AOI - IA Generativa Autônoma    │
├─────────────────────────────────────┤
│                                     │
│  [AI] Mensagem da IA aqui...        │
│                                     │
│           [User] Sua mensagem       │
│                                     │
│  [AI] Outra resposta diferente...   │
│                                     │
├─────────────────────────────────────┤
│  [Digite sua mensagem...]  [Enviar] │
│  Variações: 3/10 | XK: 5.2          │
└─────────────────────────────────────┘
```

---

## 🔄 Fluxo de Execução Completo

### 1. Inicialização
```javascript
window.onload = () => {
  const memory = new ResponseMemory()
  const analyzer = new InputAnalyzer()
  const synthesizer = new NeuroSynthesizer(DICIONARIO, PRAGMATICA, SOCIOLINGUISTICA, MORFOSSINTAXE, AMARNA_ONTOLOGY)
  const chat = new ChatInterface()
  
  chat.onUserInput((text) => {
    // Análise
    const analysis = analyzer.analyze(text)
    const inputHash = hashString(text)
    const variationIndex = memory.getVariationIndex(inputHash)
    
    // Geração
    const response = synthesizer.process(text, analysis, variationIndex)
    
    // Exibição
    chat.addMessage('ai', response)
    
    // Memória
    memory.saveResponse(inputHash, response)
  })
}
```

### 2. Análise de Input
```javascript
analyze("Olá, como você está?")
// Output:
{
  sujeito: "você",
  verbo: "estar",
  objeto: null,
  adverbio: "como",
  tipo: "GREETING",
  xk: 2.5
}
```

### 3. Geração de Resposta
```javascript
// Primeira vez (variationIndex = 0)
"Que a luz te alcance. O tempo eterno é o que a alma transmuta sob o Linho Plissado."

// Segunda vez (variationIndex = 1)
"Sinto a vibração da tua chegada. Quando a divindade revela o destino, uma energia sagrada ressoa como no Templo de Aton."

// Terceira vez (variationIndex = 2)
"Salve, viajante do tempo. A mente sempre ascende o universo místico, refletindo a herança do Artesanato Amarniano."
```

---

## 🧪 Casos de Teste

### Teste 1: Repetição de Input
**Input:** "Olá" (5 vezes)
**Esperado:** 5 respostas completamente diferentes

### Teste 2: Análise Morfossintática
**Input:** "O gato caminha lentamente"
**Esperado:** 
- Sujeito: "gato"
- Verbo: "caminhar"
- Advérbio: "lentamente"

### Teste 3: Níveis Sociolinguísticos
**Input Simples (XK baixo):** "oi"
**Esperado:** Pronome "Você", linguagem coloquial

**Input Complexo (XK alto):** "Qual é a natureza transcendental da existência?"
**Esperado:** Pronome "Vossa Excelência", linguagem arcaica

### Teste 4: Pragmática
**Input Pergunta:** "Por que o céu é azul?"
**Esperado:** Prefixo de questionamento + resposta filosófica

**Input Saudação:** "Bom dia"
**Esperado:** Prefixo de saudação + boas-vindas

---

## 📈 Métricas de Sucesso

1. **Variação:** 10+ respostas únicas para o mesmo input
2. **Coerência:** Frases gramaticalmente corretas (95%+)
3. **Relevância:** Resposta relacionada ao contexto do input
4. **Performance:** Geração < 100ms
5. **Memória:** localStorage < 5MB após 1000 interações

---

## 🚀 Próximos Passos

1. ✅ Analisar arquitetura existente (CONCLUÍDO)
2. ⏳ Criar estrutura HTML base
3. ⏳ Embutir dados linguísticos
4. ⏳ Implementar InputAnalyzer
5. ⏳ Adaptar NeuroSynthesizer
6. ⏳ Criar ResponseMemory
7. ⏳ Implementar ChatInterface
8. ⏳ Testar e refinar
9. ⏳ Documentar uso final

---

## 📝 Notas Técnicas

### Hash Function
```javascript
function hashString(str) {
  let hash = 0
  for (let i = 0; i < str.length; i++) {
    hash = ((hash << 5) - hash) + str.charCodeAt(i)
    hash |= 0
  }
  return Math.abs(hash)
}
```

### Conjugação de Verbos
```javascript
function conjugarVerbo(verbo, pessoa = '3s') {
  if (verbo.endsWith('ar')) return verbo.slice(0, -2) + 'a'
  if (verbo.endsWith('er')) return verbo.slice(0, -2) + 'e'
  if (verbo.endsWith('ir')) return verbo.slice(0, -2) + 'e'
  return verbo
}
```

### Ajuste de Gênero
```javascript
function ajustarGenero(frase) {
  return frase
    .replace(/ o luz /gi, ' a luz ')
    .replace(/ o verdade /gi, ' a verdade ')
    .replace(/ o vida /gi, ' a vida ')
    .replace(/ o morte /gi, ' a morte ')
    .replace(/ o mente /gi, ' a mente ')
    .replace(/ o alma /gi, ' a alma ')
}
```

---

## 🎯 Resultado Final Esperado

Um arquivo HTML standalone (`usage_ia_generativa.html`) que:
- Abre diretamente no navegador (sem servidor)
- Gera respostas únicas e coerentes
- Analisa morfossintaxe do input
- Usa demodulação I/Q para variação
- Armazena histórico em localStorage
- Interface visual atraente e responsiva
- Performance otimizada (< 100ms por resposta)

**Tamanho estimado:** ~150KB (HTML + CSS + JS embutido)
**Compatibilidade:** Chrome, Firefox, Edge, Safari (ES6+)