@gabrihhh/jarvis 2.2.2 → 2.4.0

package/.claude/skills/MEMORY_ARCHITECTURE.md

@@ -0,0 +1,172 @@
+# Memory Architecture — Contrato do Grafo de Memória Semântica
+
+Este documento é a fonte de verdade para as skills `/create-memory` e `/update-memory`.
+Toda decisão de indexação deve seguir as regras aqui definidas.
+
+---
+
+## 1. Schema do Grafo
+
+### Nodes
+
+| Node | Propriedades | Unicidade |
+|---|---|---|
+| `Project` | name, path, description, language, branch, createdAt | (name, branch) |
+| `Module` | name, path, domain, projectName, branch | (path, projectName, branch) |
+| `File` | path, name, extension, purpose, projectName, branch | (path, projectName, branch) |
+| `Concept` | name, projectName | (name, projectName) |
+| `Pattern` | name, description | name — **global, compartilhado entre projetos** |
+| `Dependency` | name, version, type, projectName, branch | (name, projectName, branch) |
+
+### Relationships
+
+```
+Project  -[:HAS_MODULE]->  Module
+Module   -[:CONTAINS]->    File
+Module   -[:HANDLES]->     Concept
+Module   -[:IMPLEMENTS]->  Pattern
+Module   -[:DEPENDS_ON]->  Module
+Project  -[:USES_PATTERN]-> Pattern
+```
+
+### Notas do schema
+
+- `Pattern` é o único nó global — o mesmo padrão pode ser compartilhado entre projetos
+- `Concept` é sempre vinculado ao projeto — "pedido" no projeto A ≠ "pedido" no projeto B
+- `Dependency` registra apenas dependências diretas (package.json, go.mod, etc.), nunca transitivas
+
+---
+
+## 2. Regras de Indexação
+
+### O que É um módulo
+
+- Um diretório com **responsabilidade coesa e identificável**
+- Exemplos: `src/auth`, `src/memory`, `.claude/skills`, `bin`
+- Profundidade máxima: 2 níveis a partir da raiz do projeto (ex: `src/memory` é válido, `src/memory/adapters/neo4j` não)
+- Diretórios "standalone" com um único arquivo importante podem ser tratados como módulo
+
+### O que NÃO é um módulo
+
+- `node_modules/`, `.git/`, `dist/`, `build/`, `.next/`, `__pycache__/`
+- Diretórios de configuração trivial (`.husky/`, `.vscode/`)
+- Diretórios gerados automaticamente
+
+### O que É um arquivo indexável
+
+- Arquivos com lógica de negócio: `.js`, `.ts`, `.py`, `.go`, `.php`, `.java`, `.rb`, `.rs`
+- Entry points, services, controllers, handlers, routers, models
+- Arquivos de skill/automação (`.md` de skills)
+
+### O que NÃO indexar como arquivo
+
+- Lock files (`package-lock.json`, `yarn.lock`, `*.lock`)
+- Arquivos minificados ou gerados
+- Arquivos de configuração sem lógica (`tsconfig.json`, `.eslintrc`)
+- Binários
+
+### Conceitos: domínio, não técnica
+
+- **Certo:** `autenticação`, `sessão`, `pedido`, `faturamento`, `status bar`, `injeção de contexto`
+- **Errado:** `string`, `array`, `request`, `handler`, `utils`
+- Conceitos em português quando o domínio é brasileiro, inglês quando o projeto é internacional
+
+### Padrões: nomes canônicos
+
+- Usar nomes reconhecíveis: `Repository Pattern`, `MCP Protocol`, `Command Pattern`, `Pipeline`, `Single Responsibility`, `Observer`, `Factory`, `Middleware`
+- Nunca inventar nomes de padrões
+
+### Granularidade do domain (Module.domain)
+
+- Frase curta e descritiva: `"Autenticação de usuários"`, `"Grafo de memória semântica"`, `"Dashboard de uso do terminal"`
+- Nunca genérico: `"Utilitários"`, `"Helpers"`, `"Misc"`
+
+---
+
+## 3. Fluxo de Criação (`/create-memory`)
+
+Usado quando o projeto **não existe** no grafo ou se deseja reindexar do zero.
+
+```
+Passo 0 → Selecionar branch (main ou qa)
+Passo 1 → Descoberta inicial (manifesto, estrutura, dependências)
+Passo 2 → Análise profunda por módulo (arquivos, padrões, conceitos, deps)
+Passo 3 → Montagem do mapa completo (sem salvar ainda)
+Passo 4 → Apresentação ao usuário para aprovação e correção
+Passo 5 → Gravação via save-project após "pode salvar"
+```
+
+**Regra:** nunca salvar sem aprovação explícita.
+
+---
+
+## 4. Fluxo de Atualização (`/update-memory`)
+
+Usado quando o projeto **já existe** no grafo e houve mudanças no repositório.
+
+```
+Passo 0 → Consultar grafo atual (query-project)
+Passo 1 → Detectar mudanças via git (git log + git diff)
+Passo 2 → Calcular delta (novo, modificado, removido)
+Passo 3 → Re-analisar apenas módulos afetados
+Passo 4 → Apresentar delta ao usuário (antes vs. depois)
+Passo 5 → Aplicar merge via save-project após aprovação
+```
+
+**Comportamento do save-project:** usa `MERGE` — adiciona e atualiza, nunca deleta.
+**Limitação v1:** módulos removidos do código permanecem como nós órfãos no grafo.
+Módulos removidos devem ser sinalizados ao usuário no Passo 4 com um aviso explícito.
+
+---
+
+## 5. Critérios de Qualidade
+
+### Grafo saudável
+
+- Cada módulo tem `domain` específico e não genérico
+- Conceitos refletem o vocabulário do produto/negócio
+- Relações `DEPENDS_ON` são reais e verificadas no código
+- Patterns são nomes canônicos da literatura
+
+### Sinais de grafo poluído
+
+- Módulos com `domain: "utilitários"` ou `"misc"`
+- Conceitos técnicos: `"json"`, `"http"`, `"string"`
+- Arquivos de config indexados como arquivos relevantes
+- Mais de 15 arquivos por módulo sem subdivisão
+- Módulos sem nenhum conceito associado
+
+---
+
+## 6. Objeto canônico para save-project
+
+```json
+{
+  "project": {
+    "name": "<nome do repositório>",
+    "path": "<path absoluto>",
+    "description": "<uma linha descrevendo o que o projeto faz>",
+    "language": "<linguagem principal>",
+    "branch": "main | qa"
+  },
+  "modules": [
+    {
+      "name": "<nome do diretório ou nome semântico>",
+      "path": "<path relativo ao root>",
+      "domain": "<responsabilidade em frase curta>",
+      "files": [
+        { "path": "<path relativo>", "purpose": "<o que este arquivo faz>" }
+      ],
+      "patterns": ["Repository Pattern", "MCP Protocol"],
+      "concepts": ["autenticação", "sessão"],
+      "dependsOn": ["<nome de outro módulo deste projeto>"]
+    }
+  ],
+  "dependencies": [
+    { "name": "<pacote>", "version": "<versão>", "type": "external | internal" }
+  ],
+  "patterns": [
+    { "name": "<nome canônico>", "description": "<descrição do padrão>" }
+  ]
+}
+```

package/.claude/skills/configure-memory/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: configure-memory
+description: Configurar a arquitetura do grafo de memória semântica — personaliza o schema, regras e fluxos usados pelo /create-memory e /update-memory
+---
+
+# /configure-memory — Configurar Arquitetura de Memória
+
+Você vai guiar o usuário para criar ou modificar a arquitetura do grafo de memória semântica.
+O resultado será salvo em `~/.claude/skills/MEMORY_ARCHITECTURE.md`, substituindo o padrão e sendo usado pelo `/create-memory` e `/update-memory`.
+
+## REGRA GLOBAL
+
+- Nunca salvar sem aprovação explícita do usuário
+- Se qualquer intenção do usuário for ambígua, pergunte antes de continuar
+- Ao final, sempre mostrar o arquivo completo gerado antes de salvar
+
+---
+
+## Passo 0 — Ler arquitetura atual
+
+Leia o arquivo `~/.claude/skills/MEMORY_ARCHITECTURE.md`.
+
+Se não existir, informe: "Nenhuma arquitetura customizada encontrada. Usarei a arquitetura padrão como base."
+Nesse caso, use o conteúdo padrão definido internamente (schema básico com Project, Module, File, Concept, Pattern, Dependency).
+
+---
+
+## Passo 1 — Entender a intenção
+
+Apresente as duas opções ao usuário:
+
+```
+Como deseja proceder?
+
+  1. Modificar a arquitetura atual (ajustar regras, schema ou convenções)
+  2. Criar uma arquitetura do zero (descreva o que precisa)
+```
+
+Aguarde a resposta antes de continuar.
+
+---
+
+## Passo 2a — Se escolher "Modificar"
+
+Mostre um resumo da arquitetura atual (schema e regras principais) e pergunte:
+
+```
+O que deseja modificar? Exemplos:
+  • Adicionar/remover tipos de nó
+  • Mudar regras de granularidade de módulo
+  • Alterar convenções de naming (português/inglês, etc.)
+  • Adicionar/remover tipos de relacionamento
+  • Mudar critérios de qualidade
+  • Ajustar regras de o que indexar/ignorar
+```
+
+Conduza a conversa até ter clareza completa sobre cada alteração desejada.
+Se o usuário der uma instrução vaga ("quero algo mais simples"), faça perguntas de refinamento:
+- "Simples em qual sentido? Menos tipos de nó? Menos regras?"
+- "Pode me dar um exemplo do que ficaria fora?"
+
+---
+
+## Passo 2b — Se escolher "Do zero"
+
+Conduza uma conversa estruturada com estas perguntas (adapte conforme as respostas):
+
+**Sobre o domínio:**
+- "Que tipo de projetos você vai indexar? (frontend, backend, monorepo, scripts, etc.)"
+- "Qual linguagem/stack predominante?"
+- "Qual o vocabulário do seu domínio? (ex: pedidos, clientes, eventos, pipelines)"
+
+**Sobre o schema:**
+- "Além de módulos e arquivos, quer rastrear algo mais? (ex: serviços externos, tabelas de banco, endpoints de API)"
+- "Quer rastrear relacionamentos entre projetos diferentes?"
+- "Padrões de design são relevantes para o seu contexto?"
+
+**Sobre as regras:**
+- "Qual é a granularidade ideal de módulo para você? (diretório? feature? domínio de negócio?)"
+- "Há diretórios/arquivos específicos que sempre devem ser ignorados no seu contexto?"
+- "Prefere conceitos em português, inglês ou misto?"
+
+**Sobre os fluxos:**
+- "Quer manter o fluxo de aprovação antes de salvar, ou prefere algo mais direto?"
+- "O /update-memory deve sempre mostrar o delta ou pode salvar direto se as mudanças forem pequenas?"
+
+Continue perguntando até ter uma visão clara e completa da arquitetura desejada.
+
+---
+
+## Passo 3 — Gerar a arquitetura
+
+Com base na conversa, gere o arquivo completo `MEMORY_ARCHITECTURE.md` seguindo esta estrutura:
+
+```markdown
+# Memory Architecture — [título que reflita o contexto do usuário]
+
+[descrição breve do propósito desta configuração]
+
+---
+
+## 1. Schema do Grafo
+
+### Nodes
+[tabela com nodes, propriedades e unicidade]
+
+### Relationships
+[diagrama em texto]
+
+### Notas do schema
+[decisões e justificativas]
+
+---
+
+## 2. Regras de Indexação
+
+### O que É um módulo
+[definição específica para o contexto do usuário]
+
+### O que NÃO é um módulo
+[exclusões]
+
+### O que É um arquivo indexável
+[critérios]
+
+### O que NÃO indexar
+[exclusões]
+
+### Convenções de naming
+[padrões de escrita para domain, concepts, patterns]
+
+---
+
+## 3. Fluxo de Criação (/create-memory)
+[resumo do fluxo, com qualquer customização]
+
+---
+
+## 4. Fluxo de Atualização (/update-memory)
+[resumo do fluxo, com qualquer customização]
+
+---
+
+## 5. Critérios de Qualidade
+
+### Grafo saudável
+[sinais positivos]
+
+### Sinais de grafo poluído
+[antipadrões a evitar]
+
+---
+
+## 6. Objeto canônico para save-project
+[exemplo JSON com os campos relevantes para este contexto]
+```
+
+---
+
+## Passo 4 — Apresentar para aprovação
+
+Mostre o arquivo **completo** gerado ao usuário.
+
+Diga: **"Esta é a arquitetura que vou salvar em `~/.claude/skills/MEMORY_ARCHITECTURE.md`. Revise, corrija o que quiser, e me diga 'pode salvar' quando estiver pronto."**
+
+Se o usuário pedir ajustes:
+- Aplique, mostre o trecho alterado
+- Confirme: "Ajustei X. Mais alguma coisa antes de salvar?"
+- Repita até aprovação
+
+---
+
+## Passo 5 — Salvar
+
+Após aprovação explícita, salve o conteúdo gerado em:
+
+```
+~/.claude/skills/MEMORY_ARCHITECTURE.md
+```
+
+Informe ao usuário:
+**"Arquitetura salva. O `/create-memory` e o `/update-memory` já vão usar essa configuração a partir de agora."**
+
+Se quiser restaurar o padrão no futuro: **"Rode `jarvis --setup` novamente para reinstalar a arquitetura padrão."**

package/.claude/skills/create-memory/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: create-memory
+description: Indexar repositório atual no grafo de memória semântica (Neo4j) do zero
+---
+
+# /create-memory — Criar Índice de Memória do Repositório
+
+Você vai analisar o repositório atual de forma exaustiva e indexar seu entendimento no Neo4j.
+
+**Antes de iniciar:** leia `.claude/skills/MEMORY_ARCHITECTURE.md` — ele define o schema do grafo, as regras de indexação e os critérios de qualidade que você deve seguir durante toda a execução desta skill.
+
+## PRÉ-REQUISITO — Verificar ambiente
+
+Antes de qualquer passo, chame a MCP tool:
+```
+list-projects()
+```
+
+Se a tool retornar erro de conexão, tool não encontrada ou MCP indisponível:
+**"O MCP server `jarvis-memory` não está acessível. Execute `/setup-memory` primeiro e reinicie o Claude Code antes de continuar."**
+Interrompa aqui — não prossiga.
+
+Se a tool responder (mesmo que com "Nenhum projeto indexado"), o ambiente está pronto. Continue.
+
+---
+
+## REGRA GLOBAL
+
+- Se travar em qualquer ponto — dúvida técnica, conceitual, arquivo ilegível, ambiguidade de qualquer natureza — **pare e pergunte ao usuário** antes de continuar
+- Não há limite de perguntas. Prefira perguntar a gravar algo errado
+- Só chame a MCP tool `save-project` após o usuário dizer explicitamente "pode salvar" ou equivalente
+
+---
+
+## Passo 0 — Seleção de Branch
+
+Pergunte ao usuário: **"Deseja indexar o branch `main` ou `qa`?"**
+
+Após a resposta, execute:
+```bash
+git checkout <branch-escolhido>
+git pull origin <branch-escolhido>
+git branch --show-current
+```
+
+Se qualquer comando falhar (branch inexistente, conflitos, sem remote), pergunte ao usuário o que fazer antes de continuar.
+
+---
+
+## Passo 1 — Descoberta Inicial
+
+```bash
+# Manifesto principal do projeto
+cat package.json 2>/dev/null || cat composer.json 2>/dev/null || cat pyproject.toml 2>/dev/null || cat go.mod 2>/dev/null || echo "Nenhum manifesto padrão encontrado"
+
+# Estrutura de diretórios (sem ruído)
+find . -maxdepth 3 -type d \
+  ! -path "*/node_modules/*" ! -path "*/.git/*" \
+  ! -path "*/dist/*" ! -path "*/build/*" ! -path "*/.next/*"
+
+# Arquivos de configuração relevantes
+find . -maxdepth 2 -type f \( -name "*.json" -o -name "*.toml" -o -name "*.yaml" -o -name "*.yml" \) \
+  ! -path "*/node_modules/*" ! -path "*/.git/*"
+```
+
+Identifique com base no output:
+- Linguagem principal e framework
+- Candidatos a módulos (diretórios com responsabilidade identificável)
+- Dependências do manifesto
+
+Consulte `MEMORY_ARCHITECTURE.md §2` para decidir o que é ou não um módulo.
+
+---
+
+## Passo 2 — Análise Profunda
+
+Para cada módulo candidato:
+
+**1. Liste os arquivos:**
+```bash
+find <diretório> -type f \
+  ! -path "*/node_modules/*" ! -path "*/.git/*" \
+  ! -name "*.lock" ! -name "package-lock.json"
+```
+
+**2. Leia os arquivos relevantes** (entry points, services, controllers, handlers, routers, models).
+
+**3. Para cada arquivo, determine:**
+- **Responsabilidade:** o que este arquivo faz?
+- **Imports/Exports:** quais módulos ele usa ou expõe?
+- **Padrões:** nomes canônicos conforme `MEMORY_ARCHITECTURE.md §2`
+- **Conceitos de negócio:** conforme regra de domínio em `MEMORY_ARCHITECTURE.md §2`
+
+**A qualquer momento de incerteza → pergunte ao usuário.**
+
+---
+
+## Passo 3 — Montagem do Mapa
+
+Consolide o mapa completo (sem salvar ainda):
+
+```
+Projeto: <nome> [<branch>]
+Linguagem: <linguagem>
+Descrição: <descrição curta>
+
+Módulos:
+  - <nome> | Domínio: <domain> | Path: <path>
+    Arquivos: [lista com purpose de cada um]
+    Padrões: [padrões identificados]
+    Conceitos: [conceitos de negócio]
+    Depende de: [outros módulos do projeto]
+
+Padrões globais do projeto: [lista]
+Dependências externas relevantes: [nome, versão, tipo]
+```
+
+Valide o mapa contra os critérios de qualidade em `MEMORY_ARCHITECTURE.md §5` antes de apresentar.
+
+---
+
+## Passo 4 — Apresentação para Aprovação
+
+Apresente o mapa completo ao usuário de forma clara e legível.
+
+Diga ao final: **"Este é meu entendimento completo do projeto. Revise, corrija o que estiver errado, e quando estiver tudo certo me diga 'pode salvar'."**
+
+Se o usuário corrigir algo:
+- Atualize o mapa
+- Confirme: "Entendido. Corrigi X para Y. Mais alguma correção?"
+- Repita até aprovação explícita
+
+---
+
+## Passo 5 — Gravação
+
+Após aprovação explícita, chame `save-project` com o objeto canônico definido em `MEMORY_ARCHITECTURE.md §6`.
+
+Após sucesso:
+**"Projeto `<nome>` [<branch>] indexado com sucesso no grafo de memória."**

package/.claude/skills/setup-memory/SKILL.md

@@ -110,4 +110,4 @@ Informe ao usuário:
 - "Neo4j rodando em http://localhost:7474 (interface web) e bolt://localhost:7687"
 - "MCP server `jarvis-memory` registrado em ~/.claude/settings.json"
 - "**Reinicie o Claude Code** para que o MCP server seja ativado"
-- "Após reiniciar, use `/memory-index` para indexar seu primeiro repositório"
+- "Após reiniciar, use `/create-memory` para indexar seu primeiro repositório"

package/.claude/skills/update-memory/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: update-memory
+description: Atualizar o índice de memória semântica (Neo4j) de um repositório já indexado com base nas mudanças recentes
+---
+
+# /update-memory — Atualizar Memória do Repositório
+
+Você vai identificar o que mudou no repositório desde a última indexação e aplicar as atualizações no grafo de memória.
+
+**Antes de iniciar:** leia `.claude/skills/MEMORY_ARCHITECTURE.md` — ele define o schema, as regras de indexação e os critérios de qualidade que guiam esta skill.
+
+## PRÉ-REQUISITO — Verificar ambiente
+
+Antes de qualquer passo, chame a MCP tool:
+```
+list-projects()
+```
+
+Se a tool retornar erro de conexão, tool não encontrada ou MCP indisponível:
+**"O MCP server `jarvis-memory` não está acessível. Execute `/setup-memory` primeiro e reinicie o Claude Code antes de continuar."**
+Interrompa aqui — não prossiga.
+
+Se a tool retornar "Nenhum projeto indexado ainda":
+**"Nenhum projeto indexado encontrado. Execute `/create-memory` primeiro para criar o índice inicial."**
+Interrompa aqui — não prossiga.
+
+Se a tool listar projetos, o ambiente está pronto. Continue.
+
+---
+
+## REGRA GLOBAL
+
+- Se travar em qualquer ponto — dúvida técnica, ambiguidade, mudança que não entende — **pare e pergunte ao usuário**
+- Só chame `save-project` após aprovação explícita do usuário
+- **Nunca re-indexar o projeto inteiro** — se detectar que a mudança é muito grande, sugira usar `/create-memory` no lugar
+
+---
+
+## Passo 0 — Consultar Estado Atual do Grafo
+
+Chame a MCP tool `query-project` para obter o estado atual indexado:
+
+```
+query-project(name: "<nome do projeto>", branch: "<branch>")
+```
+
+Se o projeto não estiver indexado, interrompa e informe:
+**"Este projeto não está indexado ainda. Use `/create-memory` para criar o índice inicial."**
+
+Anote o estado atual: módulos existentes, conceitos, padrões.
+
+---
+
+## Passo 1 — Detectar Mudanças no Repositório
+
+Execute os comandos abaixo para entender o que mudou:
+
+```bash
+# Commits recentes (para ter contexto das mudanças)
+git log --oneline -20
+
+# Arquivos modificados nos últimos commits (ajuste N conforme necessário)
+git diff HEAD~5..HEAD --name-status
+
+# Arquivos modificados e não commitados (trabalho em andamento)
+git status --short
+
+# Resumo de quais diretórios foram afetados
+git diff HEAD~5..HEAD --name-only | sed 's|/[^/]*$||' | sort -u
+```
+
+Se o projeto não tiver histórico git ou a última indexação for muito antiga, pergunte ao usuário qual período considerar.
+
+---
+
+## Passo 2 — Calcular o Delta
+
+Com base nos arquivos modificados, classifique cada mudança:
+
+### Módulos novos
+Diretórios que apareceram e não existem no grafo atual.
+
+### Módulos modificados
+Diretórios cujos arquivos foram alterados (novos arquivos, arquivos removidos, lógica modificada).
+
+### Módulos removidos
+Diretórios que existiam no grafo mas não existem mais no código.
+> ⚠️ **Limitação v1:** `save-project` não deleta nós — módulos removidos serão sinalizados ao usuário mas não removidos automaticamente do grafo.
+
+### Novos conceitos / padrões
+Identificados na análise dos módulos modificados que não constam no grafo atual.
+
+Apresente o delta inicial ao usuário antes de continuar a análise profunda:
+
+```
+Delta detectado:
+  ✅ Módulos novos: [lista]
+  🔄 Módulos modificados: [lista]
+  ⚠️  Módulos removidos (ficam no grafo — não são deletados automaticamente): [lista]
+```
+
+Pergunte: **"Este delta está correto? Posso prosseguir com a análise?"**
+
+---
+
+## Passo 3 — Re-analisar Módulos Afetados
+
+Para cada módulo **novo** ou **modificado** (apenas esses):
+
+**1. Liste os arquivos atuais:**
+```bash
+find <diretório> -type f \
+  ! -path "*/node_modules/*" ! -path "*/.git/*" \
+  ! -name "*.lock"
+```
+
+**2. Leia os arquivos relevantes.**
+
+**3. Determine para cada arquivo:**
+- Responsabilidade
+- Padrões (nomes canônicos conforme `MEMORY_ARCHITECTURE.md §2`)
+- Conceitos de negócio (domínio, não termos técnicos)
+- Dependências de outros módulos
+
+**A qualquer incerteza → pergunte ao usuário.**
+
+---
+
+## Passo 4 — Apresentar Delta Completo
+
+Apresente o mapa atualizado apenas com o que vai mudar:
+
+```
+## Atualização proposta para <nome do projeto> [<branch>]
+
+### Módulos novos
+  - <nome> | Domínio: <domain> | Path: <path>
+    Arquivos: [lista]
+    Padrões: [lista]
+    Conceitos: [lista]
+    Depende de: [lista]
+
+### Módulos atualizados
+  - <nome> | Antes: <domain antigo> → Depois: <domain novo>
+    Arquivos adicionados: [lista]
+    Arquivos removidos: [lista]
+    Novos conceitos: [lista]
+    Novos padrões: [lista]
+
+### ⚠️ Módulos removidos do código (permanecem no grafo nesta versão)
+  - <nome> — ainda presente no grafo, mas não encontrado no código
+```
+
+Diga ao final: **"Este é o delta que vou aplicar. Corrija o que estiver errado e me diga 'pode salvar' quando estiver pronto."**
+
+---
+
+## Passo 5 — Aplicar Merge no Grafo
+
+Após aprovação explícita, monte o objeto completo do projeto (estado atual do grafo + mudanças do delta) e chame `save-project`.
+
+O `save-project` usa `MERGE` — atualiza e adiciona, nunca deleta. O resultado será um merge seguro.
+
+Use o objeto canônico definido em `MEMORY_ARCHITECTURE.md §6`.
+
+Após sucesso:
+**"Memória de `<nome>` [<branch>] atualizada. <N> módulos processados."**
+
+Se houver módulos removidos não tratados:
+**"⚠️ Os módulos `<lista>` foram removidos do código mas ainda existem no grafo. Para removê-los, será necessário um tool de limpeza (previsto para v2)."**

package/README.md

@@ -17,17 +17,30 @@ Reinicie o Claude Code após o setup.
 
 ## Comandos
 
+**CLI:**
+
 | Comando | Descrição |
 |---|---|
 | `jarvis` | Mostra a versão |
 | `jarvis --usage` | Dashboard completo de uso (tokens, custo, contexto) |
 | `jarvis --watch` | Dashboard com auto-refresh a cada 30s |
-| `jarvis --setup` | Configura status bar e instala slash commands |
+| `jarvis --setup` | Configura status bar, instala slash commands e define trigger padrão |
 | `jarvis --graph` | Abre o Neo4j Browser em localhost:7474 |
+| `jarvis --trigger` | Mostra o modo de trigger atual |
+| `jarvis --trigger session` | Hook de memória roda uma vez por sessão *(padrão)* |
+| `jarvis --trigger prompt` | Hook de memória roda a cada prompt |
+| `jarvis --trigger off` | Desativa o carregamento automático de memória |
 | `jarvis --line` | Saída de uma linha usada internamente pela status bar |
 | `jarvis --help` | Lista todos os comandos |
-| `/setup-memory` | *(Claude Code)* Sobe Neo4j via Docker e registra o MCP server |
-| `/memory-index` | *(Claude Code)* Indexa um repositório no grafo de memória |
+
+**Slash commands** *(dentro do Claude Code)*:
+
+| Comando | Descrição |
+|---|---|
+| `/setup-memory` | Sobe Neo4j via Docker e registra o MCP server |
+| `/create-memory` | Indexa um repositório no grafo de memória (primeira vez) |
+| `/update-memory` | Atualiza o grafo com as mudanças recentes do repositório |
+| `/configure-memory` | Personaliza o schema, regras e fluxos da arquitetura de memória |
 
 ---
 

package/bin/jarvis.js

@@ -4,11 +4,36 @@ import { renderLine } from '../src/statusline.js';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
-import { exec } from 'child_process';
+import { exec, execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 
 const MEMORY_CONFIG_PATH = join(homedir(), '.claude-memory.json');
 
+function checkSetupDone() {
+  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  if (!existsSync(settingsPath)) return false;
+  try {
+    const s = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    return !!(s?.statusLine);
+  } catch { return false; }
+}
+
+function checkMcpRegistered() {
+  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  if (!existsSync(settingsPath)) return false;
+  try {
+    const s = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    return !!(s?.mcpServers?.['jarvis-memory']);
+  } catch { return false; }
+}
+
+function checkNeo4jRunning() {
+  try {
+    const out = execSync('docker ps --filter name=claude-memory --filter status=running --format "{{.Names}}"', { stdio: 'pipe' }).toString().trim();
+    return out.includes('claude-memory');
+  } catch { return false; }
+}
+
 function loadMemoryConfig() {
   try { return JSON.parse(readFileSync(MEMORY_CONFIG_PATH, 'utf-8')); }
   catch { return { neo4j: { uri: 'bolt://localhost:7687', user: 'neo4j', password: 'claudememory' } }; }
@@ -55,7 +80,9 @@ if (args.includes('--help') || args.includes('-h')) {
 
   Slash commands (inside Claude Code):
     /setup-memory                Setup Docker + Neo4j + register MCP server
-    /memory-index                Index a repository into the memory graph
+    /create-memory               Index a repository into the memory graph (first time)
+    /update-memory               Update an existing memory graph with recent changes
+    /configure-memory            Customize the memory graph architecture (schema, rules, flows)
 
   Data source: ~/.claude/projects/
 `);
@@ -63,6 +90,11 @@ if (args.includes('--help') || args.includes('-h')) {
 }
 
 if (args.includes('--graph')) {
+  if (!checkNeo4jRunning()) {
+    console.error('\n  ✗ Neo4j não está rodando.');
+    console.error('  Execute /setup-memory dentro do Claude Code para iniciar o container.\n');
+    process.exit(1);
+  }
   const url = 'http://localhost:7474';
   const opener =
     process.platform === 'darwin' ? 'open' :
@@ -88,13 +120,17 @@ if (args.includes('--graph')) {
   // Slash commands → ~/.claude/skills/<name>/SKILL.md
   const skillsDir = join(homedir(), '.claude', 'skills');
   const srcSkills = join(__dir, '../.claude/skills');
-  for (const skill of ['setup-memory', 'memory-index']) {
+  for (const skill of ['setup-memory', 'create-memory', 'update-memory', 'configure-memory']) {
     const destDir = join(skillsDir, skill);
     mkdirSync(destDir, { recursive: true });
     copyFileSync(join(srcSkills, skill, 'SKILL.md'), join(destDir, 'SKILL.md'));
     console.log(`  ✓ Slash command /${skill} installed`);
   }
 
+  // Arquitetura de memória (referenciada pelas skills)
+  copyFileSync(join(srcSkills, 'MEMORY_ARCHITECTURE.md'), join(skillsDir, 'MEMORY_ARCHITECTURE.md'));
+  console.log('  ✓ MEMORY_ARCHITECTURE.md installed');
+
   // Trigger padrão: session
   const memoryCfg = loadMemoryConfig();
   if (!memoryCfg.trigger) {
@@ -118,6 +154,24 @@ if (args.includes('--graph')) {
     process.exit(0);
   }
 
+  if (mode !== 'off') {
+    if (!checkSetupDone()) {
+      console.error('\n  ✗ jarvis --setup não foi executado.');
+      console.error('  Execute primeiro: jarvis --setup\n');
+      process.exit(1);
+    }
+    if (!checkMcpRegistered()) {
+      console.error('\n  ✗ MCP server jarvis-memory não está registrado.');
+      console.error('  Execute /setup-memory dentro do Claude Code e reinicie antes de ativar o trigger.\n');
+      process.exit(1);
+    }
+    if (!checkNeo4jRunning()) {
+      console.error('\n  ✗ Neo4j não está rodando.');
+      console.error('  Execute /setup-memory dentro do Claude Code para iniciar o container.\n');
+      process.exit(1);
+    }
+  }
+
   const cfg = loadMemoryConfig();
   cfg.trigger = mode;
   saveMemoryConfig(cfg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrihhh/jarvis",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "Claude Code terminal dashboard + semantic memory graph via Neo4j",
   "bin": {
     "jarvis": "bin/jarvis.js",

package/src/memory/mcp-server.js

@@ -65,7 +65,7 @@ const TOOLS = [
   },
   {
     name: 'save-project',
-    description: 'Salva o entendimento completo de um projeto no grafo. Use após aprovação do usuário no /memory-index.',
+    description: 'Salva o entendimento completo de um projeto no grafo. Use após aprovação do usuário no /create-memory ou /update-memory.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -138,7 +138,7 @@ async function handleListProjects() {
     language: r.get('language'),
   }));
   if (!projects.length) {
-    return 'Nenhum projeto indexado ainda. Use /memory-index para indexar um repositório.';
+    return 'Nenhum projeto indexado ainda. Use /create-memory para indexar um repositório.';
   }
   return `Projetos indexados:\n${projects.map(p =>
     `• ${p.name} [${p.branch}] — ${p.language}${p.description ? ': ' + p.description : ''}`

package/.claude/skills/memory-index/SKILL.md

@@ -1,168 +0,0 @@
----
-name: memory-index
-description: Indexar repositório atual no grafo de memória semantica (Neo4j)
----
-
-# Memory Index — Indexar Repositório no Grafo de Memória
-
-Você vai analisar o repositório atual de forma exaustiva e indexar seu entendimento no Neo4j. **Não grave nada sem aprovação explícita do usuário.**
-
-## REGRA GLOBAL
-- Se travar em qualquer ponto — dúvida técnica, conceitual, arquivo ilegível, ambiguidade de qualquer natureza — **pare e pergunte ao usuário** antes de continuar
-- Não há limite de perguntas. Prefira perguntar a gravar algo errado
-- Só chame a MCP tool `save-project` após o usuário dizer explicitamente "pode salvar" ou equivalente
-
----
-
-## Passo 0 — Seleção de Branch
-
-Pergunte ao usuário: **"Deseja indexar o branch `main` ou `qa`?"**
-
-Após a resposta, execute:
-```bash
-git checkout <branch-escolhido>
-git pull origin <branch-escolhido>
-```
-
-Se algum comando falhar (branch inexistente, conflitos, sem remote), pergunte ao usuário o que fazer antes de continuar.
-
-Confirme com:
-```bash
-git branch --show-current
-```
-
-O output deve mostrar o branch escolhido. Se não, pergunte ao usuário.
-
----
-
-## Passo 1 — Descoberta Inicial
-
-Execute para entender a estrutura geral:
-
-```bash
-# Manifesto principal do projeto
-cat package.json 2>/dev/null || cat composer.json 2>/dev/null || cat pyproject.toml 2>/dev/null || cat go.mod 2>/dev/null || echo "Nenhum manifesto padrão encontrado"
-
-# Estrutura de diretórios (sem node_modules, .git, dist, build)
-find . -maxdepth 3 -type d \
-  ! -path "*/node_modules/*" ! -path "*/.git/*" \
-  ! -path "*/dist/*" ! -path "*/build/*" ! -path "*/.next/*"
-
-# Arquivos de configuração relevantes
-find . -maxdepth 2 -type f \( -name "*.json" -o -name "*.toml" -o -name "*.yaml" -o -name "*.yml" -o -name "*.env.example" \) \
-  ! -path "*/node_modules/*" ! -path "*/.git/*"
-```
-
-Com base no output, identifique:
-- Linguagem principal e framework
-- Diretórios de primeiro e segundo nível como candidatos a módulos
-- Dependências listadas no manifesto
-
-Se qualquer coisa não for óbvia, pergunte ao usuário antes de prosseguir.
-
----
-
-## Passo 2 — Análise Profunda
-
-Para cada diretório candidato a módulo identificado:
-
-**1. Liste os arquivos:**
-```bash
-find <diretório> -type f \
-  ! -path "*/node_modules/*" ! -path "*/.git/*" \
-  ! -name "*.lock" ! -name "package-lock.json"
-```
-
-**2. Leia os arquivos mais relevantes** (entry points, services, controllers, models, routers, handlers):
-- Priorize: `.js`, `.ts`, `.py`, `.php`, `.go`, `.java`, `.rb`
-- Ignore: binários, lock files, arquivos gerados, arquivos minificados
-
-**3. Para cada arquivo lido, determine com certeza:**
-- **Responsabilidade:** o que este arquivo faz?
-- **Imports/Exports:** quais módulos ele usa ou expõe?
-- **Padrões:** Repository, Service Layer, MVC, Factory, Middleware, etc.?
-- **Domínio de negócio:** a qual área pertence (autenticação, pedidos, faturamento, etc.)?
-
-**A qualquer momento que não tiver 100% de certeza → pergunte ao usuário.**
-
-Exemplos de perguntas válidas:
-- "A pasta `src/oms/` é o módulo de gestão de pedidos?"
-- "O arquivo `auth.service.js` usa JWT ou sessões?"
-- "Qual é o domínio de negócio de `src/billing/`?"
-- "Este diretório `src/shared/` contém utilitários compartilhados?"
-- "Esse padrão aqui é Repository ou Service Layer?"
-
----
-
-## Passo 3 — Montagem do Mapa
-
-Ao concluir a análise, consolide mentalmente (sem gravar ainda) o mapa completo:
-
-```
-Projeto: <nome> [<branch>]
-Linguagem: <linguagem>
-Descrição: <descrição curta do que o projeto faz>
-
-Módulos:
-  - <nome> | Domínio: <domínio> | Path: <path>
-    Arquivos: [lista com propósito de cada um]
-    Padrões: [padrões de código identificados]
-    Conceitos: [conceitos de negócio]
-    Depende de: [outros módulos do projeto]
-
-Padrões globais do projeto: [lista]
-Dependências externas relevantes: [nome, versão, tipo]
-```
-
----
-
-## Passo 4 — Apresentação para Aprovação
-
-Apresente o mapa completo ao usuário de forma clara e legível.
-
-Diga ao final: **"Este é meu entendimento completo do projeto. Revise, corrija o que estiver errado, e quando estiver tudo certo me diga 'pode salvar'."**
-
-Aguarde a resposta. Se o usuário corrigir algo:
-- Atualize o mapa
-- Confirme as correções: "Entendido. Corrigi X para Y. Mais alguma correção?"
-- Repita até aprovação explícita
-
----
-
-## Passo 5 — Gravação
-
-Após aprovação explícita do usuário, chame a MCP tool `save-project` com o objeto completo:
-
-```json
-{
-  "project": {
-    "name": "<nome do projeto>",
-    "path": "<path absoluto do repositório>",
-    "description": "<descrição>",
-    "language": "<linguagem principal>",
-    "branch": "<branch escolhido>"
-  },
-  "modules": [
-    {
-      "name": "<nome do módulo>",
-      "path": "<path relativo>",
-      "domain": "<domínio de negócio>",
-      "files": [
-        { "path": "<path do arquivo>", "purpose": "<responsabilidade>" }
-      ],
-      "patterns": ["<padrão identificado>"],
-      "concepts": ["<conceito de negócio>"],
-      "dependsOn": ["<nome de outro módulo do projeto>"]
-    }
-  ],
-  "dependencies": [
-    { "name": "<nome>", "version": "<versão>", "type": "external" }
-  ],
-  "patterns": [
-    { "name": "<nome>", "description": "<descrição do padrão>" }
-  ]
-}
-```
-
-Após a tool retornar sucesso, informe ao usuário:
-**"Projeto `<nome>` [<branch>] indexado com sucesso no grafo de memória."**