jarvis-ai-framework 1.0.0

package/bin/commands/docs-sync.js

@@ -0,0 +1,139 @@
+import { loadEnv, resolveEnvPath } from '../lib/env-loader.js'
+import { exec } from 'node:child_process'
+import { promisify } from 'node:util'
+import { existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const execAsync = promisify(exec)
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+/**
+ * Sincroniza documentação do central-docs
+ * Executado automaticamente em /warm-up
+ * 
+ * @param {Object} flags - Flags do comando
+ * @param {boolean} flags.silent - Modo silencioso (sem output)
+ * @param {boolean} flags.verbose - Modo verbose (mostra conteúdo)
+ * @param {string} flags.envFile - Path customizado do ENV.md
+ */
+export async function docsSync(flags = {}) {
+  const cwd = process.cwd()
+  
+  // Resolver path do ENV.md (suporta --ide e --env-file)
+  let envPath
+  try {
+    const resolved = resolveEnvPath(cwd, flags)
+    envPath = resolved.path
+  } catch (error) {
+    if (!flags.silent) {
+      console.error('❌ Erro ao resolver ENV.md:', error.message)
+    }
+    process.exit(1)
+  }
+  
+  // Carregar ENV.md
+  let env
+  try {
+    env = loadEnv(cwd, envPath)
+  } catch (error) {
+    if (!flags.silent) {
+      console.error('❌ Erro ao carregar ENV.md:', error.message)
+    }
+    process.exit(1)
+  }
+  
+  // Verificar se central-docs está configurado
+  if (!env.CENTRAL_DOCS_REPO) {
+    if (!flags.silent) {
+      console.log('ℹ️  Central docs não configurado (CENTRAL_DOCS_REPO vazio)')
+    }
+    return
+  }
+  
+  const { SQUAD, WORKSPACE, CENTRAL_DOCS_REF = 'main' } = env
+  
+  if (!SQUAD || !WORKSPACE) {
+    if (!flags.silent) {
+      console.error('❌ SQUAD ou WORKSPACE não definidos no ENV.md')
+    }
+    process.exit(1)
+  }
+  
+  if (!flags.silent) {
+    console.log(`🔄 Sincronizando docs do squad ${SQUAD}...`)
+  }
+
+  // Verificar se script fetch-file.sh existe
+  // Usar path relativo ao módulo, não ao cwd do usuário
+  const fetchScript = join(__dirname, '../lib/docs/fetch-file.sh')
+  if (!existsSync(fetchScript)) {
+    console.error('❌ Script não encontrado:', fetchScript)
+    process.exit(1)
+  }
+
+  // Buscar index.md do squad
+  const indexPath = `${SQUAD}/index.md`
+  
+  try {
+    // Exportar variáveis de ambiente para o script bash
+    const envVars = {
+      ...process.env,
+      CENTRAL_DOCS_REPO: env.CENTRAL_DOCS_REPO,
+      CENTRAL_DOCS_CACHE_TTL: env.CENTRAL_DOCS_CACHE_TTL || '3600'
+    }
+    
+    const { stdout, stderr } = await execAsync(
+      `bash "${fetchScript}" "${indexPath}" "${CENTRAL_DOCS_REF}"`,
+      { env: envVars }
+    )
+    
+    if (!flags.silent) {
+      console.log('✅ Docs sincronizados')
+    }
+    
+    if (flags.verbose && stdout) {
+      console.log('\n📄 Conteúdo do index.md:\n')
+      console.log(stdout)
+    }
+    
+    // Parsear index.md para contar documentos
+    if (!flags.silent && stdout) {
+      const prdCount = (stdout.match(/\[prd-.*\.md\]/g) || []).length
+      const frdCount = (stdout.match(/\[frd-.*\.md\]/g) || []).length
+      const ardCount = (stdout.match(/\[ard-.*\.md\]/g) || []).length
+      const rfcCount = (stdout.match(/\[rfc-.*\.md\]/g) || []).length
+      
+      const total = prdCount + frdCount + ardCount + rfcCount
+      
+      if (total > 0) {
+        console.log(`📊 ${total} documentos disponíveis:`)
+        if (prdCount > 0) console.log(`   - ${prdCount} PRD(s)`)
+        if (frdCount > 0) console.log(`   - ${frdCount} FRD(s)`)
+        if (ardCount > 0) console.log(`   - ${ardCount} ARD(s)`)
+        if (rfcCount > 0) console.log(`   - ${rfcCount} RFC(s)`)
+      }
+    }
+    
+    if (stderr && !flags.silent) {
+      console.warn('⚠️  Avisos:', stderr)
+    }
+    
+  } catch (error) {
+    if (!flags.silent) {
+      console.error('❌ Erro ao sincronizar docs:', error.message)
+      
+      // Dicas de troubleshooting
+      if (error.message.includes('Token GitLab')) {
+        console.error('\n💡 Configure o token GitLab no .npmrc:')
+        console.error('   //gitlab.com/api/v4/packages/npm/:_authToken=seu-token')
+      } else if (error.message.includes('não encontrado')) {
+        console.error('\n💡 Verifique se o squad existe no central-docs:')
+        console.error(`   ${SQUAD}/index.md`)
+      }
+    }
+
+    process.exit(1)
+  }
+}

package/bin/commands/info.js

@@ -0,0 +1,87 @@
+import { findPrompt, discoverAll } from "../lib/core/scanner.js";
+import {
+  showBanner,
+  RED,
+  GREEN,
+  BLUE,
+  YELLOW,
+  CYAN,
+  DIM,
+  NC,
+} from "../lib/utils/ui.js";
+import { logger } from "../lib/utils/logger.js";
+
+export async function info(target) {
+  showBanner();
+
+  if (!target) {
+    logger.error(`${RED}❌ Uso incorreto${NC}`);
+    logger.info(`${YELLOW}Uso: jarvis info <type/name>${NC}`);
+    logger.info(`${DIM}Exemplo: jarvis info agent/eng.agent${NC}\n`);
+    process.exit(1);
+  }
+
+  let prompt = findPrompt(target);
+
+  if (!prompt && !target.includes("/")) {
+    const all = discoverAll();
+    const allPrompts = [...all.agents, ...all.skills, ...all.workflows];
+
+    prompt = allPrompts.find((p) => p.id === target);
+
+    if (!prompt) {
+      prompt = allPrompts.find((p) => p.id.startsWith(target));
+    }
+
+    if (!prompt) {
+      prompt = allPrompts.find((p) => p.id.includes(target));
+    }
+  }
+
+  if (!prompt) {
+    logger.error(`${RED}❌ Não encontrado: ${YELLOW}${target}${NC}`);
+    logger.info(
+      `${DIM}Execute: ${YELLOW}jarvis list${DIM} para ver prompts disponíveis${NC}\n`,
+    );
+    process.exit(1);
+  }
+
+  // Icon based on type
+  const icon =
+    prompt.type === "agent" ? "🤖" : prompt.type === "skill" ? "⚡" : "🔄";
+
+  logger.info(`${CYAN}${icon} ${prompt.type.toUpperCase()}/${prompt.id}${NC}`);
+  logger.info("");
+  logger.info(`  ${BLUE}Nome:${NC}        ${GREEN}${prompt.name}${NC}`);
+  logger.info(`  ${BLUE}Versão:${NC}      ${prompt.version}`);
+  if (prompt.model) {
+    logger.info(`  ${BLUE}Modelo:${NC}      ${prompt.model}`);
+  }
+  logger.info(`  ${BLUE}Descrição:${NC}   ${DIM}${prompt.description}${NC}`);
+  logger.info(`  ${BLUE}Caminho:${NC}     ${DIM}${prompt.path}${NC}`);
+  logger.info("");
+
+  const deps = prompt.deps;
+  const hasDeps = Object.values(deps).some((arr) => arr.length > 0);
+
+  if (hasDeps) {
+    logger.info(`  ${YELLOW}📦 Dependências:${NC}`);
+    if (deps.rules.length)
+      logger.info(
+        `    ${BLUE}Rules:${NC}     ${DIM}${deps.rules.join(", ")}${NC}`,
+      );
+    if (deps.templates.length)
+      logger.info(
+        `    ${BLUE}Templates:${NC} ${DIM}${deps.templates.join(", ")}${NC}`,
+      );
+    if (deps.agents.length)
+      logger.info(
+        `    ${BLUE}Agents:${NC}    ${DIM}${deps.agents.join(", ")}${NC}`,
+      );
+    if (deps.skills.length)
+      logger.info(
+        `    ${BLUE}Skills:${NC}    ${DIM}${deps.skills.join(", ")}${NC}`,
+      );
+    logger.info("");
+  }
+}

package/bin/commands/init.js

@@ -0,0 +1,237 @@
+import { existsSync, mkdirSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { syncAssets } from "../lib/core/sync-engine.js";
+import { discoverAll } from "../lib/core/scanner.js";
+import {
+  IDES,
+  getIDEConfig,
+  getIDEFolder,
+  getWorkflowsFolder,
+  isIDESupported,
+} from "../lib/config/ide-config.js";
+import {
+  showBanner,
+  RED,
+  GREEN,
+  BLUE,
+  YELLOW,
+  CYAN,
+  DIM,
+  BOLD,
+  NC,
+} from "../lib/utils/ui.js";
+import { getPackageInfo } from "../lib/utils/paths.js";
+import { logger, configureFromFlags } from "../lib/utils/logger.js";
+
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+export async function init(flags) {
+  configureFromFlags(flags);
+
+  const cwd = process.cwd();
+
+  showBanner();
+
+  let ide;
+  if (flags.ide) {
+    if (!isIDESupported(flags.ide)) {
+      logger.error(`${RED}❌ IDE inválida: ${flags.ide}${NC}`);
+      logger.info(
+        `${YELLOW}IDEs disponíveis: ${IDES.filter((i) => i.supported).map((i) => i.value).join(", ")}${NC}\n`,
+      );
+      return;
+    }
+    ide = flags.ide;
+    const ideObj = getIDEConfig(ide);
+    logger.info(`${GREEN}✓ IDE: ${ideObj.name}${NC}\n`);
+  } else {
+    logger.info(`${YELLOW}Qual IDE você está usando?${NC}`);
+    logger.info("");
+
+    IDES.forEach((ideObj, index) => {
+      if (ideObj.supported) {
+        logger.info(`  ${GREEN}${index + 1}${NC}) ${ideObj.name}`);
+      } else {
+        logger.info(
+          `  ${DIM}${index + 1}) ${ideObj.name} (não suportado)${NC}`,
+        );
+      }
+    });
+    logger.info("");
+
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    let choice;
+    while (true) {
+      choice = await ask(
+        rl,
+        `${BLUE}Digite o número da sua escolha (1-${IDES.length}): ${NC}`,
+      );
+      const choiceNum = parseInt(choice, 10);
+
+      if (choiceNum >= 1 && choiceNum <= IDES.length) {
+        const selectedIde = IDES[choiceNum - 1];
+        if (selectedIde.supported) {
+          ide = selectedIde.value;
+          logger.info("");
+          logger.info(
+            `${GREEN}Interface selecionada: ${selectedIde.name}${NC}`,
+          );
+          logger.info(`${DIM}Pasta destino: .${getIDEFolder(ide)}${NC}`);
+          logger.info("");
+          break;
+        } else {
+          logger.info(`${DIM}Esta interface ainda não é suportada.${NC}\n`);
+        }
+      } else {
+        logger.info(
+          `${RED}Opção inválida. Por favor, escolha um número entre 1 e ${IDES.length}.${NC}\n`,
+        );
+      }
+    }
+
+    rl.close();
+  }
+
+  const ideDir = join(cwd, `.${getIDEFolder(ide)}`);
+
+  // Reinstall: --force ou confirmação "s" devem sobrescrever assets (cpSync force:true).
+  let forceSync = !!flags.force;
+
+  if (existsSync(ideDir) && !forceSync) {
+    logger.info(`${YELLOW}⚠️  Framework já instalado em .${getIDEFolder(ide)}${NC}`);
+    logger.info("");
+
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const confirm = await ask(
+      rl,
+      `Deseja reinstalar? Isso irá sobrescrever a instalação existente. (s/N): `,
+    );
+    rl.close();
+
+    if (confirm.toLowerCase() !== "s") {
+      logger.info(`${BLUE}ℹ️  Instalação cancelada.${NC}\n`);
+      return;
+    }
+    forceSync = true;
+    logger.info("");
+  }
+
+  const ideConfig = getIDEConfig(ide);
+  logger.info(
+    `${BLUE}Configurando ambiente para ${ideConfig?.name}...${NC}`,
+  );
+  logger.info("");
+  const result = syncAssets(cwd, ide, {
+    force: forceSync,
+    workflowsFolder: getWorkflowsFolder(ide),
+  });
+
+  for (const item of result.copied) {
+    logger.info(`${BLUE}  ↳ ${item}${NC}`);
+  }
+  for (const item of result.skipped) {
+    logger.info(`${DIM}  ↳ ${item} (já existe)${NC}`);
+  }
+  for (const item of result.errors) {
+    logger.error(`${RED}  ✗ ${item}${NC}`);
+  }
+
+  const jarvisRoot = join(cwd, '.jarvis');
+  for (const area of ['eng', 'prod', 'qa']) {
+    mkdirSync(join(jarvisRoot, 'sessions', area), { recursive: true });
+  }
+  const gitignore = join(cwd, '.gitignore');
+  const ignoreLine = '.jarvis/';
+  if (existsSync(gitignore)) {
+    const text = readFileSync(gitignore, 'utf8');
+    if (!text.split('\n').some((l) => l.trim() === ignoreLine || l.trim() === '.jarvis')) {
+      appendFileSync(gitignore, `${text.endsWith('\n') ? '' : '\n'}${ignoreLine}\n`);
+    }
+  } else {
+    writeFileSync(gitignore, `${ignoreLine}\n`);
+  }
+
+  const pkg = getPackageInfo();
+
+  logger.info("");
+  logger.info(`${GREEN}✓ Configuração concluída!${NC}`);
+  logger.info(
+    `${BOLD}${CYAN}  versão: ${pkg.name} v${pkg.version}${NC}`,
+  );
+  logger.info(`${DIM}  origem: ${pkg.root}${NC}`);
+  logger.info(`${DIM}Pasta criada: ${ideDir}${NC}`);
+  logger.info("");
+
+  const all = discoverAll();
+
+  logger.info(
+    `${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`,
+  );
+  logger.info(`${CYAN}  🏁 PRÓXIMO PASSO${NC}`);
+  logger.info(
+    `${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`,
+  );
+  logger.info("");
+
+  if (ide === "codex") {
+    logger.info(`  No ${GREEN}Codex${NC}, skills não usam slash commands.`);
+    logger.info(`  Para invocar um skill, use linguagem natural:`);
+    logger.info(`  ${DIM}  "use o skill init-jarvis para configurar o projeto"${NC}`);
+    logger.info(`  ${DIM}  "execute o warm-up do Jarvis"${NC}`);
+    logger.info("");
+    logger.info(`  Skills disponíveis em ${YELLOW}.codex/skills/${NC}`);
+    logger.info(`  Cada pasta é um skill — veja o SKILL.md para a descrição.`);
+    logger.info("");
+    logger.info(`  Para configurar as variáveis do projeto, peça ao Codex:`);
+    logger.info(`  ${GREEN}"execute o skill init-jarvis"${NC}`);
+  } else if (ide === "kiro") {
+    logger.info(`  No ${GREEN}Kiro${NC}, skills e workflows são steering files.`);
+    logger.info(`  Para invocar um skill, use ${GREEN}#skill-{nome}${NC} no chat:`);
+    logger.info(`  ${DIM}  #skill-init-jarvis${NC}`);
+    logger.info(`  ${DIM}  #skill-eng-backend${NC}`);
+    logger.info("");
+    logger.info(`  Steering files gerados em ${YELLOW}.kiro/steering/${NC}`);
+    logger.info(`  • ${DIM}steering/*.md${NC}       — workflows (inclusion: manual)`);
+    logger.info(`  • ${DIM}steering/*.md${NC}       — rules (inclusion: auto)`);
+    logger.info(`  • ${DIM}steering/skills/*.md${NC} — skills (inclusion: manual)`);
+    logger.info("");
+    logger.info(`  Para configurar as variáveis do projeto, ative:`);
+    logger.info(`  ${GREEN}#skill-init-jarvis${NC} no chat do Kiro`);
+  } else {
+    logger.info(`  Execute o comando ${GREEN}/init-jarvis${NC} na sua IDE para`);
+    logger.info(`  configurar as variáveis de ambiente do projeto.`);
+  }
+
+  logger.info("");
+  logger.info(
+    `${DIM}  Isso irá criar o arquivo ENV.md com as configurações${NC}`,
+  );
+  logger.info(`${DIM}  necessárias para o funcionamento do JARVIS.${NC}`);
+  logger.info("");
+  logger.info(
+    `${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`,
+  );
+  logger.info("");
+  logger.info(`${GREEN}✓ Instalação completa! 🎉${NC}`);
+  logger.info("");
+  logger.info(`${BLUE}📁 Estrutura criada:${NC}`);
+  logger.info(`  • ${YELLOW}.${getIDEFolder(ide)}/${NC} - Configuração da IDE`);
+  logger.info(`  • ${GREEN}${all.agents.length}${NC} agents`);
+  logger.info(`  • ${GREEN}${all.skills.length}${NC} skills`);
+  logger.info(`  • ${GREEN}${all.workflows.length}${NC} workflows`);
+  logger.info("");
+  logger.info(`${BLUE}📖 Para ver todos os prompts disponíveis:${NC}`);
+  logger.info(`     ${YELLOW}jarvis list${NC}`);
+  logger.info("");
+
+}

package/bin/commands/install-rtk.js

@@ -0,0 +1,90 @@
+import { execSync } from "node:child_process";
+import { logger, configureFromFlags } from "../lib/utils/logger.js";
+import { GREEN, RED, YELLOW, DIM, NC } from "../lib/utils/ui.js";
+
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd} 2>/dev/null`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function installRtk(flags) {
+  configureFromFlags(flags);
+
+  logger.info("");
+  logger.info(`${GREEN}🦀 RTK — Rust Token Killer${NC}`);
+  logger.info(`${DIM}   Proxy CLI que economiza 60-90% de tokens em outputs de shell${NC}`);
+  logger.info("");
+
+  // 1. Verificar se RTK já está instalado
+  if (commandExists("rtk")) {
+    try {
+      const version = execSync("rtk --version", { encoding: "utf-8" }).trim();
+      logger.info(`${GREEN}✓ RTK já instalado: ${version}${NC}`);
+      logger.info(`${DIM}  Para atualizar: cargo install rtk --force${NC}`);
+      logger.info("");
+      return;
+    } catch {}
+  }
+
+  // 2. Verificar se cargo está disponível
+  if (!commandExists("cargo")) {
+    logger.info(`${YELLOW}⚠ cargo não encontrado — instalando Rust via rustup...${NC}`);
+    logger.info("");
+    try {
+      execSync('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y', {
+        stdio: "inherit",
+        shell: true,
+      });
+      // Atualizar PATH para a sessão atual
+      const home = process.env.HOME || process.env.USERPROFILE;
+      process.env.PATH = `${home}/.cargo/bin:${process.env.PATH}`;
+    } catch (err) {
+      logger.error(`${RED}✗ Falha ao instalar Rust: ${err.message}${NC}`);
+      logger.info(`${DIM}  Instale manualmente: https://rustup.rs${NC}`);
+      logger.info("");
+      process.exit(1);
+    }
+
+    if (!commandExists("cargo")) {
+      logger.error(`${RED}✗ cargo não encontrado após instalação do Rust${NC}`);
+      logger.info(`${DIM}  Reinicie o terminal e tente novamente: jarvis install-rtk${NC}`);
+      logger.info("");
+      process.exit(1);
+    }
+
+    logger.info(`${GREEN}✓ Rust instalado${NC}`);
+    logger.info("");
+  }
+
+  // 3. Instalar RTK via cargo
+  logger.info(`${YELLOW}⏳ Instalando RTK via cargo (pode levar alguns minutos)...${NC}`);
+  logger.info("");
+  try {
+    execSync("cargo install rtk", { stdio: "inherit" });
+  } catch (err) {
+    logger.error(`${RED}✗ Falha ao instalar RTK: ${err.message}${NC}`);
+    logger.info("");
+    process.exit(1);
+  }
+
+  // 4. Verificar instalação
+  if (commandExists("rtk")) {
+    const version = execSync("rtk --version", { encoding: "utf-8" }).trim();
+    logger.info("");
+    logger.info(`${GREEN}✓ RTK instalado com sucesso: ${version}${NC}`);
+    logger.info("");
+    logger.info(`${YELLOW}Próximo passo:${NC}`);
+    logger.info(`  Execute ${GREEN}jarvis init${NC} (ou atualize o ENV.md) para ativar ${GREEN}RTK_ENABLED=true${NC}`);
+    logger.info(`  A rule de economia de tokens será ativada automaticamente.`);
+    logger.info("");
+  } else {
+    logger.error(`${RED}✗ RTK não encontrado no PATH após instalação${NC}`);
+    logger.info(`${DIM}  Reinicie o terminal e verifique: rtk --version${NC}`);
+    logger.info("");
+    process.exit(1);
+  }
+}

package/bin/commands/list.js

@@ -0,0 +1,48 @@
+import { discoverAll } from "../lib/core/scanner.js";
+import {
+  showBanner,
+  GREEN,
+  BLUE,
+  YELLOW,
+  CYAN,
+  DIM,
+  NC,
+} from "../lib/utils/ui.js";
+import { logger } from "../lib/utils/logger.js";
+
+export async function list(flags) {
+  const all = discoverAll();
+  const filter = flags.type || flags._?.[0];
+
+  showBanner();
+
+  logger.info(`${CYAN}📋 Prompts Disponíveis${NC}`);
+  logger.info("");
+
+  function printSection(title, items, emoji) {
+    if (items.length === 0) return;
+    logger.info(`${YELLOW}${emoji} ${title}${NC} ${DIM}(${items.length})${NC}`);
+    logger.info(`${DIM}${"─".repeat(80)}${NC}`);
+    for (const item of items) {
+      const desc =
+        item.description.length > 45
+          ? item.description.slice(0, 45) + "..."
+          : item.description;
+      logger.info(`  ${GREEN}${item.id.padEnd(30)}${NC} ${DIM}${desc}${NC}`);
+    }
+    logger.info("");
+  }
+
+  if (!filter || filter === "agent")
+    printSection("AGENTS", all.agents, "🤖");
+  if (!filter || filter === "skill")
+    printSection("SKILLS", all.skills, "⚡");
+  if (!filter || filter === "workflow")
+    printSection("WORKFLOWS", all.workflows, "🔄");
+
+  const total = all.agents.length + all.skills.length + all.workflows.length;
+  logger.info(`${BLUE}📦 Total: ${GREEN}${total}${BLUE} prompts disponíveis${NC}`);
+  logger.info("");
+  logger.info(`${DIM}Use: ${YELLOW}jarvis info <type/name>${DIM} para ver detalhes${NC}`);
+  logger.info("");
+}