ganbatte-os 0.2.1

package/scripts/hooks/pre-commit-validate.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+/**
+ * pre-commit-validate.js
+ *
+ * Validacao pre-commit: roda tsc --noEmit e testes antes do commit.
+ * Zero-dependency. Usa execFileSync para seguranca (sem shell injection).
+ *
+ * Uso:
+ *   node scripts/hooks/pre-commit-validate.js [--json] [--skip-tests] [--skip-tsc]
+ *
+ * Exit codes:
+ *   0 — todos os checks passaram
+ *   1 — um ou mais checks falharam
+ */
+
+const { execFileSync } = require('child_process');
+const { existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+
+// ---------------------------------------------------------------------------
+// Flags
+// ---------------------------------------------------------------------------
+const args = process.argv.slice(2);
+const jsonOutput = args.includes('--json');
+const skipTests = args.includes('--skip-tests');
+const skipTsc = args.includes('--skip-tsc');
+
+// ---------------------------------------------------------------------------
+// Detectar diretorio do projeto
+// ---------------------------------------------------------------------------
+// Se chamado de dentro de um workspace, usar cwd.
+// Se chamado via scripts/hooks/, subir ate a raiz do projeto.
+function findProjectRoot() {
+  let dir = process.cwd();
+  // Procurar package.json subindo no maximo 5 niveis
+  for (let i = 0; i < 5; i++) {
+    if (existsSync(join(dir, 'package.json'))) return dir;
+    const parent = join(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+
+const PROJECT_ROOT = findProjectRoot();
+
+// ---------------------------------------------------------------------------
+// Detectar package manager
+// ---------------------------------------------------------------------------
+function detectPackageManager() {
+  if (existsSync(join(PROJECT_ROOT, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (existsSync(join(PROJECT_ROOT, 'bun.lockb')) || existsSync(join(PROJECT_ROOT, 'bun.lock'))) return 'bun';
+  if (existsSync(join(PROJECT_ROOT, 'yarn.lock'))) return 'yarn';
+  return 'npm';
+}
+
+// ---------------------------------------------------------------------------
+// Ler package.json
+// ---------------------------------------------------------------------------
+function readPkg() {
+  const pkgPath = join(PROJECT_ROOT, 'package.json');
+  if (!existsSync(pkgPath)) return {};
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Rodar comando com execFileSync
+// ---------------------------------------------------------------------------
+function runCheck(name, cmd, cmdArgs, opts = {}) {
+  const start = Date.now();
+  try {
+    const output = execFileSync(cmd, cmdArgs, {
+      cwd: PROJECT_ROOT,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 300_000, // 5 min max
+      ...opts
+    });
+    return {
+      name,
+      status: 'pass',
+      output: output.trim().slice(0, 2000),
+      duration: Date.now() - start
+    };
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString().trim() : '';
+    const stdout = err.stdout ? err.stdout.toString().trim() : '';
+    return {
+      name,
+      status: 'fail',
+      output: (stderr || stdout || err.message).slice(0, 4000),
+      duration: Date.now() - start
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Detectar script de teste disponivel
+// ---------------------------------------------------------------------------
+function detectTestScript(pkg) {
+  const scripts = pkg.scripts || {};
+  // Prioridade: test:run (vitest --run) > test:e2e > test
+  if (scripts['test:run']) return 'test:run';
+  if (scripts['test:e2e']) return 'test:e2e';
+  if (scripts['test']) {
+    // Se o script test e apenas "vitest" (sem --run), adicionar --run
+    // para evitar watch mode
+    return 'test';
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function main() {
+  const pm = detectPackageManager();
+  const pkg = readPkg();
+  const checks = [];
+
+  // Check 1: TypeScript (tsc --noEmit)
+  if (!skipTsc) {
+    const hasTsConfig = existsSync(join(PROJECT_ROOT, 'tsconfig.json'));
+    if (hasTsConfig) {
+      // Tentar usar npx para garantir que tsc esta disponivel
+      const check = runCheck('tsc --noEmit', 'npx', ['tsc', '--noEmit']);
+      checks.push(check);
+    } else {
+      checks.push({
+        name: 'tsc --noEmit',
+        status: 'skip',
+        output: 'tsconfig.json nao encontrado',
+        duration: 0
+      });
+    }
+  }
+
+  // Check 2: Testes
+  if (!skipTests) {
+    const testScript = detectTestScript(pkg);
+    if (testScript) {
+      // Construir comando: <pm> run <script> -- --run (para vitest)
+      const cmdArgs = ['run', testScript];
+
+      // Se o script e "test" e usa vitest, adicionar --run para evitar watch
+      const scriptCmd = (pkg.scripts || {})[testScript] || '';
+      if (scriptCmd.includes('vitest') && !scriptCmd.includes('--run')) {
+        cmdArgs.push('--', '--run');
+      }
+
+      const check = runCheck(`${pm} run ${testScript}`, pm, cmdArgs);
+      checks.push(check);
+    } else {
+      checks.push({
+        name: 'tests',
+        status: 'skip',
+        output: 'Nenhum script de teste encontrado no package.json',
+        duration: 0
+      });
+    }
+  }
+
+  // Resultado
+  const passed = checks.every(c => c.status === 'pass' || c.status === 'skip');
+  const result = {
+    passed,
+    packageManager: pm,
+    projectRoot: PROJECT_ROOT,
+    checks,
+    timestamp: new Date().toISOString()
+  };
+
+  if (jsonOutput) {
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  } else {
+    // Output legivel
+    const icon = passed ? '\u2705' : '\u274C';
+    console.log(`\n${icon} Pre-Commit Validation\n`);
+    for (const c of checks) {
+      const statusIcon = c.status === 'pass' ? '\u2705' : c.status === 'skip' ? '\u23ED' : '\u274C';
+      console.log(`  ${statusIcon} ${c.name} (${c.duration}ms)`);
+      if (c.status === 'fail') {
+        // Mostrar primeiras linhas do output de erro
+        const lines = c.output.split('\n').slice(0, 15);
+        for (const line of lines) {
+          console.log(`     ${line}`);
+        }
+      }
+    }
+    console.log(`\n${passed ? 'Todos os checks passaram.' : 'Checks falharam. Corrija os erros antes do commit.'}\n`);
+  }
+
+  process.exit(passed ? 0 : 1);
+}
+
+main();

package/scripts/integrations/check-ide-compat.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const root = process.cwd();
+const required = [
+  'AGENTS.md',
+  'CLAUDE.md',
+  'GEMINI.md',
+  'prompts/01-search.md',
+  'prompts/02-spec.md',
+  'prompts/03-tasks.md',
+  'prompts/04-code.md',
+  'prompts/05-reviews.md',
+  'integrations/registry.json',
+  'integrations/claude/command-map.json',
+  'integrations/codex/command-map.json',
+  'integrations/opencode/command-map.json',
+  'integrations/antigravity/command-map.json',
+  'integrations/gemini/command-map.json',
+  'integrations/cursor/command-map.json',
+  'integrations/kilo-code/command-map.json',
+  '.claude/commands/gos/agents/dev.md',
+  '.claude/commands/gos/skills/design-to-code.md',
+  '.codex/skills/gos-design-to-code.md',
+  '.gemini/skills/gos-design-to-code/SKILL.md',
+  '.opencode/skills/gos-design-to-code/SKILL.md',
+  '.antigravity/instructions.md',
+  '.cursor/rules/g-os.mdc',
+  '.kilocode/rules/g-os.md'
+];
+
+const missing = required.filter((entry) => !fs.existsSync(path.join(root, entry)));
+
+if (missing.length > 0) {
+  console.error('Missing compatibility artifacts:');
+  for (const entry of missing) {
+    console.error(`- ${entry}`);
+  }
+  process.exit(1);
+}
+
+console.log('All IDE compatibility artifacts are present.');

package/scripts/integrations/setup-ide-adapters.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const root = process.cwd();
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function writeFile(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content.replace(/\r?\n/g, '\n') + '\n');
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function relativeTarget(fromFile, targetFile) {
+  return path.relative(path.dirname(fromFile), targetFile).replace(/\\/g, '/');
+}
+
+function agentWrapper(agentId, target) {
+  return `# ${agentId}\n\nFonte canonica: \`${target}\`\n\nLeia e siga o perfil em \`${target}\`.\nEste arquivo existe apenas como adapter fino para a IDE.`;
+}
+
+function skillWrapper(slug, target) {
+  return `# gos-${slug}\n\nFonte canonica: \`${target}\`\n\nLeia e siga a skill em \`${target}\`.\nEste arquivo existe apenas como adapter fino para a IDE.`;
+}
+
+function main() {
+  const agents = readJson(path.join(root, 'agents', 'profiles', 'index.json')).profiles;
+  const skills = readJson(path.join(root, 'skills', 'registry.json')).skills;
+
+  for (const agent of agents) {
+    const claudeFile = path.join(root, '.claude', 'commands', 'gos', 'agents', `${agent.id}.md`);
+    const target = relativeTarget(claudeFile, path.join(root, 'agents', 'profiles', agent.path));
+    writeFile(claudeFile, agentWrapper(agent.id, target));
+  }
+
+  for (const skill of skills) {
+    const skillTargetPath = skill.skillFile || skill.path;
+    const claudeSkill = path.join(root, '.claude', 'commands', 'gos', 'skills', `${skill.slug}.md`);
+    const codexSkill = path.join(root, '.codex', 'skills', `gos-${skill.slug}.md`);
+    const geminiSkill = path.join(root, '.gemini', 'skills', `gos-${skill.slug}`, 'SKILL.md');
+    const opencodeSkill = path.join(root, '.opencode', 'skills', `gos-${skill.slug}`, 'SKILL.md');
+
+    writeFile(claudeSkill, skillWrapper(skill.slug, relativeTarget(claudeSkill, path.join(root, skillTargetPath))));
+    writeFile(codexSkill, skillWrapper(skill.slug, relativeTarget(codexSkill, path.join(root, skillTargetPath))));
+    writeFile(geminiSkill, skillWrapper(skill.slug, relativeTarget(geminiSkill, path.join(root, skillTargetPath))));
+    writeFile(opencodeSkill, skillWrapper(skill.slug, relativeTarget(opencodeSkill, path.join(root, skillTargetPath))));
+  }
+
+  const antigravityInstructions = [
+    '# G-OS Antigravity Instructions',
+    '',
+    'Leia sempre:',
+    '- `AGENTS.md`',
+    '- `CLAUDE.md`',
+    '- `docs/toolchain-map.md`',
+    '',
+    'Agentes disponiveis:',
+    ...agents.map((agent) => `- ${agent.id}`),
+    '',
+    'Skills curadas:',
+    ...skills.map((skill) => `- ${skill.slug}`)
+  ].join('\n');
+
+  writeFile(path.join(root, '.antigravity', 'instructions.md'), antigravityInstructions);
+  writeFile(
+    path.join(root, '.antigravity', 'config.json'),
+    JSON.stringify(
+      {
+        project: 'g-os',
+        instructions: ['instructions.md', '../AGENTS.md', '../CLAUDE.md']
+      },
+      null,
+      2
+    )
+  );
+
+  console.log(`Adapters generated for ${agents.length} agents and ${skills.length} skills.`);
+}
+
+main();

package/scripts/tools/clickup-preprocess.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const ACCENT_FIXES = {
+  'nao': 'não', 'entao': 'então', 'tambem': 'também', 'codigo': 'código',
+  'pagina': 'página', 'unico': 'único', 'analise': 'análise', 'modulo': 'módulo',
+  'numero': 'número', 'especifico': 'específico', 'diretorio': 'diretório',
+  'padrao': 'padrão', 'configuracao': 'configuração', 'validacao': 'validação',
+  'implementacao': 'implementação', 'descricao': 'descrição', 'opcao': 'opção',
+  'sessao': 'sessão', 'secao': 'seção', 'funcao': 'função', 'acao': 'ação',
+  'informacao': 'informação', 'versao': 'versão', 'conexao': 'conexão',
+  'excecao': 'exceção', 'condicao': 'condição', 'operacao': 'operação',
+  'autenticacao': 'autenticação', 'migracao': 'migração', 'integracao': 'integração',
+}
+
+const AI_PATTERNS = [
+  /\bvale ressaltar\b/gi, /\be importante destacar\b/gi,
+  /\bnesse sentido\b/gi, /\bdiante disso\b/gi,
+  /\bem suma\b/gi, /\bpor fim\b/gi,
+  /\brobusto\b/gi, /\babrangente\b/gi,
+  /\binovador\b/gi, /\bestrategico\b/gi,
+  /\bholistic[oa]\b/gi, /\balem disso\b/gi,
+]
+
+function fixAccents(text) {
+  if (typeof text !== 'string' || !text) return text
+  let output = text
+  for (const [wrong, right] of Object.entries(ACCENT_FIXES)) {
+    output = output.replace(new RegExp(`\\b${wrong}\\b`, 'gi'), (match) => {
+      if (match === match.toUpperCase()) return right.toUpperCase()
+      if (match[0] === match[0].toUpperCase()) return right[0].toUpperCase() + right.slice(1)
+      return right
+    })
+  }
+  return output
+}
+
+function detectAIPatterns(text) {
+  if (!text) return { count: 0, matches: [] }
+  const haystack = Array.isArray(text) ? text.join('\n') : String(text)
+  const matches = []
+  let count = 0
+  for (const pattern of AI_PATTERNS) {
+    const found = haystack.match(pattern)
+    if (found) {
+      count += found.length
+      matches.push({ pattern: pattern.source, count: found.length })
+    }
+  }
+  return { count, matches }
+}
+
+function buildTaskDescription(task) {
+  const sections = []
+
+  // Descrição principal (texto livre, sem header)
+  if (task.description) sections.push(task.description)
+
+  // Seções estruturadas — headers H3, sem emojis, português com acentos
+  if (task.context) sections.push(`### Contexto\n${task.context}`)
+  if (task.steps?.length) sections.push(`### Como fazer\n${task.steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`)
+  if (task.businessRules?.length) sections.push(`### Regras de Negócio\n${task.businessRules.map((r) => `\`${r}\``).join(' · ')}`)
+  if (task.files?.length) sections.push(`### Arquivos\n${task.files.map((f) => `- \`${f}\``).join('\n')}`)
+  if (task.dependencies?.length) sections.push(`### Dependências\n${task.dependencies.map((d) => `- ${d}`).join('\n')}`)
+  if (task.acceptanceCriteria?.length) sections.push(`### Critérios de Aceite\n${task.acceptanceCriteria.map((a) => `- [ ] ${a}`).join('\n')}`)
+  if (task.ref) sections.push(`### Referência\n${task.ref}`)
+  if (task.technicalNotes) sections.push(`### Notas Técnicas\n${task.technicalNotes}`)
+  if (task.dod) sections.push(`### Definition of Done\n${task.dod}`)
+
+  // Primeira seção (descrição) separada das demais por ---
+  if (sections.length > 1) {
+    return sections[0] + '\n\n---\n\n' + sections.slice(1).join('\n\n')
+  }
+  return sections.join('\n\n')
+}
+
+
+function scoreCompleteness(task) {
+  let score = 0
+  const suggestions = []
+
+  if (task.description && task.description.length > 50) {
+    score += 20
+  } else if (task.description) {
+    score += 5
+    suggestions.push(`Descricao muito curta (${task.description.length} chars).`)
+  } else {
+    suggestions.push('Sem descricao.')
+  }
+
+  if (task.acceptanceCriteria?.length >= 2 && task.acceptanceCriteria.every((a) => a.length > 20)) {
+    score += 25
+  } else if (task.acceptanceCriteria?.length) {
+    score += 10
+    suggestions.push(`ACs insuficientes (${task.acceptanceCriteria.length} item(ns)).`)
+  } else {
+    suggestions.push('Sem criterios de aceite.')
+  }
+
+  if (task.steps?.length || task.subtasks?.length) score += 15
+  else suggestions.push('Sem steps de implementacao.')
+
+  if (task.files?.length) score += 10
+  else suggestions.push('Sem arquivos listados.')
+
+  if (task.points && task.points >= 1 && task.points <= 13) score += 10
+  else suggestions.push('Sem story points validos.')
+
+  if (task.dependencies?.length >= 0) score += 5
+
+  if (task.context || task.businessRules?.length) score += 10
+  else suggestions.push('Sem contexto de negocio.')
+
+  if (task.dod || task.acceptanceCriteria?.some((a) => /\b(dado|quando|entao|given|when|then)\b/i.test(a))) score += 5
+  else suggestions.push('Sem Definition of Done explicito.')
+
+  return { score, suggestions }
+}
+
+function sanitizeTaskTexts(task) {
+  const copy = { ...task }
+  let aiPatternCount = 0
+  const textFields = ['description', 'context', 'technicalNotes', 'dod', 'title', 'name', 'ref']
+  const arrayFields = ['acceptanceCriteria', 'steps', 'businessRules', 'dependencies', 'files']
+
+  for (const field of textFields) {
+    if (typeof copy[field] === 'string') {
+      copy[field] = fixAccents(copy[field])
+      aiPatternCount += detectAIPatterns(copy[field]).count
+    }
+  }
+
+  for (const field of arrayFields) {
+    if (Array.isArray(copy[field])) {
+      copy[field] = copy[field].map((item) => {
+        if (typeof item !== 'string') return item
+        const fixed = fixAccents(item)
+        aiPatternCount += detectAIPatterns(fixed).count
+        return fixed
+      })
+    }
+  }
+
+  const completeness = scoreCompleteness(copy)
+  const description = buildTaskDescription(copy)
+  return {
+    task: {
+      ...copy,
+      completenessScore: completeness.score,
+      completenessSuggestions: completeness.suggestions,
+      aiPatternCount,
+      description,
+    },
+    aiPatternCount,
+    completenessScore: completeness.score,
+    completenessSuggestions: completeness.suggestions,
+    description,
+  }
+}
+
+function processPayload(payload) {
+  if (Array.isArray(payload)) {
+    return { tasks: payload.map((task) => sanitizeTaskTexts(task).task) }
+  }
+  if (payload && Array.isArray(payload.tasks)) {
+    return { ...payload, tasks: payload.tasks.map((task) => sanitizeTaskTexts(task).task) }
+  }
+  if (payload && typeof payload === 'object') {
+    return sanitizeTaskTexts(payload).task
+  }
+  return payload
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (chunk) => { data += chunk })
+    process.stdin.on('end', () => resolve(data))
+    process.stdin.on('error', reject)
+  })
+}
+
+async function main() {
+  if (!process.argv.includes('--json')) {
+    console.error(JSON.stringify({ error: 'Use --json and provide JSON via stdin' }))
+    process.exit(1)
+  }
+
+  const input = await readStdin()
+  let parsed
+  try {
+    parsed = input.trim() ? JSON.parse(input) : {}
+  } catch (error) {
+    console.error(JSON.stringify({ error: `Invalid JSON input: ${error.message}` }))
+    process.exit(1)
+  }
+
+  const output = processPayload(parsed)
+  process.stdout.write(JSON.stringify(output, null, 2) + '\n')
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(JSON.stringify({ error: error.message }))
+    process.exit(1)
+  })
+}
+
+module.exports = {
+  fixAccents,
+  detectAIPatterns,
+  scoreCompleteness,
+  buildTaskDescription,
+  sanitizeTaskTexts,
+  processPayload,
+}