@gabrihhh/jarvis 2.0.0 → 2.0.1

package/.claude/commands/memory-index.md

@@ -0,0 +1,163 @@
+# 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."**

package/.claude/commands/setup-memory.md

@@ -0,0 +1,108 @@
+# Setup Memory — Preparar ambiente Neo4j e MCP Server
+
+Você vai configurar o ambiente de memória semântica para o Claude Code. Siga este fluxo exato, passo a passo.
+
+## REGRA GLOBAL
+Se travar em qualquer etapa — erro inesperado, permissão negada, output estranho — **pare e pergunte ao usuário o que deve ser feito** antes de continuar.
+
+---
+
+## Passo 1 — Verificar Docker
+
+Execute:
+```bash
+docker --version
+```
+
+**Se não instalado:**
+- Pergunte: "Docker não encontrado. Posso tentar instalar agora? (requer sudo)"
+- Se aprovado, detecte o OS (`cat /etc/os-release` ou `uname -a`) e instale:
+  - Ubuntu/Debian: `sudo apt-get update && sudo apt-get install -y docker.io`
+  - Fedora/RHEL: `sudo dnf install -y docker`
+  - macOS: instrua a instalar Docker Desktop manualmente e aguarde confirmação do usuário
+  - Se a instalação falhar por qualquer motivo: informe o erro, forneça o link https://docs.docker.com/get-docker/ e aguarde o usuário confirmar que instalou antes de continuar
+
+Execute:
+```bash
+docker info
+```
+
+**Se daemon não rodando:**
+- Pergunte: "Docker está instalado mas não está rodando. Posso iniciar? (requer sudo)"
+- Se aprovado:
+  - Linux: `sudo systemctl start docker`
+  - macOS: instrua a abrir o Docker Desktop
+- Se falhar: pergunte ao usuário o que fazer
+
+---
+
+## Passo 2 — Verificar container Neo4j
+
+Execute:
+```bash
+docker ps -a --filter name=claude-memory --format "{{.Status}}"
+```
+
+- Se retornar linha começando com `Up`: container já está rodando → **pule para o Passo 4**
+- Se retornar linha começando com `Exited`: execute `docker start claude-memory` e aguarde 10s antes de continuar
+- Se não retornar nada: siga para o Passo 3
+
+---
+
+## Passo 3 — Subir Neo4j (primeira vez)
+
+Execute:
+```bash
+docker run -d \
+  --name claude-memory \
+  -p 7474:7474 -p 7687:7687 \
+  -e NEO4J_AUTH=neo4j/claudememory \
+  --restart unless-stopped \
+  neo4j:latest
+```
+
+Aguarde Neo4j estar pronto com polling (até 60 segundos):
+```bash
+for i in $(seq 1 12); do
+  docker exec claude-memory cypher-shell -u neo4j -p claudememory "RETURN 1" 2>/dev/null && echo "Neo4j pronto!" && break
+  echo "Aguardando Neo4j iniciar... ($i/12)"
+  sleep 5
+done
+```
+
+Se não ficar pronto após 60 segundos: pergunte ao usuário o que fazer.
+
+---
+
+## Passo 4 — Registrar MCP Server
+
+Descubra o caminho absoluto do bin `jarvis-memory`:
+```bash
+which jarvis-memory 2>/dev/null || realpath bin/jarvis-memory.js
+```
+
+Leia o arquivo `~/.claude/settings.json`. Se não existir, trate como `{}`.
+
+Adicione ou atualize a chave `mcpServers.claude-memory` preservando todas as outras chaves existentes:
+```json
+{
+  "mcpServers": {
+    "jarvis-memory": {
+      "command": "node",
+      "args": ["<CAMINHO_ABSOLUTO_DO_BIN>"]
+    }
+  }
+}
+```
+
+Salve o arquivo `~/.claude/settings.json`.
+
+---
+
+## Passo 5 — Confirmação Final
+
+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"

package/.claude/settings.local.json

@@ -0,0 +1,25 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(head -50 ~/.claude/telemetry/*.json)",
+      "Bash(grep -l \"usage\\\\|tokens\\\\|cost\\\\|model\" ~/.claude/projects/*/*.jsonl)",
+      "Bash(xargs -I {} sh -c 'echo \"=== {} ===\" && cat {}')",
+      "Bash(chmod +x /tmp/analyze_claude_data.sh)",
+      "Bash(/tmp/analyze_claude_data.sh)",
+      "Read(//tmp/**)",
+      "Bash(chmod +x:*)",
+      "Bash(npm install:*)",
+      "Bash(node:*)",
+      "Bash(claude-usage:*)",
+      "Bash(COLUMNS=60 node -e \"process.stdout.columns=60; import\\('./bin/claude-usage.js'\\)\")",
+      "Bash(npm set:*)",
+      "Bash(git init:*)",
+      "Bash(git add:*)",
+      "Bash(git commit -m ':*)",
+      "Bash(npm publish:*)",
+      "Bash(git commit:*)",
+      "Bash(git push:*)",
+      "Read(//home/patara/.nvm/versions/node/v18.20.8/lib/node_modules/@gabrihhh/jarvis/**)"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrihhh/jarvis",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Claude Code terminal dashboard + semantic memory graph via Neo4j",
   "bin": {
     "jarvis": "bin/jarvis.js",
@@ -12,7 +12,8 @@
   },
   "files": [
     "bin/",
-    "src/"
+    "src/",
+    ".claude/"
   ],
   "keywords": [
     "claude",