@lugom.io/hefesto 0.3.0 → 1.0.0

package/bin/install.js

@@ -20,14 +20,19 @@ const red = '\x1b[31m';
 const dim = '\x1b[2m';
 const reset = '\x1b[0m';
 
-const banner = '\n' +
-  red + '  ██╗  ██╗███████╗███████╗███████╗███████╗████████╗ ██████╗\n' +
+const banner =
+  '\n' +
+  red +
+  '  ██╗  ██╗███████╗███████╗███████╗███████╗████████╗ ██████╗\n' +
   '  ██║  ██║██╔════╝██╔════╝██╔════╝██╔════╝╚══██╔══╝██╔═══██╗\n' +
   '  ███████║█████╗  █████╗  █████╗  ███████╗   ██║   ██║   ██║\n' +
   '  ██╔══██║██╔══╝  ██╔══╝  ██╔══╝  ╚════██║   ██║   ██║   ██║\n' +
   '  ██║  ██║███████╗██║     ███████╗███████║   ██║   ╚██████╔╝\n' +
-  '  ╚═╝  ╚═╝╚══════╝╚═╝     ╚══════╝╚══════╝   ╚═╝    ╚═════╝\n' + reset +
-  dim + '  Toolkit spec-driven + story-driven para agentes AI\n' + reset;
+  '  ╚═╝  ╚═╝╚══════╝╚═╝     ╚══════╝╚══════╝   ╚═╝    ╚═════╝\n' +
+  reset +
+  dim +
+  '  Toolkit spec-driven + story-driven para agentes AI\n' +
+  reset;
 
 // ── CLI Args ────────────────────────────────────────────────────────────────
 
@@ -41,6 +46,25 @@ const hasGemini = args.includes('--gemini');
 const hasCodex = args.includes('--codex');
 const hasAll = args.includes('--all');
 
+const knownArgs = new Set([
+  '--global',
+  '-g',
+  '--uninstall',
+  '-u',
+  '--help',
+  '-h',
+  '--claude',
+  '--gemini',
+  '--codex',
+  '--all',
+]);
+const unknownArgs = args.filter((a) => a.startsWith('-') && !knownArgs.has(a));
+if (unknownArgs.length > 0) {
+  console.warn(
+    `⚠ Opção desconhecida: ${unknownArgs.join(', ')}. Use --help para ver opções válidas.`
+  );
+}
+
 // ── Help ────────────────────────────────────────────────────────────────────
 
 if (hasHelp) {
@@ -144,14 +168,12 @@ function removeIfExists(targetPath) {
 // ── Default Config ──────────────────────────────────────────────────────────
 
 function createDefaultConfig() {
-  return {
-    version: '0.1.0',
-    project: { name: '', language: 'pt-BR' },
-    runtime: 'claude',
-    feature: { id_prefix: 'FEAT', counter: 0 },
-    research: { id_prefix: 'RES', counter: 0 },
-    lifecycle: { auto_update_state: true },
-  };
+  const templatePath = path.join(PKG_ROOT, 'templates', 'TPL-CONFIG.json');
+  const template = JSON.parse(fs.readFileSync(templatePath, 'utf8'));
+  const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
+  // --all: getSelectedRuntimes()[0] é 'claude' (runtime primário).
+  // Config armazena apenas o primário; todos os runtimes recebem os arquivos instalados.
+  return { ...template, version: pkg.version, runtime: getSelectedRuntimes()[0] || 'claude' };
 }
 
 // ── Install ─────────────────────────────────────────────────────────────────
@@ -172,12 +194,15 @@ function installHefesto() {
     ensureDir(path.join(hefestoDir, 'research'));
 
     // Copiar templates como arquivos iniciais do projeto
-    const templateFiles = ['PROJECT.md', 'STATE.md', 'ROADMAP.md'];
-    for (const file of templateFiles) {
-      const src = path.join(templatesDir, file);
-      const dest = path.join(hefestoDir, file);
-      if (fs.existsSync(src)) {
-        fs.copyFileSync(src, dest);
+    const templateFiles = [
+      { src: 'TPL-PROJECT.md', dest: 'PROJECT.md' },
+      { src: 'TPL-STATE.md', dest: 'STATE.md' },
+    ];
+    for (const { src, dest } of templateFiles) {
+      const srcPath = path.join(templatesDir, src);
+      const destPath = path.join(hefestoDir, dest);
+      if (fs.existsSync(srcPath)) {
+        fs.copyFileSync(srcPath, destPath);
       }
     }
 
@@ -187,7 +212,7 @@ function installHefesto() {
     // Criar config.json
     fs.writeFileSync(
       path.join(hefestoDir, 'config.json'),
-      JSON.stringify(createDefaultConfig(), null, 2) + '\n',
+      JSON.stringify(createDefaultConfig(), null, 2) + '\n'
     );
 
     console.log(`  ✅ .hefesto/ criado com scaffold do projeto.`);
@@ -210,9 +235,11 @@ function installRuntime(runtime) {
   // Skills
   const srcSkills = path.join(PKG_ROOT, 'skills');
   if (fs.existsSync(srcSkills)) {
-    const destSkills = getSkillsDestDir(runtime, runtimeDir);
+    const destSkills = getSkillsDestDir(runtimeDir);
     copySkills(srcSkills, destSkills);
-    console.log(`  ✅ Skills instaladas em ${path.relative(process.cwd(), destSkills) || destSkills}`);
+    console.log(
+      `  ✅ Skills instaladas em ${path.relative(process.cwd(), destSkills) || destSkills}`
+    );
   }
 
   // Agents
@@ -220,18 +247,17 @@ function installRuntime(runtime) {
   if (fs.existsSync(srcAgents)) {
     const destAgents = path.join(runtimeDir, 'agents');
     copyAgents(srcAgents, destAgents);
-    console.log(`  ✅ Agents instalados em ${path.relative(process.cwd(), destAgents) || destAgents}`);
-  }
-
-  // Agent memory directories (apenas Claude Code)
-  if (runtime === 'claude') {
-    installAgentMemory(runtimeDir);
+    console.log(
+      `  ✅ Agents instalados em ${path.relative(process.cwd(), destAgents) || destAgents}`
+    );
   }
 
   // Cleanup: remove legacy commands (migrated to skills)
   const legacyCmds = path.join(runtimeDir, 'commands', 'hefesto');
   if (removeIfExists(legacyCmds)) {
-    console.log(`  ♻️  Commands legados removidos de ${path.relative(process.cwd(), legacyCmds) || legacyCmds}`);
+    console.log(
+      `  ♻️  Commands legados removidos de ${path.relative(process.cwd(), legacyCmds) || legacyCmds}`
+    );
     const cmdsParent = path.join(runtimeDir, 'commands');
     if (fs.existsSync(cmdsParent) && fs.readdirSync(cmdsParent).length === 0) {
       fs.rmSync(cmdsParent, { recursive: true });
@@ -244,7 +270,7 @@ function installRuntime(runtime) {
   }
 }
 
-function getSkillsDestDir(_runtime, runtimeDir) {
+function getSkillsDestDir(runtimeDir) {
   // Claude: .claude/skills/
   // Gemini: .gemini/skills/
   // Codex: .codex/skills/
@@ -279,18 +305,6 @@ function copyAgents(srcDir, destDir) {
   }
 }
 
-// ── Agent Memory ─────────────────────────────────────────────────────────────
-
-function installAgentMemory(runtimeDir) {
-  const agentMemoryDir = path.join(runtimeDir, 'agent-memory');
-  const agentNames = ['hefesto-athena', 'hefesto-argos'];
-
-  for (const name of agentNames) {
-    ensureDir(path.join(agentMemoryDir, name));
-  }
-  console.log(`  ✅ Agent memory criado em ${path.relative(process.cwd(), agentMemoryDir) || agentMemoryDir}`);
-}
-
 // ── Hooks ───────────────────────────────────────────────────────────────────
 
 function installHooks(runtimeDir) {
@@ -299,7 +313,11 @@ function installHooks(runtimeDir) {
 
   // Copiar hooks
   ensureDir(destHooks);
-  for (const file of ['hefesto-statusline.cjs', 'hefesto-check-update.cjs']) {
+  for (const file of [
+    'hefesto-statusline.cjs',
+    'hefesto-check-update.cjs',
+    'hefesto-workflow.cjs',
+  ]) {
     const src = path.join(srcHooks, file);
     if (fs.existsSync(src)) {
       fs.copyFileSync(src, path.join(destHooks, file));
@@ -332,15 +350,35 @@ function installHooks(runtimeDir) {
 
   // Remover hook hefesto anterior se existir
   settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
-    h => !JSON.stringify(h).includes('hefesto-check-update'),
+    (h) => !JSON.stringify(h).includes('hefesto-check-update')
   );
 
   settings.hooks.SessionStart.push({
     matcher: 'startup',
-    hooks: [{
-      type: 'command',
-      command: checkUpdateCmd,
-    }],
+    hooks: [
+      {
+        type: 'command',
+        command: checkUpdateCmd,
+      },
+    ],
+  });
+
+  // PreToolUse hook (workflow enforcement)
+  if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+
+  // Remover hook hefesto-workflow anterior se existir
+  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+    (h) => !JSON.stringify(h).includes('hefesto-workflow')
+  );
+
+  settings.hooks.PreToolUse.push({
+    matcher: 'Write|Edit',
+    hooks: [
+      {
+        type: 'command',
+        command: `node "${hooksDir}/hefesto-workflow.cjs"`,
+      },
+    ],
   });
 
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
@@ -350,7 +388,11 @@ function installHooks(runtimeDir) {
 function uninstallHooks(runtimeDir) {
   // Remover arquivos de hooks
   const hooksDir = path.join(runtimeDir, 'hooks');
-  for (const file of ['hefesto-statusline.cjs', 'hefesto-check-update.cjs']) {
+  for (const file of [
+    'hefesto-statusline.cjs',
+    'hefesto-check-update.cjs',
+    'hefesto-workflow.cjs',
+  ]) {
     const hookPath = path.join(hooksDir, file);
     if (fs.existsSync(hookPath)) {
       fs.unlinkSync(hookPath);
@@ -372,13 +414,23 @@ function uninstallHooks(runtimeDir) {
     // Remover hook de SessionStart do hefesto
     if (settings.hooks?.SessionStart) {
       settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
-        h => !JSON.stringify(h).includes('hefesto-check-update'),
+        (h) => !JSON.stringify(h).includes('hefesto-check-update')
       );
       if (settings.hooks.SessionStart.length === 0) {
         delete settings.hooks.SessionStart;
       }
     }
 
+    // Remover hook de PreToolUse do hefesto
+    if (settings.hooks?.PreToolUse) {
+      settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+        (h) => !JSON.stringify(h).includes('hefesto-workflow')
+      );
+      if (settings.hooks.PreToolUse.length === 0) {
+        delete settings.hooks.PreToolUse;
+      }
+    }
+
     // Limpar hooks vazio
     if (settings.hooks && Object.keys(settings.hooks).length === 0) {
       delete settings.hooks;
@@ -418,7 +470,9 @@ function uninstallRuntime(runtime) {
   // Remover legacy commands/hefesto/ (se existir de versão anterior)
   const commandsDir = path.join(runtimeDir, 'commands', 'hefesto');
   if (removeIfExists(commandsDir)) {
-    console.log(`  ✅ Commands legados removidos de ${path.relative(process.cwd(), commandsDir) || commandsDir}`);
+    console.log(
+      `  ✅ Commands legados removidos de ${path.relative(process.cwd(), commandsDir) || commandsDir}`
+    );
     const cmdsParent = path.join(runtimeDir, 'commands');
     if (fs.existsSync(cmdsParent) && fs.readdirSync(cmdsParent).length === 0) {
       fs.rmSync(cmdsParent, { recursive: true });
@@ -426,7 +480,7 @@ function uninstallRuntime(runtime) {
   }
 
   // Remover skills hefesto-*
-  const skillsDir = getSkillsDestDir(runtime, runtimeDir);
+  const skillsDir = getSkillsDestDir(runtimeDir);
   if (fs.existsSync(skillsDir)) {
     const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
@@ -454,24 +508,6 @@ function uninstallRuntime(runtime) {
     }
   }
 
-  // Remover agent-memory hefesto-* (apenas Claude Code)
-  if (runtime === 'claude') {
-    const agentMemoryDir = path.join(runtimeDir, 'agent-memory');
-    if (fs.existsSync(agentMemoryDir)) {
-      const memEntries = fs.readdirSync(agentMemoryDir, { withFileTypes: true });
-      for (const entry of memEntries) {
-        if (entry.isDirectory() && entry.name.startsWith('hefesto-')) {
-          fs.rmSync(path.join(agentMemoryDir, entry.name), { recursive: true });
-          console.log(`  ✅ Agent memory ${entry.name} removido.`);
-        }
-      }
-      // Remove agent-memory/ se vazio
-      if (fs.readdirSync(agentMemoryDir).length === 0) {
-        fs.rmSync(agentMemoryDir, { recursive: true });
-      }
-    }
-  }
-
   // Remover hooks (apenas Claude Code)
   if (runtime === 'claude') {
     uninstallHooks(runtimeDir);

package/hooks/hefesto-check-update.cjs

@@ -7,6 +7,10 @@ const path = require('path');
 const os = require('os');
 const { spawn } = require('child_process');
 
+// Drain stdin (hook runner pode enviar dados)
+process.stdin.resume();
+process.stdin.on('data', () => {});
+
 const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 const cacheDir = path.join(configDir, 'cache');
 const cacheFile = path.join(cacheDir, 'hefesto-update-check.json');
@@ -17,44 +21,61 @@ if (!fs.existsSync(cacheDir)) {
 }
 
 // Rodar check em background (não bloqueia a sessão)
-const child = spawn(process.execPath, ['-e', `
+const child = spawn(
+  process.execPath,
+  [
+    '-e',
+    `
   const fs = require('fs');
   const { execSync } = require('child_process');
   const cacheFile = ${JSON.stringify(cacheFile)};
 
   let installed = '0.0.0';
   try {
-    const pkg = JSON.parse(execSync('npm ls hefesto --json 2>/dev/null', {
+    const pkg = JSON.parse(execSync('npm ls @lugom.io/hefesto --json 2>/dev/null', {
       encoding: 'utf8', timeout: 10000, windowsHide: true
     }));
-    installed = pkg.dependencies?.hefesto?.version || '0.0.0';
+    installed = pkg.dependencies?.['@lugom.io/hefesto']?.version || '0.0.0';
   } catch (_) {
     // Se não conseguir detectar versão instalada, tentar package.json local
     try {
-      const localPkg = JSON.parse(fs.readFileSync('node_modules/hefesto/package.json', 'utf8'));
+      const localPkg = JSON.parse(fs.readFileSync('node_modules/@lugom.io/hefesto/package.json', 'utf8'));
       installed = localPkg.version || '0.0.0';
     } catch (_) {}
   }
 
   let latest = null;
   try {
-    latest = execSync('npm view hefesto version', {
+    latest = execSync('npm view @lugom.io/hefesto version', {
       encoding: 'utf8', timeout: 10000, windowsHide: true
     }).trim();
   } catch (_) {}
 
+  function semverLt(a, b) {
+    const pa = a.split('.').map(s => parseInt(s, 10) || 0);
+    const pb = b.split('.').map(s => parseInt(s, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+      if ((pa[i] || 0) < (pb[i] || 0)) return true;
+      if ((pa[i] || 0) > (pb[i] || 0)) return false;
+    }
+    return false;
+  }
+
   const result = {
-    update_available: latest && installed !== latest && latest !== '0.0.0',
+    update_available: latest && latest !== '0.0.0' && installed !== latest && semverLt(installed, latest),
     installed,
     latest: latest || 'unknown',
     checked: Math.floor(Date.now() / 1000),
   };
 
   fs.writeFileSync(cacheFile, JSON.stringify(result));
-`], {
-  stdio: 'ignore',
-  windowsHide: true,
-  detached: true,
-});
+`,
+  ],
+  {
+    stdio: 'ignore',
+    windowsHide: true,
+    detached: true,
+  }
+);
 
 child.unref();

package/hooks/hefesto-statusline.cjs

@@ -9,36 +9,25 @@ const os = require('os');
 let input = '';
 const stdinTimeout = setTimeout(() => process.exit(0), 3000);
 process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('data', (chunk) => (input += chunk));
 process.stdin.on('end', () => {
   clearTimeout(stdinTimeout);
   try {
     const data = JSON.parse(input);
     const model = data.model?.display_name || 'Claude';
     const dir = data.workspace?.current_dir || process.cwd();
-    const session = data.session_id || '';
     const remaining = data.context_window?.remaining_percentage;
 
     // Context window (normalizado para contexto utilizável)
     const AUTO_COMPACT_BUFFER_PCT = 16.5;
     let ctx = '';
     if (remaining != null) {
-      const usableRemaining = Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100);
+      const usableRemaining = Math.max(
+        0,
+        ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100
+      );
       const used = Math.max(0, Math.min(100, Math.round(100 - usableRemaining)));
 
-      // Bridge file para o context-monitor
-      if (session) {
-        try {
-          const bridgePath = path.join(os.tmpdir(), `hefesto-ctx-${session}.json`);
-          fs.writeFileSync(bridgePath, JSON.stringify({
-            session_id: session,
-            remaining_percentage: remaining,
-            used_pct: used,
-            timestamp: Math.floor(Date.now() / 1000),
-          }));
-        } catch (_) {}
-      }
-
       // Barra de progresso (10 segmentos)
       const filled = Math.floor(used / 10);
       const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
@@ -68,7 +57,9 @@ process.stdin.on('end', () => {
     }
 
     const dirname = path.basename(dir);
-    process.stdout.write(`${updateMsg}\x1b[1;31m⚒ HEFESTO\x1b[0m │ \x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    process.stdout.write(
+      `${updateMsg}\x1b[1;31m⚒ HEFESTO\x1b[0m │ \x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`
+    );
   } catch (_) {
     // Falha silenciosa
   }

package/hooks/hefesto-workflow.cjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// Hefesto Workflow Enforcement
+// PreToolUse hook: avisa quando Write/Edit é usado sem feature ativa
+// Comportamento: WARN only, nunca BLOCK — Hefesto guia, não bloqueia
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+let input = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => (input += chunk));
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const toolName = data.tool_name;
+    const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
+
+    // Só verificar Write e Edit
+    if (toolName !== 'Write' && toolName !== 'Edit') return;
+
+    // Se não tem file_path, não tem como verificar
+    if (!filePath) return;
+
+    const basename = path.basename(filePath);
+    const normalized = filePath.replace(/\\/g, '/');
+
+    // Escape hatches — sempre permitir:
+    // .hefesto/ (state files do próprio Hefesto)
+    if (normalized.includes('.hefesto/')) return;
+    // Configs de runtime (.claude/, .gemini/, .codex/)
+    if (
+      normalized.includes('.claude/') ||
+      normalized.includes('.gemini/') ||
+      normalized.includes('.codex/')
+    )
+      return;
+    // Testes (test, spec, __tests__)
+    if (/test|spec|__tests__/i.test(normalized)) return;
+    // Dotfiles e package.json
+    if (basename.startsWith('.') || basename === 'package.json' || basename === 'package-lock.json')
+      return;
+    // Markdown docs
+    if (basename.endsWith('.md')) return;
+
+    // Verificar se .hefesto/STATE.md existe
+    const statePath = path.join(process.cwd(), '.hefesto', 'STATE.md');
+    if (!fs.existsSync(statePath)) return;
+
+    // Ler STATE.md e checar se tem feature ativa
+    const state = fs.readFileSync(statePath, 'utf8');
+    const featureSection = state.match(/## Feature Ativa\s*\n([\s\S]*?)(?=\n## |\n---|$)/);
+
+    if (!featureSection) return;
+
+    const content = featureSection[1].trim();
+    if (content && content !== 'Nenhuma.' && content !== 'Nenhuma') return;
+
+    // Sem feature ativa — emitir warning via stderr
+    process.stderr.write(
+      '\n⚒ HEFESTO: Nenhuma feature ativa. Considere usar /hefesto-new-feature antes de implementar.\n'
+    );
+  } catch (_) {
+    // Silent failure — nunca quebrar o runtime
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lugom.io/hefesto",
-  "version": "0.3.0",
+  "version": "1.0.0",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code, Gemini and Codex by lugom.io.",
   "type": "module",
   "bin": {
@@ -8,6 +8,10 @@
   },
   "scripts": {
     "test": "node --test tests/**/*.test.js",
+    "lint": "eslint bin/ hooks/ tests/",
+    "lint:fix": "eslint bin/ hooks/ tests/ --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
     "sandbox": "HEFESTO=$PWD && mkdir -p $HEFESTO/tmp/hefesto-sandbox/src && cd $HEFESTO/tmp/hefesto-sandbox && test -f package.json || echo '{\"name\":\"sandbox\",\"type\":\"module\"}' > package.json && node $HEFESTO/bin/install.js && claude"
   },
   "engines": {
@@ -33,5 +37,11 @@
     "codex-cli"
   ],
   "author": "lugom.io",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.1.0",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.1"
+  }
 }