@gabrihhh/jarvis 2.0.0

package/README.md

@@ -0,0 +1,71 @@
+# jarvis
+
+Terminal dashboard, status bar e grafo de memória semântica para o **Claude Code** — 100% local.
+
+---
+
+## Instalação
+
+```bash
+npm install -g @gabrihhh/jarvis
+jarvis --setup
+```
+
+Reinicie o Claude Code após o setup.
+
+---
+
+## Comandos
+
+| 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 --graph` | Abre o Neo4j Browser em localhost:7474 |
+| `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 |
+
+---
+
+## Exemplos
+
+**Dashboard completo** (`jarvis --usage`):
+```
+╭──────────────────────────────────────────────────────────────╮
+│  ◈  Claude Code  ·  Usage Dashboard                          │
+│   08 de abr. de 2026, 17:14                                  │
+├──────────────────────────────────────────────────────────────┤
+│                                                              │
+│   ◷  Token Usage                                             │
+│                                                              │
+│   Period    Activity          Tokens    Cost       Requests  │
+│   Monthly   ████████████████  245.33M   $124.99    4810 req  │
+│   Weekly    ██████░░░░░░░░░░  93.19M    $55.50     2050 req  │
+│   Today     ███░░░░░░░░░░░░░  42.78M    $21.60     767 req   │
+│                                                              │
+├──────────────────────────────────────────────────────────────┤
+│                                                              │
+│   ⬡  Context Window  (current session)                       │
+│                                                              │
+│   ████████████░░░░░░░░░░░░  52%  103.6K / 200.0K             │
+│   146 turns  ·  model: sonnet-4-6                            │
+│                                                              │
+├──────────────────────────────────────────────────────────────┤
+│                                                              │
+│   Monthly breakdown                                          │
+│   Input: 62.5K   Output: 1.53M                               │
+│   Cache read: 232.48M   Cache write: 11.25M                  │
+│                                                              │
+╰──────────────────────────────────────────────────────────────╯
+```
+
+**Status bar** (rodapé de cada sessão no Claude Code):
+```
+╭──────────────────────╮
+│ CONTEXT ████░░░░ 52% │
+╰──────────────────────╯
+```

package/bin/jarvis-memory.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { startServer } from '../src/memory/mcp-server.js';
+startServer();

package/bin/jarvis.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { run } from '../src/index.js';
+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 { fileURLToPath } from 'url';
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf-8'));
+  console.log(`\n  jarvis v${pkg.version}\n`);
+  process.exit(0);
+}
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+  jarvis  —  Claude Code terminal dashboard + semantic memory graph
+
+  Usage:
+    jarvis                 Show version
+    jarvis --usage         Show full usage dashboard
+    jarvis --watch         Refresh dashboard every 30s
+    jarvis --setup         Install status bar into ~/.claude/settings.json
+    jarvis --graph         Open Neo4j browser at http://localhost:7474
+    jarvis --line          Single-line status (for Claude Code status bar)
+    jarvis --help          Show this help
+
+  Slash commands (inside Claude Code):
+    /setup-memory          Setup Docker + Neo4j + register MCP server
+    /memory-index          Index a repository into the memory graph
+
+  Data source: ~/.claude/projects/
+`);
+  process.exit(0);
+}
+
+if (args.includes('--graph')) {
+  const url = 'http://localhost:7474';
+  const opener =
+    process.platform === 'darwin' ? 'open' :
+    process.platform === 'win32'  ? 'start' :
+    'xdg-open';
+  console.log(`  Opening Neo4j Browser at ${url} ...\n`);
+  exec(`${opener} ${url}`, (err) => {
+    if (err) console.error(`  Could not open browser automatically. Visit ${url} manually.\n`);
+  });
+} else if (args.includes('--setup')) {
+  const __dir = dirname(fileURLToPath(import.meta.url));
+
+  // Status bar
+  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch { /* keep empty */ }
+  }
+  settings.statusLine = { type: 'command', command: 'jarvis --line' };
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  console.log('  ✓ Status bar configured');
+
+  // Slash commands → ~/.claude/commands/
+  const commandsDir = join(homedir(), '.claude', 'commands');
+  mkdirSync(commandsDir, { recursive: true });
+  const srcCommands = join(__dir, '../.claude/commands');
+  for (const file of ['setup-memory.md', 'memory-index.md']) {
+    copyFileSync(join(srcCommands, file), join(commandsDir, file));
+    console.log(`  ✓ Slash command /${file.replace('.md', '')} installed`);
+  }
+
+  console.log('\n  Restart Claude Code to activate.\n');
+} else if (args.includes('--line') || args.includes('-l')) {
+  renderLine();
+} else if (args.includes('--watch') || args.includes('-w')) {
+  async function loop() {
+    console.clear();
+    await run();
+    console.log('  Auto-refresh in 30s  ·  Ctrl+C to exit\n');
+  }
+  await loop();
+  setInterval(loop, 30_000);
+} else if (args.includes('--usage')) {
+  await run();
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@gabrihhh/jarvis",
+  "version": "2.0.0",
+  "description": "Claude Code terminal dashboard + semantic memory graph via Neo4j",
+  "bin": {
+    "jarvis": "bin/jarvis.js",
+    "jarvis-memory": "bin/jarvis-memory.js"
+  },
+  "main": "./src/index.js",
+  "scripts": {
+    "start": "node bin/jarvis.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "keywords": [
+    "claude",
+    "anthropic",
+    "claude-code",
+    "usage",
+    "stats",
+    "cli",
+    "status-bar",
+    "neo4j",
+    "memory-graph",
+    "mcp"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "chalk": "^5.3.0",
+    "neo4j-driver": "^6.0.1"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/calculator.js

@@ -0,0 +1,116 @@
+// Pricing per million tokens (USD) - April 2026
+const PRICING = {
+  'claude-opus-4-6':    { input: 15.00, output: 75.00, cacheRead: 1.50,  cacheWrite: 18.75 },
+  'claude-sonnet-4-6':  { input:  3.00, output: 15.00, cacheRead: 0.30,  cacheWrite:  3.75 },
+  'claude-haiku-4-5':   { input:  0.25, output:  1.25, cacheRead: 0.025, cacheWrite:  0.30 },
+  'default':            { input:  3.00, output: 15.00, cacheRead: 0.30,  cacheWrite:  3.75 },
+};
+
+// Context window sizes per model
+export const CONTEXT_WINDOWS = {
+  'claude-opus-4-6':   200000,
+  'claude-sonnet-4-6': 200000,
+  'claude-haiku-4-5':  200000,
+  'default':           200000,
+};
+
+function getPrice(model) {
+  for (const [key, price] of Object.entries(PRICING)) {
+    if (model.startsWith(key)) return price;
+  }
+  return PRICING.default;
+}
+
+export function calcCost(entry) {
+  const price = getPrice(entry.model);
+  const M = 1_000_000;
+  return (
+    (entry.inputTokens  / M) * price.input      +
+    (entry.outputTokens / M) * price.output     +
+    (entry.cacheReadTokens  / M) * price.cacheRead  +
+    (entry.cacheWriteTokens / M) * price.cacheWrite
+  );
+}
+
+export function totalTokens(entry) {
+  return entry.inputTokens + entry.outputTokens + entry.cacheReadTokens + entry.cacheWriteTokens;
+}
+
+function withinDays(entry, days) {
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+  return entry.timestamp >= cutoff;
+}
+
+export function aggregateStats(entries) {
+  const now = new Date();
+
+  const monthly = entries.filter(e => withinDays(e, 30));
+  const weekly  = entries.filter(e => withinDays(e, 7));
+  const daily   = entries.filter(e => withinDays(e, 1));
+
+  function sum(arr) {
+    return arr.reduce((acc, e) => ({
+      inputTokens:      acc.inputTokens      + e.inputTokens,
+      outputTokens:     acc.outputTokens     + e.outputTokens,
+      cacheReadTokens:  acc.cacheReadTokens  + e.cacheReadTokens,
+      cacheWriteTokens: acc.cacheWriteTokens + e.cacheWriteTokens,
+      cost:             acc.cost             + calcCost(e),
+      count:            acc.count            + 1,
+    }), { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cost: 0, count: 0 });
+  }
+
+  const monthlyStats = sum(monthly);
+  const weeklyStats  = sum(weekly);
+  const dailyStats   = sum(daily);
+
+  // total tokens for display
+  monthlyStats.total = monthlyStats.inputTokens + monthlyStats.outputTokens + monthlyStats.cacheReadTokens + monthlyStats.cacheWriteTokens;
+  weeklyStats.total  = weeklyStats.inputTokens  + weeklyStats.outputTokens  + weeklyStats.cacheReadTokens  + weeklyStats.cacheWriteTokens;
+  dailyStats.total   = dailyStats.inputTokens   + dailyStats.outputTokens   + dailyStats.cacheReadTokens   + dailyStats.cacheWriteTokens;
+
+  // dominant model
+  const modelCount = {};
+  for (const e of entries.slice(0, 50)) {
+    modelCount[e.model] = (modelCount[e.model] || 0) + 1;
+  }
+  const dominantModel = Object.entries(modelCount).sort((a, b) => b[1] - a[1])[0]?.[0] || 'claude-sonnet-4-6';
+
+  return { monthly: monthlyStats, weekly: weeklyStats, daily: dailyStats, dominantModel };
+}
+
+export function aggregateSession(entries) {
+  if (!entries.length) return null;
+
+  const last = entries[entries.length - 1];
+  const model = last?.model || 'claude-sonnet-4-6';
+  const contextWindow = CONTEXT_WINDOWS[model] || CONTEXT_WINDOWS.default;
+
+  // last assistant turn shows cumulative context usage via cache tokens
+  // We use the most recent entry's tokens as current context position
+  const latestEntry = entries[entries.length - 1];
+  if (!latestEntry) return null;
+
+  // total tokens in last exchange approximates context usage
+  const contextUsed = latestEntry.inputTokens + latestEntry.cacheReadTokens + latestEntry.cacheWriteTokens;
+
+  return {
+    model,
+    contextUsed,
+    contextWindow,
+    percent: Math.min(100, Math.round((contextUsed / contextWindow) * 100)),
+    turns: entries.length,
+  };
+}
+
+export function formatTokens(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(2)}M`;
+  if (n >= 1_000)     return `${(n / 1_000).toFixed(1)}K`;
+  return `${n}`;
+}
+
+export function formatCost(n) {
+  if (n >= 1) return `$${n.toFixed(2)}`;
+  if (n >= 0.01) return `$${n.toFixed(3)}`;
+  return `$${n.toFixed(4)}`;
+}

package/src/display.js

@@ -0,0 +1,150 @@
+import chalk from 'chalk';
+import { formatTokens, formatCost } from './calculator.js';
+
+const W      = 62;
+const PURPLE = '#7c3aed';
+const WHITE  = '#ffffff';
+const DIM    = '#555555';
+
+// ─── Box drawing ────────────────────────────────────────────
+const TOP = chalk.hex(PURPLE)(`╭${'─'.repeat(W)}╮`);
+const BOT = chalk.hex(PURPLE)(`╰${'─'.repeat(W)}╯`);
+const DIV = chalk.hex(PURPLE)(`├${'─'.repeat(W)}┤`);
+
+function stripAnsi(str) {
+  return str.replace(/\u001b\[[0-9;]*m/g, '');
+}
+
+function pad(text, width) {
+  return text + ' '.repeat(Math.max(0, width - stripAnsi(text).length));
+}
+
+const row = (text) => {
+  const len = stripAnsi(text).length;
+  const pipe = chalk.hex(PURPLE)('│');
+  return `${pipe} ${text}${' '.repeat(Math.max(0, W - 1 - len))}${pipe}`;
+};
+
+// ─── Progress bar ────────────────────────────────────────────
+function bar(percent, width = 16) {
+  const filled = Math.round((percent / 100) * width);
+  const empty  = width - filled;
+  const color  = percent >= 85 ? chalk.red : percent >= 60 ? chalk.yellow : chalk.hex('#00e5ff');
+  return color('█'.repeat(filled)) + chalk.hex('#2a2a2a')('░'.repeat(empty));
+}
+
+// ─── Title ───────────────────────────────────────────────────
+function title() {
+  const t = ' ◈  Claude Code  ·  Usage Dashboard';
+  return chalk.bold.hex(WHITE)(t) + ' '.repeat(W - 1 - t.length);
+}
+
+function subtitle() {
+  const now = new Date();
+  const s = now.toLocaleString('pt-BR', {
+    day: '2-digit', month: 'short', year: 'numeric',
+    hour: '2-digit', minute: '2-digit'
+  });
+  const t = `  ${s}`;
+  return chalk.hex(DIM)(t) + ' '.repeat(Math.max(0, W - 1 - t.length));
+}
+
+// ─── Token row ───────────────────────────────────────────────
+function tokenRow(label, stats, maxTokens) {
+  const pct  = maxTokens > 0 ? Math.min(100, Math.round((stats.total / maxTokens) * 100)) : 0;
+  const b    = bar(pct, 16);
+  const tok  = pad(chalk.hex(WHITE)(formatTokens(stats.total)), 8);
+  const cost = pad(chalk.hex('#a78bfa')(formatCost(stats.cost)), 9);
+  const cnt  = chalk.hex(DIM)(pad(`${stats.count} req`, 9));
+  const text = `  ${label}  ${b}  ${tok}  ${cost}  ${cnt}`;
+  return row(text);
+}
+
+// ─── Context window row ──────────────────────────────────────
+function contextRow(session) {
+  if (!session) {
+    return row(`  ${chalk.hex(DIM)('No active session detected')}`);
+  }
+  const { contextUsed, contextWindow, percent, model, turns } = session;
+  const b    = bar(percent, 24);
+  const pct  = chalk.bold.hex(WHITE)(`${percent}%`);
+  const info = chalk.hex(WHITE)(`${formatTokens(contextUsed)} / ${formatTokens(contextWindow)}`);
+  const meta = chalk.hex(DIM)(`${turns} turn${turns !== 1 ? 's' : ''}  ·  model: ${model.replace('claude-', '')}`);
+  return [
+    row(`  ${b}  ${pct}  ${info}`),
+    row(`  ${meta}`),
+  ].join('\n');
+}
+
+// ─── Section header ──────────────────────────────────────────
+function sectionHeader(icon, label) {
+  return row(`  ${chalk.hex(WHITE)(icon)}  ${chalk.bold.hex(WHITE)(label)}`);
+}
+
+// ─── Full render ─────────────────────────────────────────────
+export function render(stats, session) {
+  const { monthly, weekly, daily } = stats;
+  const maxTokens = monthly.total || 1;
+
+  const colHeader =
+    `  ${chalk.hex(WHITE)(pad('Period', 10))}` +
+    `${chalk.hex(WHITE)(pad('Activity', 18))}` +
+    `${chalk.hex(WHITE)(pad('Tokens', 10))}` +
+    `${chalk.hex(WHITE)(pad('Cost', 11))}` +
+    `${chalk.hex(WHITE)('Requests')}`;
+
+  const lines = [
+    TOP,
+    row(title()),
+    row(subtitle()),
+    DIV,
+    row(''),
+    sectionHeader('◷', 'Token Usage'),
+    row(''),
+    row(colHeader),
+    tokenRow(chalk.hex('#c084fc').bold(pad('Monthly', 8)), monthly, maxTokens),
+    tokenRow(chalk.hex('#60a5fa').bold(pad('Weekly ', 8)), weekly,  maxTokens),
+    tokenRow(chalk.hex('#34d399').bold(pad('Today  ', 8)), daily,   maxTokens),
+    row(''),
+    DIV,
+    row(''),
+    sectionHeader('⬡', 'Context Window  (current session)'),
+    row(''),
+    contextRow(session),
+    row(''),
+    DIV,
+    row(''),
+    breakdown(monthly),
+    row(''),
+    BOT,
+  ];
+
+  return lines.join('\n');
+}
+
+function breakdown(monthly) {
+  const items = [
+    { label: 'Input',       val: formatTokens(monthly.inputTokens),      color: '#7dd3fc' },
+    { label: 'Output',      val: formatTokens(monthly.outputTokens),     color: '#86efac' },
+    { label: 'Cache read',  val: formatTokens(monthly.cacheReadTokens),  color: '#fde68a' },
+    { label: 'Cache write', val: formatTokens(monthly.cacheWriteTokens), color: '#f9a8d4' },
+  ];
+
+  const cols = items.map(i =>
+    `${chalk.hex(WHITE)(i.label + ':')} ${chalk.hex(i.color).bold(i.val)}`
+  );
+
+  return [
+    row(`  ${chalk.bold.hex(WHITE)('Monthly breakdown')}`),
+    row(`  ${cols[0]}   ${cols[1]}`),
+    row(`  ${cols[2]}   ${cols[3]}`),
+  ].join('\n');
+}
+
+export function renderError(msg) {
+  console.error(chalk.red(`\n  Error: ${msg}\n`));
+}
+
+export function renderLoading() {
+  process.stdout.write(chalk.hex(DIM)('  Loading usage data...'));
+}

package/src/index.js

@@ -0,0 +1,26 @@
+import { readAllUsage, getCurrentSessionFile, readCurrentSessionUsage } from './reader.js';
+import { aggregateStats, aggregateSession } from './calculator.js';
+import { render, renderError, renderLoading } from './display.js';
+
+export async function run() {
+  renderLoading();
+
+  const allEntries = readAllUsage();
+
+  if (!allEntries.length) {
+    process.stdout.write('\r' + ' '.repeat(40) + '\r');
+    renderError('No Claude Code usage data found. Have you used Claude Code yet?');
+    process.exit(1);
+  }
+
+  const stats = aggregateStats(allEntries);
+
+  // current session
+  const sessionMeta = getCurrentSessionFile();
+  const sessionId   = sessionMeta?.sessionId;
+  const sessionEntries = sessionId ? readCurrentSessionUsage(sessionId) : [];
+  const session = aggregateSession(sessionEntries);
+
+  process.stdout.write('\r' + ' '.repeat(40) + '\r');
+  console.log('\n' + render(stats, session) + '\n');
+}

package/src/memory/mcp-server.js

@@ -0,0 +1,374 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { runQuery, runWriteQuery, closeDriver } from './neo4j-client.js';
+
+// ── Tool definitions ──────────────────────────────────────────────────────────
+
+const TOOLS = [
+  {
+    name: 'list-projects',
+    description: 'Lista todos os projetos e branches indexados no grafo de memória.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'query-project',
+    description: 'Retorna resumo completo de um projeto: módulos, padrões, conceitos e dependências.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Nome do projeto' },
+        branch: { type: 'string', description: 'Branch (main ou qa)', enum: ['main', 'qa'] },
+      },
+      required: ['name', 'branch'],
+    },
+  },
+  {
+    name: 'search-concept',
+    description: 'Busca módulos e arquivos relacionados a um conceito de negócio.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        concept: { type: 'string', description: 'Conceito a buscar (ex: "pedido", "autenticação")' },
+        projectName: { type: 'string', description: 'Nome do projeto (opcional)' },
+      },
+      required: ['concept'],
+    },
+  },
+  {
+    name: 'get-module-detail',
+    description: 'Retorna detalhes completos de um módulo: arquivos, padrões, conceitos, dependências.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        moduleName: { type: 'string', description: 'Nome do módulo' },
+        projectName: { type: 'string', description: 'Nome do projeto' },
+        branch: { type: 'string', description: 'Branch (main ou qa)', enum: ['main', 'qa'] },
+      },
+      required: ['moduleName', 'projectName', 'branch'],
+    },
+  },
+  {
+    name: 'save-project',
+    description: 'Salva o entendimento completo de um projeto no grafo. Use após aprovação do usuário no /memory-index.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            path: { type: 'string' },
+            description: { type: 'string' },
+            language: { type: 'string' },
+            branch: { type: 'string' },
+          },
+          required: ['name', 'path', 'language', 'branch'],
+        },
+        modules: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              path: { type: 'string' },
+              domain: { type: 'string' },
+              files: { type: 'array', items: { type: 'object' } },
+              patterns: { type: 'array', items: { type: 'string' } },
+              concepts: { type: 'array', items: { type: 'string' } },
+              dependsOn: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['name', 'path', 'domain'],
+          },
+        },
+        dependencies: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              version: { type: 'string' },
+              type: { type: 'string', enum: ['external', 'internal'] },
+            },
+          },
+        },
+        patterns: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              description: { type: 'string' },
+            },
+          },
+        },
+      },
+      required: ['project'],
+    },
+  },
+];
+
+// ── Tool handlers ─────────────────────────────────────────────────────────────
+
+async function handleListProjects() {
+  const records = await runQuery(`
+    MATCH (p:Project)
+    RETURN p.name AS name, p.branch AS branch, p.description AS description, p.language AS language
+    ORDER BY p.name, p.branch
+  `);
+  const projects = records.map(r => ({
+    name: r.get('name'),
+    branch: r.get('branch'),
+    description: r.get('description'),
+    language: r.get('language'),
+  }));
+  if (!projects.length) {
+    return 'Nenhum projeto indexado ainda. Use /memory-index para indexar um repositório.';
+  }
+  return `Projetos indexados:\n${projects.map(p =>
+    `• ${p.name} [${p.branch}] — ${p.language}${p.description ? ': ' + p.description : ''}`
+  ).join('\n')}`;
+}
+
+async function handleQueryProject({ name, branch }) {
+  const records = await runQuery(`
+    MATCH (p:Project {name: $name, branch: $branch})
+    OPTIONAL MATCH (p)-[:HAS_MODULE]->(m:Module)
+    OPTIONAL MATCH (m)-[:HANDLES]->(c:Concept)
+    OPTIONAL MATCH (m)-[:IMPLEMENTS]->(pat:Pattern)
+    RETURN p, collect(DISTINCT m) AS modules,
+           collect(DISTINCT c.name) AS concepts,
+           collect(DISTINCT pat.name) AS patterns
+  `, { name, branch });
+
+  if (!records.length) {
+    return `Projeto "${name}" [${branch}] não encontrado. Use list-projects para ver os disponíveis.`;
+  }
+
+  const r = records[0];
+  const p = r.get('p').properties;
+  const modules = r.get('modules').map(m => m.properties);
+  const concepts = [...new Set(r.get('concepts'))].filter(Boolean);
+  const patterns = [...new Set(r.get('patterns'))].filter(Boolean);
+
+  return [
+    `# ${p.name} [${p.branch}]`,
+    p.description ? `**Descrição:** ${p.description}` : '',
+    `**Linguagem:** ${p.language}`,
+    `**Path:** ${p.path}`,
+    '',
+    `## Módulos (${modules.length})`,
+    modules.map(m => `• **${m.name}** — ${m.domain} (${m.path})`).join('\n') || 'Nenhum',
+    '',
+    `## Conceitos de Negócio`,
+    concepts.length ? concepts.map(c => `• ${c}`).join('\n') : 'Nenhum',
+    '',
+    `## Padrões`,
+    patterns.length ? patterns.map(p => `• ${p}`).join('\n') : 'Nenhum',
+  ].filter(l => l !== undefined).join('\n');
+}
+
+async function handleSearchConcept({ concept, projectName }) {
+  let cypher, params;
+
+  if (projectName) {
+    cypher = `
+      MATCH (p:Project {name: $projectName})-[:HAS_MODULE]->(m:Module)-[:HANDLES]->(c:Concept)
+      WHERE toLower(c.name) CONTAINS toLower($concept)
+      OPTIONAL MATCH (m)-[:CONTAINS]->(f:File)
+      RETURN p.name AS project, p.branch AS branch,
+             m.name AS module, m.domain AS domain, m.path AS modulePath,
+             collect(f.path) AS files
+    `;
+    params = { concept, projectName };
+  } else {
+    cypher = `
+      MATCH (m:Module)-[:HANDLES]->(c:Concept)
+      WHERE toLower(c.name) CONTAINS toLower($concept)
+      MATCH (p:Project)-[:HAS_MODULE]->(m)
+      OPTIONAL MATCH (m)-[:CONTAINS]->(f:File)
+      RETURN p.name AS project, p.branch AS branch,
+             m.name AS module, m.domain AS domain, m.path AS modulePath,
+             collect(f.path) AS files
+    `;
+    params = { concept };
+  }
+
+  const records = await runQuery(cypher, params);
+
+  if (!records.length) {
+    return `Nenhum módulo encontrado para o conceito "${concept}".`;
+  }
+
+  return records.map(r =>
+    `[${r.get('project')} / ${r.get('branch')}] **${r.get('module')}** (${r.get('domain')}) — ${r.get('modulePath')}`
+  ).join('\n');
+}
+
+async function handleGetModuleDetail({ moduleName, projectName, branch }) {
+  const records = await runQuery(`
+    MATCH (p:Project {name: $projectName, branch: $branch})-[:HAS_MODULE]->(m:Module {name: $moduleName})
+    OPTIONAL MATCH (m)-[:CONTAINS]->(f:File)
+    OPTIONAL MATCH (m)-[:HANDLES]->(c:Concept)
+    OPTIONAL MATCH (m)-[:IMPLEMENTS]->(pat:Pattern)
+    OPTIONAL MATCH (m)-[:DEPENDS_ON]->(dep:Module)
+    RETURN m,
+           collect(DISTINCT f) AS files,
+           collect(DISTINCT c.name) AS concepts,
+           collect(DISTINCT pat.name) AS patterns,
+           collect(DISTINCT dep.name) AS deps
+  `, { moduleName, projectName, branch });
+
+  if (!records.length) {
+    return `Módulo "${moduleName}" não encontrado em ${projectName} [${branch}].`;
+  }
+
+  const r = records[0];
+  const m = r.get('m').properties;
+  const files = r.get('files').map(f => f.properties);
+  const concepts = r.get('concepts').filter(Boolean);
+  const patterns = r.get('patterns').filter(Boolean);
+  const deps = r.get('deps').filter(Boolean);
+
+  return [
+    `# Módulo: ${m.name}`,
+    `**Domínio:** ${m.domain}`,
+    `**Path:** ${m.path}`,
+    '',
+    `## Arquivos (${files.length})`,
+    files.map(f => `• ${f.path}${f.purpose ? ' — ' + f.purpose : ''}`).join('\n') || 'Nenhum',
+    '',
+    `## Conceitos`,
+    concepts.length ? concepts.map(c => `• ${c}`).join('\n') : 'Nenhum',
+    '',
+    `## Padrões`,
+    patterns.length ? patterns.map(p => `• ${p}`).join('\n') : 'Nenhum',
+    '',
+    `## Depende de`,
+    deps.length ? deps.map(d => `• ${d}`).join('\n') : 'Nenhum',
+  ].join('\n');
+}
+
+async function handleSaveProject({ project, modules = [], dependencies = [], patterns = [] }) {
+  const createdAt = new Date().toISOString();
+
+  // Upsert Project
+  await runWriteQuery(`
+    MERGE (p:Project {name: $name, branch: $branch})
+    SET p.path = $path, p.description = $description,
+        p.language = $language, p.createdAt = $createdAt
+  `, { ...project, description: project.description || '', createdAt });
+
+  // Upsert global Patterns e relação com Project
+  for (const pat of patterns) {
+    await runWriteQuery(`
+      MERGE (pat:Pattern {name: $name})
+      SET pat.description = $description
+      WITH pat
+      MATCH (p:Project {name: $projectName, branch: $branch})
+      MERGE (p)-[:USES_PATTERN]->(pat)
+    `, { name: pat.name, description: pat.description || '', projectName: project.name, branch: project.branch });
+  }
+
+  // Upsert Dependencies
+  for (const dep of dependencies) {
+    await runWriteQuery(`
+      MERGE (d:Dependency {name: $name, projectName: $projectName, branch: $branch})
+      SET d.version = $version, d.type = $type
+    `, { name: dep.name, version: dep.version || '', type: dep.type || 'external', projectName: project.name, branch: project.branch });
+  }
+
+  // Upsert Modules, Files, Concepts, Patterns
+  for (const mod of modules) {
+    await runWriteQuery(`
+      MATCH (p:Project {name: $projectName, branch: $branch})
+      MERGE (m:Module {path: $path, projectName: $projectName, branch: $branch})
+      SET m.name = $name, m.domain = $domain
+      MERGE (p)-[:HAS_MODULE]->(m)
+    `, { projectName: project.name, branch: project.branch, name: mod.name, path: mod.path, domain: mod.domain });
+
+    for (const file of (mod.files || [])) {
+      await runWriteQuery(`
+        MATCH (m:Module {path: $modulePath, projectName: $projectName, branch: $branch})
+        MERGE (f:File {path: $filePath, projectName: $projectName, branch: $branch})
+        SET f.name = $fileName, f.extension = $ext, f.purpose = $purpose
+        MERGE (m)-[:CONTAINS]->(f)
+      `, {
+        modulePath: mod.path,
+        projectName: project.name,
+        branch: project.branch,
+        filePath: file.path,
+        fileName: file.name || file.path.split('/').pop(),
+        ext: file.extension || file.path.split('.').pop(),
+        purpose: file.purpose || '',
+      });
+    }
+
+    for (const conceptName of (mod.concepts || [])) {
+      await runWriteQuery(`
+        MATCH (m:Module {path: $modulePath, projectName: $projectName, branch: $branch})
+        MERGE (c:Concept {name: $name, projectName: $projectName})
+        MERGE (m)-[:HANDLES]->(c)
+      `, { modulePath: mod.path, projectName: project.name, branch: project.branch, name: conceptName });
+    }
+
+    for (const patternName of (mod.patterns || [])) {
+      await runWriteQuery(`
+        MATCH (m:Module {path: $modulePath, projectName: $projectName, branch: $branch})
+        MERGE (pat:Pattern {name: $name})
+        MERGE (m)-[:IMPLEMENTS]->(pat)
+      `, { modulePath: mod.path, projectName: project.name, branch: project.branch, name: patternName });
+    }
+  }
+
+  // Relações dependsOn (após todos os módulos existirem no grafo)
+  for (const mod of modules) {
+    for (const depName of (mod.dependsOn || [])) {
+      await runWriteQuery(`
+        MATCH (a:Module {name: $fromName, projectName: $projectName, branch: $branch})
+        MATCH (b:Module {name: $toName, projectName: $projectName, branch: $branch})
+        MERGE (a)-[:DEPENDS_ON]->(b)
+      `, { fromName: mod.name, toName: depName, projectName: project.name, branch: project.branch });
+    }
+  }
+
+  return `Projeto "${project.name}" [${project.branch}] indexado com sucesso. ${modules.length} módulos gravados.`;
+}
+
+// ── Server bootstrap ──────────────────────────────────────────────────────────
+
+export async function startServer() {
+  const server = new Server(
+    { name: 'claude-memory', version: '1.0.0' },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      let text;
+      switch (name) {
+        case 'list-projects':     text = await handleListProjects(); break;
+        case 'query-project':     text = await handleQueryProject(args); break;
+        case 'search-concept':    text = await handleSearchConcept(args); break;
+        case 'get-module-detail': text = await handleGetModuleDetail(args); break;
+        case 'save-project':      text = await handleSaveProject(args); break;
+        default: throw new Error(`Tool desconhecida: ${name}`);
+      }
+      return { content: [{ type: 'text', text }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Erro: ${err.message}` }], isError: true };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  process.on('SIGINT', async () => { await closeDriver(); process.exit(0); });
+  process.on('SIGTERM', async () => { await closeDriver(); process.exit(0); });
+}

package/src/memory/neo4j-client.js

@@ -0,0 +1,71 @@
+import neo4j from 'neo4j-driver';
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CONFIG_PATH = join(homedir(), '.claude-memory.json');
+
+const DEFAULT_CONFIG = {
+  neo4j: {
+    uri: 'bolt://localhost:7687',
+    user: 'neo4j',
+    password: 'claudememory',
+  },
+};
+
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return DEFAULT_CONFIG;
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+let _driver = null;
+
+export function getDriver() {
+  if (_driver) return _driver;
+  const config = loadConfig();
+  const { uri, user, password } = config.neo4j;
+  _driver = neo4j.driver(uri, neo4j.auth.basic(user, password));
+  return _driver;
+}
+
+export async function closeDriver() {
+  if (_driver) {
+    await _driver.close();
+    _driver = null;
+  }
+}
+
+export async function runQuery(cypher, params = {}) {
+  const driver = getDriver();
+  const session = driver.session();
+  try {
+    const result = await session.run(cypher, params);
+    return result.records;
+  } finally {
+    await session.close();
+  }
+}
+
+export async function runWriteQuery(cypher, params = {}) {
+  const driver = getDriver();
+  const session = driver.session({ defaultAccessMode: neo4j.session.WRITE });
+  try {
+    const result = await session.run(cypher, params);
+    return result.records;
+  } finally {
+    await session.close();
+  }
+}
+
+export async function testConnection() {
+  try {
+    await runQuery('RETURN 1 AS ok');
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/memory/schema.js

@@ -0,0 +1,26 @@
+import { runWriteQuery } from './neo4j-client.js';
+
+const CONSTRAINTS = [
+  'CREATE CONSTRAINT project_unique IF NOT EXISTS FOR (p:Project) REQUIRE (p.name, p.branch) IS UNIQUE',
+  'CREATE CONSTRAINT module_unique IF NOT EXISTS FOR (m:Module) REQUIRE (m.path, m.projectName, m.branch) IS UNIQUE',
+  'CREATE CONSTRAINT file_unique IF NOT EXISTS FOR (f:File) REQUIRE (f.path, f.projectName, f.branch) IS UNIQUE',
+  'CREATE CONSTRAINT pattern_unique IF NOT EXISTS FOR (pat:Pattern) REQUIRE pat.name IS UNIQUE',
+  'CREATE CONSTRAINT concept_unique IF NOT EXISTS FOR (c:Concept) REQUIRE (c.name, c.projectName) IS UNIQUE',
+];
+
+export async function applySchema() {
+  for (const cypher of CONSTRAINTS) {
+    try {
+      await runWriteQuery(cypher);
+    } catch (err) {
+      if (!err.message?.includes('already exists')) throw err;
+    }
+  }
+}
+
+// Estrutura canônica esperada pelo save-project
+// project: { name, path, description, language, branch, createdAt }
+// modules: [{ name, path, domain, files: [{ path, purpose }], patterns: [string], concepts: [string], dependsOn: [string] }]
+// dependencies: [{ name, version, type }]
+// patterns: [{ name, description }]
+export const PROJECT_SHAPE = {};

package/src/reader.js

@@ -0,0 +1,163 @@
+import { readFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+const PROJECTS_DIR = join(CLAUDE_DIR, 'projects');
+
+function parseJsonlFile(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    return content
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => {
+        try { return JSON.parse(line); }
+        catch { return null; }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function getAllSessionFiles() {
+  if (!existsSync(PROJECTS_DIR)) return [];
+
+  const files = [];
+
+  try {
+    const projects = readdirSync(PROJECTS_DIR);
+    for (const project of projects) {
+      const projectPath = join(PROJECTS_DIR, project);
+      if (!statSync(projectPath).isDirectory()) continue;
+
+      const entries = readdirSync(projectPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+          files.push(join(projectPath, entry.name));
+        } else if (entry.isDirectory()) {
+          // subagent dirs
+          try {
+            const subEntries = readdirSync(join(projectPath, entry.name), { withFileTypes: true });
+            for (const sub of subEntries) {
+              if (sub.isFile() && sub.name.endsWith('.jsonl')) {
+                files.push(join(projectPath, entry.name, sub.name));
+              }
+            }
+          } catch { /* skip */ }
+        }
+      }
+    }
+  } catch { /* skip */ }
+
+  return files;
+}
+
+function extractUsageFromEntry(entry) {
+  if (!entry || entry.type !== 'assistant') return null;
+
+  const usage = entry.message?.usage;
+  if (!usage) return null;
+
+  return {
+    timestamp: entry.timestamp ? new Date(entry.timestamp) : null,
+    model: entry.message?.model || 'unknown',
+    inputTokens: usage.input_tokens || 0,
+    outputTokens: usage.output_tokens || 0,
+    cacheReadTokens: usage.cache_read_input_tokens || 0,
+    cacheWriteTokens: usage.cache_creation_input_tokens || 0,
+    sessionId: entry.sessionId || null,
+    cwd: entry.cwd || null,
+  };
+}
+
+export function readAllUsage() {
+  const files = getAllSessionFiles();
+  const entries = [];
+
+  for (const file of files) {
+    const lines = parseJsonlFile(file);
+    for (const line of lines) {
+      const usage = extractUsageFromEntry(line);
+      if (usage && usage.timestamp) {
+        entries.push(usage);
+      }
+    }
+  }
+
+  return entries.sort((a, b) => b.timestamp - a.timestamp);
+}
+
+export function getCurrentSessionFile() {
+  const sessionsDir = join(CLAUDE_DIR, 'sessions');
+  if (!existsSync(sessionsDir)) return null;
+
+  try {
+    // Try to match by parent PID chain: Claude spawns the status line command,
+    // so process.ppid (or its parent) should match a session file named <pid>.json
+    const pidsToCheck = new Set([process.ppid]);
+
+    // also check grandparent in case the command runs through a shell
+    try {
+      const grandparent = parseInt(
+        execSync(`ps -o ppid= -p ${process.ppid}`, { stdio: ['pipe','pipe','pipe'] }).toString().trim()
+      );
+      if (grandparent) pidsToCheck.add(grandparent);
+    } catch { /* skip */ }
+
+    for (const pid of pidsToCheck) {
+      const candidate = join(sessionsDir, `${pid}.json`);
+      if (existsSync(candidate)) {
+        try { return JSON.parse(readFileSync(candidate, 'utf-8')); }
+        catch { /* skip */ }
+      }
+    }
+
+    // Fallback: find a session whose sessionId appears in JSONL files
+    const sessionFiles = readdirSync(sessionsDir)
+      .map(f => {
+        try { return JSON.parse(readFileSync(join(sessionsDir, f), 'utf-8')); }
+        catch { return null; }
+      })
+      .filter(Boolean);
+
+    if (!sessionFiles.length) return null;
+
+    const allFiles = getAllSessionFiles();
+    const sessionIdSet = new Set();
+    for (const file of allFiles) {
+      try {
+        const lines = readFileSync(file, 'utf-8').split('\n').filter(l => l.trim());
+        for (const line of lines.slice(-5)) {
+          try { const obj = JSON.parse(line); if (obj.sessionId) sessionIdSet.add(obj.sessionId); }
+          catch { /* skip */ }
+        }
+      } catch { /* skip */ }
+    }
+
+    return sessionFiles.find(s => sessionIdSet.has(s.sessionId)) || sessionFiles[0];
+  } catch {
+    return null;
+  }
+}
+
+export function readCurrentSessionUsage(sessionId) {
+  if (!sessionId) return [];
+
+  const files = getAllSessionFiles();
+  const entries = [];
+
+  for (const file of files) {
+    const lines = parseJsonlFile(file);
+    for (const line of lines) {
+      if (line.sessionId === sessionId) {
+        const usage = extractUsageFromEntry(line);
+        if (usage) entries.push(usage);
+      }
+    }
+  }
+
+  return entries;
+}

package/src/statusline.js

@@ -0,0 +1,57 @@
+import { Chalk } from 'chalk';
+import { readAllUsage, getCurrentSessionFile, readCurrentSessionUsage } from './reader.js';
+import { aggregateStats, aggregateSession, formatCost } from './calculator.js';
+
+const chalk = new Chalk({ level: 3 });
+
+const PINK   = '#f472b6';
+const BLUE   = '#60a5fa';
+const CYAN   = '#22d3ee';
+const DIM    = '#444444';
+
+function bar(percent, width = 8) {
+  const filled = Math.round((percent / 100) * width);
+  const empty  = width - filled;
+  return '█'.repeat(filled) + '░'.repeat(empty);
+}
+
+export function renderLine() {
+  const allEntries = readAllUsage();
+  if (!allEntries.length) {
+    process.stdout.write('claude: no data');
+    return;
+  }
+
+  const stats = aggregateStats(allEntries);
+  const sessionMeta = getCurrentSessionFile();
+  const sessionId = sessionMeta?.sessionId;
+  const sessionEntries = sessionId ? readCurrentSessionUsage(sessionId) : [];
+  const session = aggregateSession(sessionEntries);
+
+  const { monthly, weekly, daily } = stats;
+
+  const weeklyPct = monthly.total > 0 ? Math.round((weekly.total / monthly.total) * 100) : 0;
+  const todayPct  = monthly.total > 0 ? Math.round((daily.total  / monthly.total) * 100) : 0;
+
+  if (!session) {
+    const inner = ` CONTEXT ${'░'.repeat(8)} 0% `;
+    const top    = `╭${'─'.repeat(inner.length)}╮`;
+    const bottom = `╰${'─'.repeat(inner.length)}╯`;
+    process.stdout.write(
+      chalk.hex(CYAN).bold(top)         + '\n' +
+      chalk.hex(CYAN).bold(`│${inner}│`) + '\n' +
+      chalk.hex(CYAN).bold(bottom)
+    );
+    return;
+  }
+
+  const inner = ` CONTEXT ${bar(session.percent)} ${session.percent}% `;
+  const top    = `╭${'─'.repeat(inner.length)}╮`;
+  const bottom = `╰${'─'.repeat(inner.length)}╯`;
+
+  process.stdout.write(
+    chalk.hex(CYAN).bold(top)    + '\n' +
+    chalk.hex(CYAN).bold(`│${inner}│`) + '\n' +
+    chalk.hex(CYAN).bold(bottom)
+  );
+}