@fefsbenson/jarvis 1.0.0

package/LICENSE

@@ -0,0 +1,35 @@
+JARVIS — Licença de Uso
+
+Copyright (c) 2026 Felipe Brandão / PRAGMA
+
+CONCESSÃO
+Este software é licenciado, não vendido, para uso interno do licenciado
+identificado no contrato de entrega. É permitido:
+
+  · instalar e executar em quantas máquinas o licenciado operar;
+  · modificar o código, as regras, as skills e os agentes para uso próprio;
+  · ingerir e processar material próprio com o sistema.
+
+RESTRIÇÕES
+Não é permitido, sem autorização escrita:
+
+  · redistribuir, revender, sublicenciar ou publicar o sistema, no todo
+    ou em parte, a terceiros;
+  · oferecer o sistema como serviço a terceiros (SaaS);
+  · remover a atribuição de autoria.
+
+MATERIAL DE TERCEIROS
+A base de conhecimento em knowledge/external/ contém conhecimento destilado
+de material de autoria de terceiros, mantido com atribuição à fonte original.
+Esse conteúdo permanece propriedade dos respectivos autores e é fornecido
+para uso interno do licenciado — sua redistribuição é vedada.
+
+SEM GARANTIA
+O software é fornecido "no estado em que se encontra", sem garantia de
+qualquer natureza. O autor não responde por perda de dados, interrupção de
+operação ou decisões tomadas com apoio do sistema.
+
+DEPENDÊNCIAS
+O sistema requer Claude Code (Anthropic), sujeito aos termos de uso da
+Anthropic, e opcionalmente serviços de terceiros cujas credenciais o
+licenciado fornece e cujos termos e custos são de sua responsabilidade.

package/README.md

@@ -0,0 +1,38 @@
+# JARVIS
+
+Sistema operacional de conhecimento e agentes para Claude Code.
+
+```bash
+npx @pragma/jarvis install
+```
+
+Este pacote é o **instalador**. Ele baixa o sistema de uma distribuição
+privada e conduz a instalação — 5 passos, cerca de 2 minutos.
+
+## Requisitos
+
+- **[Claude Code](https://claude.ai/claude-code)** (Pro ou Max) — é onde o JARVIS roda
+- **Python 3.10+** — o sistema é Python; o Node serve só para este baixador
+- **Token de acesso** — fornecido por quem entregou o sistema
+
+## O que ele faz
+
+| Passo | |
+|---|---|
+| 1 | Confere o ambiente e diz o que falta |
+| 2 | Pergunta quem é você (nome, tratamento, empresa) |
+| 3 | Coleta as credenciais que você quiser usar — nenhuma é obrigatória |
+| 4 | Instala num ambiente Python isolado |
+| 5 | **Verifica que funciona** — não só que copiou |
+
+## Uso
+
+```bash
+npx @pragma/jarvis install          # instala em ./jarvis
+npx @pragma/jarvis install PASTA    # instala onde você quiser
+```
+
+O token também pode vir da variável `JARVIS_TOKEN`.
+
+---
+PRAGMA · by Felipe Brandão

package/bin/cli.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+/**
+ * JARVIS — baixador.
+ *
+ * Este pacote npm é SÓ o transporte (~20 KB). O sistema em si (108 MB, com
+ * conhecimento destilado de material de terceiros) vive num Release PRIVADO
+ * do GitHub e exige token de acesso — a licença proíbe distribuição pública.
+ *
+ *     npx @pragma/jarvis install
+ *
+ * Só Node built-in: precisa rodar antes de qualquer dependência existir.
+ *
+ * JARVIS · PRAGMA · by Felipe Brandão
+ */
+import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+
+const REPO = 'fefsbenson/jarvis-entrega';
+const PASTA_PADRAO = 'jarvis';
+
+// ── cores (somem se o terminal não suportar) ─────────────────────────
+const tty = process.stdout.isTTY && !process.env.NO_COLOR;
+const c = (t, k) => (tty ? `\x1b[${k}m${t}\x1b[0m` : t);
+const laranja = t => c(t, '38;5;208');
+const branco = t => c(t, '38;5;255');
+const cinza = t => c(t, '38;5;250');
+const fraco = t => c(t, '38;5;240');
+const verde = t => c(t, '38;5;71');
+const vermelho = t => c(t, '38;5;167');
+const neg = t => c(t, '1');
+
+const LOGO = [
+  '     ██  █████  ██████  ██    ██ ██ ███████',
+  '     ██ ██   ██ ██   ██ ██    ██ ██ ██',
+  '     ██ ███████ ██████  ██    ██ ██ ███████',
+  '██   ██ ██   ██ ██   ██  ██  ██  ██      ██',
+  ' █████  ██   ██ ██   ██   ████   ██ ███████',
+];
+
+function abertura() {
+  console.log();
+  for (const l of LOGO) console.log('  ' + laranja(neg(l)));
+  console.log();
+  console.log(`     ${cinza('Sistema operacional de conhecimento e agentes')}`);
+  console.log(`     ${fraco('PRAGMA  ·  by Felipe Brandão')}`);
+  console.log();
+  console.log('  ' + fraco('─'.repeat(66)));
+  console.log();
+}
+
+function perguntar(texto, oculto = false) {
+  return new Promise(res => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    if (oculto && process.stdin.isTTY) {
+      // não ecoa o token na tela nem deixa no scrollback
+      const escrever = rl._writeToOutput.bind(rl);
+      rl._writeToOutput = function (s) {
+        if (s.includes(texto)) escrever(s);
+        else escrever('*');
+      };
+    }
+    rl.question(`  ${laranja('▸')} ${texto} `, r => { rl.close(); if (oculto) console.log(); res(r.trim()); });
+  });
+}
+
+/** Precisa de Python — o instalador de verdade é ele. */
+function acharPython() {
+  for (const cmd of ['python3', 'python']) {
+    const r = spawnSync(cmd, ['-c', 'import sys;print(sys.version_info[:2])'],
+                        { encoding: 'utf8' });
+    if (r.status === 0) {
+      const m = r.stdout.match(/\((\d+),\s*(\d+)\)/);
+      if (m && (+m[1] > 3 || (+m[1] === 3 && +m[2] >= 10))) return { cmd, versao: `${m[1]}.${m[2]}` };
+    }
+  }
+  return null;
+}
+
+async function api(caminho, token, aceitar = 'application/vnd.github+json') {
+  const r = await fetch(`https://api.github.com${caminho}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: aceitar,
+      'User-Agent': 'jarvis-installer',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+    redirect: 'follow',
+  });
+  return r;
+}
+
+function barra(feito, total) {
+  const largura = 28;
+  const pct = total ? feito / total : 0;
+  const cheio = Math.round(pct * largura);
+  return `  ${laranja('█'.repeat(cheio))}${fraco('░'.repeat(largura - cheio))}  ${cinza(`${Math.round(pct * 100)}%`)}`;
+}
+
+async function baixar(token, destino) {
+  // 1. qual é a versão mais recente
+  const rel = await api(`/repos/${REPO}/releases/latest`, token);
+  if (rel.status === 401) throw new Error('TOKEN_INVALIDO');
+  if (rel.status === 404) throw new Error('SEM_ACESSO');
+  if (!rel.ok) throw new Error(`GitHub respondeu ${rel.status}`);
+  const dados = await rel.json();
+
+  const asset = (dados.assets || []).find(a => a.name.endsWith('.tar.gz'));
+  if (!asset) throw new Error('Release sem pacote .tar.gz');
+
+  console.log(`  ${verde('✓')}  ${branco('Versão')} ${cinza(dados.tag_name)}  ${fraco((asset.size / 1048576).toFixed(1) + ' MB')}`);
+
+  // 2. baixa o tarball (asset privado exige Accept: octet-stream)
+  const bin = await api(`/repos/${REPO}/releases/assets/${asset.id}`, token,
+                        'application/octet-stream');
+  if (!bin.ok) throw new Error(`download falhou (${bin.status})`);
+
+  const tmp = join(tmpdir(), `jarvis-${Date.now()}.tar.gz`);
+  const total = Number(bin.headers.get('content-length')) || asset.size;
+  let feito = 0;
+  let ultimo = 0;
+
+  const origem = Readable.fromWeb(bin.body);
+  origem.on('data', pedaco => {
+    feito += pedaco.length;
+    const agora = Date.now();
+    // A barra so redesenha em TTY: com o output capturado (pipe, log, CI) o
+    // \r nao apaga a linha e o progresso vira uma parede de barras.
+    if (tty && agora - ultimo > 200) {
+      ultimo = agora;
+      process.stdout.write('\r' + barra(feito, total));
+    }
+  });
+  await pipeline(origem, createWriteStream(tmp));
+  if (tty) process.stdout.write('\r' + barra(total, total) + '\n');
+  else console.log(`  ${verde('✓')}  ${branco('Baixado')}  ${fraco((total / 1048576).toFixed(1) + ' MB')}`);
+
+  // 3. extrai
+  mkdirSync(destino, { recursive: true });
+  const tar = spawnSync('tar', ['xzf', tmp, '-C', destino, '--strip-components=1'],
+                        { encoding: 'utf8' });
+  if (tar.status !== 0) throw new Error(`tar falhou: ${(tar.stderr || '').slice(0, 120)}`);
+
+  const n = contar(destino);
+  console.log(`  ${verde('✓')}  ${branco('Extraído')}  ${fraco(n.toLocaleString('pt-BR') + ' arquivos')}`);
+  return destino;
+}
+
+function contar(dir) {
+  let n = 0;
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (e.name === 'node_modules' || e.name === '.git') continue;
+    n += e.isDirectory() ? contar(join(dir, e.name)) : 1;
+  }
+  return n;
+}
+
+function erroDeAcesso(tipo) {
+  console.log();
+  if (tipo === 'TOKEN_INVALIDO') {
+    console.log(`  ${vermelho(neg('Token inválido.'))}`);
+    console.log(`  ${cinza('O token expirou ou foi digitado errado.')}`);
+  } else {
+    console.log(`  ${vermelho(neg('Este token não tem acesso ao JARVIS.'))}`);
+    console.log(`  ${cinza('A distribuição é privada — o acesso é liberado por quem entregou o sistema.')}`);
+  }
+  console.log();
+  console.log(`  ${fraco('Fale com quem forneceu o JARVIS para receber um token válido.')}`);
+  console.log();
+}
+
+async function instalar(args) {
+  abertura();
+
+  const py = acharPython();
+  if (!py) {
+    console.log(`  ${vermelho(neg('Falta Python 3.10 ou superior.'))}`);
+    console.log();
+    console.log(`  ${cinza('O JARVIS roda em Python. O Node serve só para este baixador.')}`);
+    console.log();
+    console.log(`  ${branco('No Ubuntu/WSL:')}  ${fraco('sudo apt install python3 python3-venv')}`);
+    console.log(`  ${branco('No macOS:')}       ${fraco('brew install python@3.12')}`);
+    console.log();
+    return 1;
+  }
+
+  const destino = resolve(process.cwd(), args[0] || PASTA_PADRAO);
+  if (existsSync(destino) && readdirSync(destino).length) {
+    console.log(`  ${vermelho(neg('A pasta ' + destino + ' já existe e não está vazia.'))}`);
+    console.log(`  ${cinza('Escolha outro nome: ')}${fraco('npx @pragma/jarvis install minha-pasta')}`);
+    console.log();
+    return 1;
+  }
+
+  console.log(`  ${branco('Vou baixar o JARVIS e instalar aqui.')}`);
+  console.log(`  ${fraco('Destino:')}  ${branco(destino)}`);
+  console.log(`  ${fraco('Python:')}   ${branco(py.cmd + ' ' + py.versao)}`);
+  console.log();
+  console.log(`  ${cinza('A distribuição é privada. Cole o token de acesso que você recebeu.')}`);
+  console.log(`  ${fraco('(o token não aparece na tela)')}`);
+  console.log();
+
+  const token = process.env.JARVIS_TOKEN || await perguntar('Token:', true);
+  if (!token) {
+    console.log(`\n  ${fraco('Sem token, não há o que baixar. Cancelado.')}\n`);
+    return 130;
+  }
+
+  console.log();
+  try {
+    await baixar(token, destino);
+  } catch (e) {
+    if (e.message === 'TOKEN_INVALIDO' || e.message === 'SEM_ACESSO') {
+      erroDeAcesso(e.message);
+    } else {
+      console.log(`\n  ${vermelho(neg('Não consegui baixar.'))}`);
+      console.log(`  ${cinza(e.message)}`);
+      console.log(`\n  ${fraco('Verifique sua conexão e tente de novo.')}\n`);
+    }
+    return 1;
+  }
+
+  // entrega o comando ao instalador de verdade, que é Python
+  console.log();
+  const r = spawnSync(py.cmd, [join(destino, 'install.py'), ...args.slice(1)],
+                      { stdio: 'inherit', cwd: destino });
+  return r.status ?? 0;
+}
+
+function ajuda() {
+  abertura();
+  console.log(`  ${branco('npx @pragma/jarvis install')}          ${fraco('baixa e instala em ./jarvis')}`);
+  console.log(`  ${branco('npx @pragma/jarvis install PASTA')}    ${fraco('instala na pasta que você escolher')}`);
+  console.log();
+  console.log(`  ${fraco('Precisa de: Node 18+, Python 3.10+ e o token de acesso.')}`);
+  console.log(`  ${fraco('O token também pode vir da variável JARVIS_TOKEN.')}`);
+  console.log();
+}
+
+const [, , comando, ...resto] = process.argv;
+if (comando === 'install') {
+  instalar(resto).then(cod => process.exit(cod));
+} else {
+  ajuda();
+  process.exit(comando ? 1 : 0);
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@fefsbenson/jarvis",
+  "version": "1.0.0",
+  "description": "JARVIS — sistema operacional de conhecimento e agentes para Claude Code",
+  "bin": {
+    "jarvis": "bin/cli.js"
+  },
+  "type": "module",
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Felipe Brandão / PRAGMA",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fefsbenson/jarvis-entrega.git"
+  },
+  "keywords": [
+    "claude-code",
+    "jarvis",
+    "agents",
+    "knowledge-management",
+    "pragma"
+  ]
+}