@eximia-ventures/claude-code-toolkit 3.0.0

package/assets/skill/aios-integrate.md

@@ -0,0 +1,169 @@
+# /aios-integrate — Gerenciador de Artefatos AIOS
+
+Você é um assistente especializado em integrar, listar e exportar artefatos AIOS (agents e squads).
+
+## Instruções
+
+Quando o usuário executar `/aios-integrate`, siga este fluxo:
+
+### 1. Pergunte a ação desejada
+
+Apresente as opções:
+1. **Integrar artefato externo** — Importar um agent ou squad de um caminho/URL
+2. **Listar artefatos instalados** — Mostrar agents e squads registrados
+3. **Exportar artefatos** — Empacotar artefatos para compartilhamento
+
+---
+
+### 2. Integrar Artefato Externo
+
+Quando o usuário escolher integrar:
+
+1. Peça o **caminho ou URL** do artefato (arquivo `.md`/`.yaml` para agent, ou pasta para squad)
+2. Leia e analise o artefato para detectar o tipo:
+   - Se contém `agent:` com campos `name`, `id`, `persona` → é um **Agent**
+   - Se contém `name`, `version`, `components`, `slashPrefix` → é um **Squad**
+
+#### Para Agent:
+
+Crie automaticamente todos os arquivos de integração:
+
+```
+.codex/agents/{id}.md          — Cópia do agent para IDE discovery
+.antigravity/agents/{id}.md    — Workflow activation file
+.agent/workflows/{id}.md       — Workflow file
+```
+
+Registre no manifest `.aios-core/manifests/agents.csv` adicionando uma linha:
+```csv
+{id},{name},{title},{icon},{status}
+```
+
+Para cada `command` definido no agent (na seção `commands`), crie um slash command em `.claude/commands/`:
+- Nome do arquivo: `{agent-id}-{command-name}.md`
+- Conteúdo: Instruções para ativar o agent e executar o comando específico
+
+Exemplo de slash command gerado:
+```markdown
+# /{agent-id}-{command-name}
+
+Ative o agent @{agent-name} e execute o comando `*{command-name}`.
+
+## Contexto
+- Agent: {agent-name} ({agent-title})
+- Comando: *{command-name}
+- Descrição: {command-description}
+
+## Instruções
+1. Leia o agent definition em `.codex/agents/{id}.md`
+2. Assuma a persona do agent
+3. Execute o comando `*{command-name}` conforme definido no agent
+```
+
+#### Para Squad:
+
+1. Copie a pasta completa do squad para `./squads/{squad-name}/`
+2. Leia o `squad.yaml` para identificar os agents do squad
+3. Para cada agent listado em `components.agents`:
+   - Registre no `.aios-core/manifests/agents.csv`
+   - Crie os arquivos de integração (mesmos do fluxo agent acima)
+4. Para cada task listada em `components.tasks`, crie slash commands baseados no `slashPrefix`:
+   - Nome: `{slashPrefix}-{task-name}.md`
+   - Conteúdo: Instruções para executar a task do squad
+
+Ao finalizar, mostre um relatório:
+```
+✓ Artefato integrado: {name}
+  Tipo: Agent/Squad
+  Arquivos criados:
+    - .codex/agents/{id}.md
+    - .antigravity/agents/{id}.md
+    - .agent/workflows/{id}.md
+    - .claude/commands/{command}.md (x N)
+  Manifest atualizado: agents.csv
+```
+
+---
+
+### 3. Listar Artefatos Instalados
+
+1. Leia `.aios-core/manifests/agents.csv` e liste todos os agents registrados
+2. Verifique a pasta `./squads/` e liste todos os squads instalados
+3. Para cada artefato, mostre:
+   - Nome e ID
+   - Tipo (Agent standalone / Agent de Squad / Squad)
+   - Status (ativo/desativado)
+   - Comandos disponíveis
+   - Versão (se disponível)
+
+Formato de saída:
+```
+📋 Artefatos AIOS Instalados
+
+  Agents:
+    🤖 dev (Dex) — Development Agent — ativo
+       Comandos: *develop, *implement, *fix
+    🤖 qa (Quinn) — QA Agent — ativo
+       Comandos: *qa-gate, *review
+
+  Squads:
+    🎯 etl-squad v1.2.0 — ETL Pipeline Squad
+       Agents: extractor, transformer, loader
+       Prefix: /etl-*
+
+  Total: N agents, M squads
+```
+
+---
+
+### 4. Exportar Artefatos
+
+1. Liste todos os artefatos disponíveis e pergunte qual exportar
+2. Para o artefato selecionado:
+
+#### Agent:
+- Colete todos os arquivos relacionados:
+  - Agent definition (`.codex/agents/{id}.md`)
+  - Tasks referenciadas
+  - Templates referenciados
+  - Checklists referenciados
+- Use `tar` para criar um bundle: `{agent-id}-export.tar.gz`
+
+#### Squad:
+- Empacote a pasta completa do squad: `./squads/{squad-name}/`
+- Use `tar` para criar: `{squad-name}-export.tar.gz`
+
+Salve o export na pasta atual e informe o caminho:
+```
+✓ Exportado: ./{artifact-name}-export.tar.gz
+  Conteúdo: N arquivos, M KB
+  Para importar em outro projeto: /aios-integrate → Integrar → caminho do arquivo
+```
+
+---
+
+## Validações
+
+Antes de integrar qualquer artefato, valide:
+
+1. **Estrutura do agent** deve conter pelo menos: `agent.name`, `agent.id`, `persona.role`
+2. **Estrutura do squad** deve conter pelo menos: `name`, `version`, `components`
+3. **IDs não duplicados** — Verifique se o ID já existe no manifest antes de registrar
+4. **Dependências** — Se o agent/squad referencia tasks ou templates, verifique se existem
+
+Se a validação falhar, mostre o erro e pergunte se o usuário quer continuar mesmo assim.
+
+---
+
+## Paths de Referência
+
+| Artefato | Path |
+|----------|------|
+| Agent definitions | `.codex/agents/` |
+| Agent workflows | `.agent/workflows/` |
+| Agent activation | `.antigravity/agents/` |
+| Agent manifest | `.aios-core/manifests/agents.csv` |
+| Squad folders | `./squads/` |
+| Slash commands | `.claude/commands/` |
+| Agent schema | `.aios-core/schemas/agent-v3-schema.json` |
+| Squad schema | `.aios-core/schemas/squad-schema.json` |

package/assets/statusline/statusline.sh

@@ -0,0 +1,220 @@
+#!/usr/bin/env bash
+#
+# claude-code-toolkit — Statusline Script v1.0
+#
+# Receives JSON via stdin from Claude Code's statusLine configuration.
+# Outputs a formatted status bar with model, context, cost, time, git info.
+#
+# Required: jq (https://jqlang.github.io/jq/)
+#
+# Environment variables (optional):
+#   CLAUDE_TOOLKIT_CURRENCY      — Currency symbol (default: $)
+#   CLAUDE_TOOLKIT_CURRENCY_RATE — USD conversion rate (default: 1)
+#
+
+set -euo pipefail
+
+# --- Read JSON from stdin ---
+INPUT=$(cat)
+
+# --- Check jq availability ---
+if ! command -v jq &>/dev/null; then
+  echo "jq not found"
+  exit 0
+fi
+
+# --- ANSI Colors ---
+RESET='\033[0m'
+BOLD='\033[1m'
+DIM='\033[2m'
+RED='\033[31m'
+GREEN='\033[32m'
+YELLOW='\033[33m'
+BLUE='\033[34m'
+MAGENTA='\033[35m'
+CYAN='\033[36m'
+WHITE='\033[37m'
+BOLD_BLUE="${BOLD}${BLUE}"
+BOLD_RED="${BOLD}${RED}"
+
+# --- Currency config ---
+CURRENCY="${CLAUDE_TOOLKIT_CURRENCY:-\$}"
+RATE="${CLAUDE_TOOLKIT_CURRENCY_RATE:-1}"
+
+# --- Parse JSON fields ---
+model_id=$(echo "$INPUT" | jq -r '.model.id // ""')
+used_pct=$(echo "$INPUT" | jq -r '.context_window.used_percentage // 0')
+total_input=$(echo "$INPUT" | jq -r '.context_window.total_input_tokens // 0')
+total_output=$(echo "$INPUT" | jq -r '.context_window.total_output_tokens // 0')
+total_cost=$(echo "$INPUT" | jq -r '.cost.total_cost_usd // 0')
+total_duration=$(echo "$INPUT" | jq -r '.cost.total_duration_ms // 0')
+session_id=$(echo "$INPUT" | jq -r '.session_id // ""')
+
+# --- Helper: format model name ---
+format_model() {
+  local id="$1"
+  case "$id" in
+    *opus*)   echo "Opus 4.6" ;;
+    *sonnet*) echo "Sonnet 4.5" ;;
+    *haiku*)  echo "Haiku 4.5" ;;
+    *)        echo "$id" ;;
+  esac
+}
+
+# --- Helper: format tokens ---
+fmt_tokens() {
+  local n="$1"
+  if (( n >= 1000000 )); then
+    printf "%.1fM" "$(echo "scale=1; $n / 1000000" | bc)"
+  elif (( n >= 1000 )); then
+    echo "$((n / 1000))K"
+  else
+    echo "$n"
+  fi
+}
+
+# --- Helper: progress bar ---
+progress_bar() {
+  local pct="$1"
+  local width=10
+  local filled=$(( (pct * width + 50) / 100 ))
+  local empty=$(( width - filled ))
+
+  local color
+  if (( pct > 80 )); then color="$RED"
+  elif (( pct > 60 )); then color="$YELLOW"
+  else color="$GREEN"
+  fi
+
+  local bar=""
+  for ((i=0; i<filled; i++)); do bar+="█"; done
+  for ((i=0; i<empty; i++)); do bar+="░"; done
+
+  printf "${color}%s${RESET}" "$bar"
+}
+
+# --- Helper: format duration ---
+fmt_duration() {
+  local ms="$1"
+  local total_sec=$(( ms / 1000 ))
+  local min=$(( total_sec / 60 ))
+  local sec=$(( total_sec % 60 ))
+  if (( min > 0 )); then
+    printf "%dm%02ds" "$min" "$sec"
+  else
+    printf "%ds" "$sec"
+  fi
+}
+
+# --- Helper: format cost with currency conversion ---
+fmt_cost() {
+  local usd="$1"
+  local converted
+  converted=$(LC_NUMERIC=C awk "BEGIN { printf \"%.2f\", $usd * $RATE }")
+  printf "%s%s" "$CURRENCY" "$converted"
+}
+
+# --- Helper: get git branch (cached 5s) ---
+GIT_CACHE_DIR="${HOME}/.claude/session-cache"
+GIT_CACHE_FILE="${GIT_CACHE_DIR}/git-branch-cache"
+
+get_git_branch() {
+  mkdir -p "$GIT_CACHE_DIR" 2>/dev/null || true
+
+  if [[ -f "$GIT_CACHE_FILE" ]]; then
+    local cache_age
+    if [[ "$(uname)" == "Darwin" ]]; then
+      cache_age=$(( $(date +%s) - $(stat -f %m "$GIT_CACHE_FILE") ))
+    else
+      cache_age=$(( $(date +%s) - $(stat -c %Y "$GIT_CACHE_FILE") ))
+    fi
+    if (( cache_age < 5 )); then
+      cat "$GIT_CACHE_FILE"
+      return
+    fi
+  fi
+
+  local branch
+  branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
+  if [[ -n "$branch" ]]; then
+    echo "$branch" > "$GIT_CACHE_FILE"
+    echo "$branch"
+  fi
+}
+
+# --- Helper: count user messages from transcript ---
+count_messages() {
+  local transcript_path
+  transcript_path=$(echo "$INPUT" | jq -r '.transcript_path // ""')
+  if [[ -z "$transcript_path" || ! -f "$transcript_path" ]]; then
+    echo "0"
+    return
+  fi
+  grep -c '"type"\s*:\s*"human"\|"type"\s*:\s*"user"' "$transcript_path" 2>/dev/null || echo "0"
+}
+
+# --- Build segments ---
+PARTS=()
+
+# 1. Model with color indicator
+model_name=$(format_model "$model_id")
+if [[ -n "$model_name" ]]; then
+  model_color="$GREEN"
+  case "$model_name" in
+    "Opus 4.6")   model_color="$MAGENTA" ;;
+    "Sonnet 4.5") model_color="$BLUE" ;;
+    "Haiku 4.5")  model_color="$CYAN" ;;
+  esac
+  PARTS+=("$(printf "${model_color}●${RESET} ${BOLD_BLUE}%s${RESET}" "$model_name")")
+fi
+
+# 2. Date
+current_date=$(date +%d/%m/%Y)
+PARTS+=("$(printf "📅 %s" "$current_date")")
+
+# 3. Context (total tokens in human format)
+total_tokens=$(( total_input + total_output ))
+if (( total_tokens > 0 )); then
+  PARTS+=("$(printf "📊 %s" "$(fmt_tokens "$total_tokens")")")
+fi
+
+# 4. Message count
+msg_count=$(count_messages)
+PARTS+=("$(printf "⚡ %s" "$msg_count")")
+
+# 5. Progress bar + percentage
+pct_int=${used_pct%.*}
+pct_int=${pct_int:-0}
+bar=$(progress_bar "$pct_int")
+if (( pct_int > 80 )); then pct_color="$RED"
+elif (( pct_int > 60 )); then pct_color="$YELLOW"
+else pct_color="$GREEN"
+fi
+PARTS+=("$(printf "%s ${pct_color}%s%%${RESET}" "$bar" "$pct_int")")
+
+# 6. Cost
+if [[ "$total_cost" != "0" ]]; then
+  PARTS+=("$(printf "💰 %s" "$(fmt_cost "$total_cost")")")
+fi
+
+# 7. Duration
+if (( total_duration > 0 )); then
+  PARTS+=("$(printf "⏱ %s" "$(fmt_duration "$total_duration")")")
+fi
+
+# 8. Git branch
+git_branch=$(get_git_branch)
+if [[ -n "$git_branch" ]]; then
+  PARTS+=("$(printf "🔀 ${MAGENTA}%s${RESET}" "$git_branch")")
+fi
+
+# --- Join parts with separator ---
+output=""
+for i in "${!PARTS[@]}"; do
+  if (( i > 0 )); then
+    output+=" | "
+  fi
+  output+="${PARTS[$i]}"
+done
+
+echo -e "$output"

package/bin/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+'use strict';
+
+require('../src/index.js');

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@eximia-ventures/claude-code-toolkit",
+  "version": "3.0.0",
+  "description": "Setup completo para Claude Code: statusline, session handoff, AIOS integration",
+  "main": "src/index.js",
+  "bin": {
+    "claude-code-toolkit": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "assets/"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "toolkit",
+    "aios",
+    "developer-tools"
+  ],
+  "author": "Hugo Capitelli",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "claude-code-handoff": "^2.1.0",
+    "commander": "^12.1.0",
+    "fs-extra": "^11.3.0",
+    "inquirer": "^8.2.6"
+  }
+}

package/src/commands/doctor.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const logger = require('../utils/logger');
+const { MANIFEST_PATH } = require('../installer');
+const { SETTINGS_PATH, readSettings } = require('../utils/settings-merger');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const STATUSLINE_PATH = path.join(CLAUDE_DIR, 'statusline.sh');
+
+async function runDoctor() {
+  logger.section('Diagnóstico');
+
+  let issues = 0;
+  let ok = 0;
+
+  // 1. Check manifest
+  if (await fs.pathExists(MANIFEST_PATH)) {
+    const manifest = await fs.readJson(MANIFEST_PATH);
+    check(`Manifest encontrado (v${manifest.version})`, true);
+    ok++;
+  } else {
+    check('Manifest não encontrado — toolkit não instalado?', false);
+    issues++;
+  }
+
+  // 2. Check ~/.claude/ directory
+  if (await fs.pathExists(CLAUDE_DIR)) {
+    check('Diretório ~/.claude/ existe', true);
+    ok++;
+  } else {
+    check('Diretório ~/.claude/ não encontrado', false);
+    issues++;
+  }
+
+  // 3. Check settings.json
+  if (await fs.pathExists(SETTINGS_PATH)) {
+    const settings = await readSettings();
+    if (settings.statusLine) {
+      check('settings.json contém statusLine', true);
+      ok++;
+    } else {
+      check('settings.json não contém statusLine', false);
+      issues++;
+    }
+  } else {
+    check('settings.json não encontrado', false);
+    issues++;
+  }
+
+  // 4. Check statusline.sh
+  if (await fs.pathExists(STATUSLINE_PATH)) {
+    const stats = await fs.stat(STATUSLINE_PATH);
+    const isExecutable = (stats.mode & 0o111) !== 0;
+    if (isExecutable) {
+      check('statusline.sh existe e é executável', true);
+      ok++;
+    } else {
+      check('statusline.sh existe mas NÃO é executável', false);
+      issues++;
+    }
+  } else {
+    check('statusline.sh não encontrado', false);
+    issues++;
+  }
+
+  // 5. Check jq
+  try {
+    const jqVersion = execSync('jq --version 2>&1', { encoding: 'utf8' }).trim();
+    check(`jq instalado (${jqVersion})`, true);
+    ok++;
+  } catch {
+    check('jq não encontrado — necessário para statusline', false);
+    issues++;
+  }
+
+  // 6. Check git
+  try {
+    const gitVersion = execSync('git --version 2>&1', { encoding: 'utf8' }).trim();
+    check(`${gitVersion}`, true);
+    ok++;
+  } catch {
+    check('git não encontrado', false);
+    issues++;
+  }
+
+  // 7. Check Node.js version
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1), 10);
+  if (major >= 18) {
+    check(`Node.js ${nodeVersion}`, true);
+    ok++;
+  } else {
+    check(`Node.js ${nodeVersion} (recomendado >= 18)`, false);
+    issues++;
+  }
+
+  // 8. Check handoff commands
+  const commandsDir = path.join(process.cwd(), '.claude', 'commands');
+  if (await fs.pathExists(commandsDir)) {
+    const commands = await fs.readdir(commandsDir);
+    const handoffCommands = commands.filter(f =>
+      ['resume.md', 'handoff.md', 'save-handoff.md'].includes(f)
+    );
+    if (handoffCommands.length > 0) {
+      check(`Handoff commands encontrados (${handoffCommands.length} de 7)`, true);
+      ok++;
+    } else {
+      check('Handoff commands não encontrados no projeto atual', false);
+      issues++;
+    }
+  } else {
+    check('.claude/commands/ não encontrado no projeto atual', false);
+    issues++;
+  }
+
+  // 9. Check AIOS
+  const aiosCoreDir = path.join(process.cwd(), '.aios-core');
+  if (await fs.pathExists(aiosCoreDir)) {
+    check('AIOS Core instalado no projeto', true);
+    ok++;
+
+    // Check aios-integrate skill
+    const skillPath = path.join(process.cwd(), '.claude', 'commands', 'aios-integrate.md');
+    if (await fs.pathExists(skillPath)) {
+      check('Skill /aios-integrate instalada', true);
+      ok++;
+    } else {
+      check('Skill /aios-integrate não encontrada', false);
+      issues++;
+    }
+  } else {
+    logger.dim('  - AIOS Core não instalado (opcional)');
+  }
+
+  // 10. Check env vars
+  const currency = process.env.CLAUDE_TOOLKIT_CURRENCY;
+  const rate = process.env.CLAUDE_TOOLKIT_CURRENCY_RATE;
+  if (currency || rate) {
+    check(`Moeda configurada: ${currency || '$'} (taxa: ${rate || '1'})`, true);
+    ok++;
+  } else {
+    logger.dim('  - Variáveis de moeda não definidas (usando defaults)');
+  }
+
+  // Summary
+  logger.blank();
+  if (issues === 0) {
+    logger.success(`Tudo OK! (${ok} verificações passaram)`);
+  } else {
+    logger.warn(`${issues} problema(s) encontrado(s), ${ok} OK`);
+  }
+}
+
+function check(msg, passed) {
+  if (passed) {
+    logger.success(msg);
+  } else {
+    logger.error(msg);
+  }
+}
+
+module.exports = { runDoctor };

package/src/commands/uninstall.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const inquirer = require('inquirer');
+const logger = require('../utils/logger');
+const { MANIFEST_PATH } = require('../installer');
+const { removeSettingsKey, SETTINGS_PATH } = require('../utils/settings-merger');
+
+async function runUninstall(options = {}) {
+  logger.section('Desinstalação');
+
+  // Check manifest
+  if (!(await fs.pathExists(MANIFEST_PATH))) {
+    logger.warn('Nenhuma instalação encontrada (manifest ausente).');
+    logger.dim(`Esperado em: ${MANIFEST_PATH}`);
+    return;
+  }
+
+  const manifest = await fs.readJson(MANIFEST_PATH);
+
+  logger.info(`Instalação encontrada (v${manifest.version}, ${manifest.installedAt})`);
+  logger.info(`Módulos: ${manifest.modules.join(', ')}`);
+  logger.blank();
+
+  // Confirm
+  if (!options.force) {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Remover tudo que foi instalado pelo toolkit?',
+        default: false
+      }
+    ]);
+
+    if (!confirm) {
+      logger.info('Cancelado.');
+      return;
+    }
+  }
+
+  const removed = [];
+
+  // Remove statusline
+  if (manifest.modules.includes('statusline')) {
+    const statusline = require('../modules/statusline');
+    const files = await statusline.uninstall();
+    removed.push(...files);
+    logger.success('Statusline removida');
+  }
+
+  // Remove handoff
+  if (manifest.modules.includes('handoff')) {
+    const handoff = require('../modules/handoff');
+    const files = await handoff.uninstall();
+    removed.push(...files);
+    logger.success('Session Handoff removido');
+  }
+
+  // Remove AIOS skill
+  if (manifest.modules.includes('aios')) {
+    const aios = require('../modules/aios');
+    const files = await aios.uninstall();
+    removed.push(...files);
+    logger.success('AIOS Skill removida');
+  }
+
+  // Remove settings.json backup
+  const backupPath = SETTINGS_PATH + '.backup';
+  if (await fs.pathExists(backupPath)) {
+    await fs.remove(backupPath);
+    removed.push(backupPath);
+  }
+
+  // Remove manifest
+  await fs.remove(MANIFEST_PATH);
+  removed.push(MANIFEST_PATH);
+
+  logger.blank();
+  logger.success(`Desinstalação completa (${removed.length} itens removidos)`);
+
+  if (manifest.aiosCore) {
+    logger.blank();
+    logger.info('AIOS Core NÃO foi removido (gerenciado separadamente).');
+    logger.dim('Para remover: npx aios-core uninstall');
+  }
+}
+
+module.exports = { runUninstall };

package/src/index.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { Command } = require('commander');
+const pkg = require('../package.json');
+const logger = require('./utils/logger');
+const { runInstaller } = require('./installer');
+const { runUninstall } = require('./commands/uninstall');
+const { runDoctor } = require('./commands/doctor');
+
+const program = new Command();
+
+program
+  .name('claude-code-toolkit')
+  .description('Setup completo para Claude Code: statusline, session handoff, AIOS')
+  .version(pkg.version);
+
+program
+  .command('install', { isDefault: true })
+  .description('Instala o toolkit (wizard interativo)')
+  .option('--statusline-only', 'Instala apenas a statusline')
+  .option('--handoff-only', 'Instala apenas o session handoff')
+  .option('--no-aios', 'Pula a configuração do AIOS')
+  .option('--currency <symbol>', 'Símbolo da moeda (ex: R$, $, €)')
+  .option('--currency-rate <rate>', 'Taxa de conversão USD→moeda', parseFloat)
+  .action(async (options) => {
+    logger.banner(pkg.version);
+    try {
+      await runInstaller(options);
+    } catch (err) {
+      if (err.name === 'ExitPromptError' || err.message?.includes('prompt')) {
+        logger.blank();
+        logger.info('Instalação cancelada.');
+        process.exit(0);
+      }
+      logger.error(`Erro: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('uninstall')
+  .description('Remove tudo que foi instalado pelo toolkit')
+  .option('--force', 'Remove sem confirmação')
+  .action(async (options) => {
+    logger.banner(pkg.version);
+    try {
+      await runUninstall(options);
+    } catch (err) {
+      logger.error(`Erro: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('doctor')
+  .description('Verifica integridade da instalação')
+  .action(async () => {
+    logger.banner(pkg.version);
+    try {
+      await runDoctor();
+    } catch (err) {
+      logger.error(`Erro: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/installer.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const inquirer = require('inquirer');
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+const logger = require('./utils/logger');
+const modules = require('./modules');
+
+const MANIFEST_PATH = path.join(os.homedir(), '.claude', '.toolkit-manifest.json');
+
+const CURRENCY_PRESETS = [
+  { name: 'BRL (R$)  — Taxa: 6.20', value: { symbol: 'R$', rate: 6.20 } },
+  { name: 'USD ($)   — Sem conversão', value: { symbol: '$', rate: 1 } },
+  { name: 'EUR (€)   — Taxa: 0.92', value: { symbol: '€', rate: 0.92 } },
+  { name: 'Personalizada — Definir símbolo e taxa', value: null }
+];
+
+async function runInstaller(cliOptions = {}) {
+  let selectedModules;
+  let currencyConfig;
+  let aiosOptions = {};
+
+  // --- Short-circuit for CLI flags ---
+  if (cliOptions.statuslineOnly) {
+    selectedModules = ['statusline'];
+    currencyConfig = {
+      symbol: cliOptions.currency || '$',
+      rate: cliOptions.currencyRate || 1
+    };
+  } else if (cliOptions.handoffOnly) {
+    selectedModules = ['handoff'];
+  } else {
+    // --- Interactive wizard ---
+
+    // Step 1: Module selection
+    const { selected } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selected',
+        message: 'Selecione o que deseja instalar:',
+        choices: [
+          {
+            name: `${modules.statusline.name}      — ${modules.statusline.description}`,
+            value: 'statusline',
+            checked: true
+          },
+          {
+            name: `${modules.handoff.name} — ${modules.handoff.description}`,
+            value: 'handoff',
+            checked: true
+          }
+        ]
+      }
+    ]);
+    selectedModules = selected;
+
+    if (selectedModules.length === 0) {
+      logger.warn('Nenhum módulo selecionado. Saindo.');
+      return;
+    }
+
+    // Step 2: Currency config (if statusline selected)
+    if (selectedModules.includes('statusline')) {
+      logger.section('Configuração da Statusline');
+
+      const { currencyPreset } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'currencyPreset',
+          message: 'Moeda para exibição de custo:',
+          choices: CURRENCY_PRESETS
+        }
+      ]);
+
+      if (currencyPreset === null) {
+        const custom = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'symbol',
+            message: 'Símbolo da moeda:',
+            default: '$'
+          },
+          {
+            type: 'number',
+            name: 'rate',
+            message: 'Taxa de conversão USD→moeda:',
+            default: 1
+          }
+        ]);
+        currencyConfig = custom;
+      } else {
+        currencyConfig = currencyPreset;
+      }
+    }
+
+    // Step 3: AIOS (opt-in)
+    if (cliOptions.aios !== false) {
+      logger.section('AIOS Framework');
+
+      const { useAios } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useAios',
+          message: 'Vai utilizar o AIOS?',
+          default: false
+        }
+      ]);
+
+      if (useAios) {
+        const { aiosChoices } = await inquirer.prompt([
+          {
+            type: 'checkbox',
+            name: 'aiosChoices',
+            message: 'Selecione as opções AIOS:',
+            choices: [
+              {
+                name: 'Instalar/Atualizar AIOS Core',
+                value: 'core',
+                checked: true
+              },
+              {
+                name: 'Instalar Skill /aios-integrate (integrar e gerenciar artefatos)',
+                value: 'skill',
+                checked: true
+              }
+            ]
+          }
+        ]);
+
+        selectedModules.push('aios');
+        aiosOptions = {
+          installAiosCore: aiosChoices.includes('core'),
+          installAiosSkill: aiosChoices.includes('skill')
+        };
+      }
+    }
+  }
+
+  // --- Execute installation ---
+  logger.section('Instalando...');
+
+  const manifest = {
+    version: require('../package.json').version,
+    installedAt: new Date().toISOString(),
+    modules: selectedModules,
+    files: []
+  };
+
+  // Install statusline
+  if (selectedModules.includes('statusline')) {
+    const result = await modules.statusline.module.install({
+      currency: currencyConfig?.symbol,
+      currencyRate: currencyConfig?.rate
+    });
+    if (result.installed) {
+      manifest.files.push(...modules.statusline.module.getManifestEntries());
+    }
+  }
+
+  // Install handoff
+  if (selectedModules.includes('handoff')) {
+    const result = await modules.handoff.module.install();
+    if (result.installed) {
+      manifest.files.push(...modules.handoff.module.getManifestEntries());
+    }
+  }
+
+  // Install AIOS
+  if (selectedModules.includes('aios')) {
+    const result = await modules.aios.module.install(aiosOptions);
+    manifest.files.push(...modules.aios.module.getManifestEntries());
+    if (aiosOptions.installAiosCore && result.core?.installed) {
+      manifest.aiosCore = true;
+    }
+  }
+
+  // Save manifest
+  await fs.ensureDir(path.dirname(MANIFEST_PATH));
+  await fs.writeJson(MANIFEST_PATH, manifest, { spaces: 2 });
+
+  // Final message
+  logger.blank();
+  logger.success('Pronto!');
+  logger.blank();
+
+  if (selectedModules.includes('statusline')) {
+    logger.info('Reinicie o Claude Code para ver a statusline.');
+  }
+  if (selectedModules.includes('aios') && aiosOptions.installAiosSkill) {
+    logger.info('Use /aios-integrate para integrar e gerenciar artefatos AIOS.');
+  }
+  logger.blank();
+}
+
+module.exports = { runInstaller, MANIFEST_PATH };

package/src/modules/aios.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+const { installFile } = require('../utils/file-installer');
+const logger = require('../utils/logger');
+
+const SKILL_SRC = path.join(__dirname, '..', '..', 'assets', 'skill', 'aios-integrate.md');
+
+async function installCore({ targetDir } = {}) {
+  const cwd = targetDir || process.cwd();
+
+  logger.dim('Executando aios-core install...');
+  try {
+    execSync('npx aios-core@latest install', {
+      cwd,
+      stdio: 'inherit',
+      timeout: 180000
+    });
+    logger.success('AIOS Core instalado/atualizado');
+    return { installed: true };
+  } catch (err) {
+    logger.warn(`AIOS Core falhou: ${err.message}`);
+    logger.dim('Você pode instalar manualmente depois: npx aios-core install');
+    return { installed: false, error: err.message };
+  }
+}
+
+async function installSkill({ targetDir } = {}) {
+  const cwd = targetDir || process.cwd();
+  const commandsDir = path.join(cwd, '.claude', 'commands');
+  const dest = path.join(commandsDir, 'aios-integrate.md');
+
+  await fs.ensureDir(commandsDir);
+
+  const result = await installFile(SKILL_SRC, dest);
+
+  if (result.action === 'installed') {
+    logger.success('Skill /aios-integrate instalada');
+  } else {
+    logger.success('Skill /aios-integrate já atualizada');
+  }
+
+  return { installed: true, path: dest };
+}
+
+async function install({ installAiosCore = true, installAiosSkill = true, targetDir } = {}) {
+  logger.section('AIOS Framework');
+
+  const results = {};
+
+  if (installAiosCore) {
+    results.core = await installCore({ targetDir });
+  }
+
+  if (installAiosSkill) {
+    results.skill = await installSkill({ targetDir });
+  }
+
+  return results;
+}
+
+async function uninstall({ targetDir } = {}) {
+  const cwd = targetDir || process.cwd();
+  const removed = [];
+
+  const skillPath = path.join(cwd, '.claude', 'commands', 'aios-integrate.md');
+  if (await fs.pathExists(skillPath)) {
+    await fs.remove(skillPath);
+    removed.push(skillPath);
+  }
+
+  return removed;
+}
+
+function getManifestEntries({ targetDir } = {}) {
+  const cwd = targetDir || process.cwd();
+  return [
+    path.join(cwd, '.claude', 'commands', 'aios-integrate.md')
+  ];
+}
+
+module.exports = { install, uninstall, getManifestEntries };

package/src/modules/handoff.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const logger = require('../utils/logger');
+
+async function install({ targetDir } = {}) {
+  logger.section('Session Handoff');
+
+  const cwd = targetDir || process.cwd();
+
+  try {
+    logger.dim('Executando claude-code-handoff...');
+    execSync('npx claude-code-handoff@latest', {
+      cwd,
+      stdio: 'inherit',
+      timeout: 120000
+    });
+    logger.success('claude-code-handoff instalado (7 commands, 2 hooks, 2 rules)');
+    return { installed: true };
+  } catch (err) {
+    logger.warn(`claude-code-handoff falhou: ${err.message}`);
+    logger.dim('Você pode instalar manualmente depois: npx claude-code-handoff');
+    return { installed: false, error: err.message };
+  }
+}
+
+async function uninstall({ targetDir } = {}) {
+  const cwd = targetDir || process.cwd();
+
+  try {
+    execSync('npx claude-code-handoff@latest uninstall', {
+      cwd,
+      stdio: 'inherit',
+      timeout: 60000
+    });
+    return ['claude-code-handoff (commands, hooks, rules)'];
+  } catch {
+    logger.dim('claude-code-handoff uninstall não disponível — remova manualmente .claude/commands/');
+    return [];
+  }
+}
+
+function getManifestEntries() {
+  return ['claude-code-handoff'];
+}
+
+module.exports = { install, uninstall, getManifestEntries };

package/src/modules/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const statusline = require('./statusline');
+const handoff = require('./handoff');
+const aios = require('./aios');
+
+const modules = {
+  statusline: {
+    name: 'Statusline',
+    description: 'Barra de status: modelo, contexto %, custo, tempo, git',
+    module: statusline,
+    default: true
+  },
+  handoff: {
+    name: 'Session Handoff',
+    description: 'Continuidade de sessão (via claude-code-handoff)',
+    module: handoff,
+    default: true
+  },
+  aios: {
+    name: 'AIOS Framework',
+    description: 'Framework de orquestração de agentes AI',
+    module: aios,
+    default: false
+  }
+};
+
+module.exports = modules;

package/src/modules/statusline.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+const { installFile } = require('../utils/file-installer');
+const { mergeSettings, removeSettingsKey } = require('../utils/settings-merger');
+const logger = require('../utils/logger');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const STATUSLINE_DEST = path.join(CLAUDE_DIR, 'statusline.sh');
+const STATUSLINE_SRC = path.join(__dirname, '..', '..', 'assets', 'statusline', 'statusline.sh');
+
+const STATUSLINE_SETTINGS = {
+  statusLine: {
+    command: `bash ${STATUSLINE_DEST}`
+  }
+};
+
+async function install({ currency, currencyRate } = {}) {
+  logger.section('Statusline');
+
+  // Install statusline.sh
+  const result = await installFile(STATUSLINE_SRC, STATUSLINE_DEST, { executable: true });
+
+  if (result.action === 'installed') {
+    logger.success(`Statusline instalada em ${STATUSLINE_DEST}`);
+  } else {
+    logger.success(`Statusline já atualizada em ${STATUSLINE_DEST}`);
+  }
+
+  // Merge settings.json
+  await mergeSettings(STATUSLINE_SETTINGS);
+  logger.success('settings.json atualizado com statusLine');
+
+  // Create env hint file if currency was configured
+  if (currency || currencyRate) {
+    const envHints = [];
+    if (currency) envHints.push(`export CLAUDE_TOOLKIT_CURRENCY="${currency}"`);
+    if (currencyRate) envHints.push(`export CLAUDE_TOOLKIT_CURRENCY_RATE="${currencyRate}"`);
+
+    const envFile = path.join(CLAUDE_DIR, 'toolkit-env.sh');
+    await fs.writeFile(envFile, envHints.join('\n') + '\n');
+    logger.dim(`Variáveis de moeda salvas em ${envFile}`);
+    logger.dim('Adicione ao seu .zshrc/.bashrc: source ~/.claude/toolkit-env.sh');
+  }
+
+  // Check jq
+  const { execSync } = require('child_process');
+  try {
+    execSync('which jq', { stdio: 'ignore' });
+  } catch {
+    logger.warn('jq não encontrado. A statusline requer jq para funcionar.');
+    logger.dim('Instale com: brew install jq (macOS) ou apt install jq (Linux)');
+  }
+
+  return { installed: true };
+}
+
+async function uninstall() {
+  const removed = [];
+
+  if (await fs.pathExists(STATUSLINE_DEST)) {
+    await fs.remove(STATUSLINE_DEST);
+    removed.push(STATUSLINE_DEST);
+  }
+
+  await removeSettingsKey('statusLine');
+
+  const envFile = path.join(CLAUDE_DIR, 'toolkit-env.sh');
+  if (await fs.pathExists(envFile)) {
+    await fs.remove(envFile);
+    removed.push(envFile);
+  }
+
+  return removed;
+}
+
+function getManifestEntries() {
+  return [
+    STATUSLINE_DEST,
+    path.join(CLAUDE_DIR, 'toolkit-env.sh')
+  ];
+}
+
+module.exports = { install, uninstall, getManifestEntries };

package/src/utils/file-installer.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+const logger = require('./logger');
+
+function fileHash(filePath) {
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash('md5').update(content).digest('hex');
+}
+
+async function installFile(src, dest, { executable = false } = {}) {
+  await fs.ensureDir(path.dirname(dest));
+
+  if (await fs.pathExists(dest)) {
+    const srcHash = fileHash(src);
+    const destHash = fileHash(dest);
+    if (srcHash === destHash) {
+      logger.dim(`Já atualizado: ${dest}`);
+      return { action: 'skipped', path: dest };
+    }
+    logger.dim(`Atualizando: ${dest}`);
+  }
+
+  await fs.copy(src, dest);
+
+  if (executable) {
+    await fs.chmod(dest, 0o755);
+  }
+
+  return { action: 'installed', path: dest };
+}
+
+async function uninstallFile(filePath) {
+  if (await fs.pathExists(filePath)) {
+    await fs.remove(filePath);
+    return { action: 'removed', path: filePath };
+  }
+  return { action: 'not_found', path: filePath };
+}
+
+module.exports = { installFile, uninstallFile, fileHash };

package/src/utils/logger.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const chalk = require('chalk');
+
+const logger = {
+  banner(version) {
+    console.log('');
+    console.log(chalk.cyan('  ╔══════════════════════════════════════╗'));
+    console.log(chalk.cyan('  ║') + chalk.bold.white(`   claude-code-toolkit v${version}`.padEnd(38)) + chalk.cyan('║'));
+    console.log(chalk.cyan('  ║') + chalk.gray('   Setup completo para Claude Code   ') + chalk.cyan('║'));
+    console.log(chalk.cyan('  ╚══════════════════════════════════════╝'));
+    console.log('');
+  },
+
+  section(title) {
+    console.log('');
+    console.log(chalk.cyan(`  ─── ${title} ───`));
+    console.log('');
+  },
+
+  success(msg) {
+    console.log(chalk.green('  ✓ ') + msg);
+  },
+
+  warn(msg) {
+    console.log(chalk.yellow('  ⚠ ') + msg);
+  },
+
+  error(msg) {
+    console.log(chalk.red('  ✗ ') + msg);
+  },
+
+  info(msg) {
+    console.log(chalk.blue('  ℹ ') + msg);
+  },
+
+  dim(msg) {
+    console.log(chalk.dim(`    ${msg}`));
+  },
+
+  blank() {
+    console.log('');
+  }
+};
+
+module.exports = logger;

package/src/utils/settings-merger.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const logger = require('./logger');
+
+const SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+const BACKUP_SUFFIX = '.backup';
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key]) &&
+      target[key] &&
+      typeof target[key] === 'object' &&
+      !Array.isArray(target[key])
+    ) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+async function mergeSettings(newSettings) {
+  await fs.ensureDir(path.dirname(SETTINGS_PATH));
+
+  let existing = {};
+  if (await fs.pathExists(SETTINGS_PATH)) {
+    const backupPath = SETTINGS_PATH + BACKUP_SUFFIX;
+    await fs.copy(SETTINGS_PATH, backupPath);
+    logger.dim(`Backup criado: ${backupPath}`);
+    existing = await fs.readJson(SETTINGS_PATH);
+  }
+
+  const merged = deepMerge(existing, newSettings);
+  await fs.writeJson(SETTINGS_PATH, merged, { spaces: 2 });
+  return merged;
+}
+
+async function removeSettingsKey(key) {
+  if (!(await fs.pathExists(SETTINGS_PATH))) return;
+
+  const settings = await fs.readJson(SETTINGS_PATH);
+  if (key in settings) {
+    delete settings[key];
+    await fs.writeJson(SETTINGS_PATH, settings, { spaces: 2 });
+  }
+}
+
+async function readSettings() {
+  if (!(await fs.pathExists(SETTINGS_PATH))) return {};
+  return fs.readJson(SETTINGS_PATH);
+}
+
+module.exports = { mergeSettings, removeSettingsKey, readSettings, SETTINGS_PATH, deepMerge };