exonous 0.0.0-stage → 2.10.4

package/assets/skills/doc/doc.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+// Localiza documentação, handoffs e referências de código para o repositório.
+
+import { execFileSync } from 'node:child_process'
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { basename, dirname, join, relative, resolve, sep } from 'node:path'
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'build', 'bin', 'obj', 'vendor', 'coverage', 'target', 'venv', '__pycache__', 'Pods'])
+const MAX_DEPTH = 6
+const MAX_FILE_BYTES = 5 * 1024 * 1024
+const EXIT_NO_REPO = 2
+const EXIT_NO_VAULT = 3
+// Qualquer `algo:12` ou `algo:12-30` entre crases; o resolvedor decide se é arquivo.
+const REF = /`([^`\s:]+):(\d+)(?:-(\d+))?`/gu
+const HOST_LIKE = /^(\d{1,3}(\.\d{1,3}){3}|localhost|[\w.-]+\.(com|net|org|io|uk|br|dev|app|cloud|internal|local))$/i
+
+function fail(message, code = 1) {
+  process.stderr.write(`${message}\n`)
+  process.exit(code)
+}
+
+function git(cwd, args) {
+  // quotePath=false: sem isso o git devolve caminhos com acento escapados ("a\303\247").
+  return execFileSync('git', ['-c', 'core.quotePath=false', '-C', cwd, ...args], {
+    encoding: 'utf8',
+    maxBuffer: 256 * 1024 * 1024,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim()
+}
+
+function lines(output) {
+  return output.split('\n').map((s) => s.trim()).filter(Boolean)
+}
+
+function posix(path) {
+  return path.split(sep).join('/')
+}
+
+function parseArgs(argv) {
+  const flags = {}
+  const positional = []
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (!arg.startsWith('--')) {
+      positional.push(arg)
+      continue
+    }
+    const eq = arg.indexOf('=')
+    const key = eq === -1 ? arg.slice(2) : arg.slice(2, eq)
+    if (eq !== -1) flags[key] = arg.slice(eq + 1)
+    else if (argv[i + 1] && !argv[i + 1].startsWith('--')) flags[key] = argv[++i]
+    else flags[key] = true
+  }
+  return { flags, positional }
+}
+
+function repoInfo(start) {
+  let root
+  try {
+    root = git(start, ['rev-parse', '--show-toplevel'])
+  } catch {
+    fail(`Não é um repositório git: ${start}`, EXIT_NO_REPO)
+  }
+  // Em worktree, o nome do repo é o do checkout principal (primeira linha do worktree list).
+  const main = git(root, ['worktree', 'list', '--porcelain']).split('\n')[0].replace(/^worktree /, '')
+  return {
+    root: posix(resolve(root)),
+    name: basename(main).replace(/\.git$/, ''),
+    mainCheckout: posix(resolve(main)),
+  }
+}
+
+function hasHead(root) {
+  try {
+    git(root, ['rev-parse', '--verify', 'HEAD'])
+    return true
+  } catch {
+    return false
+  }
+}
+
+function walkVaults(dir, depth, found) {
+  if (depth > MAX_DEPTH) return found
+  let entries
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return found
+  }
+  if (entries.some((e) => e.isDirectory() && e.name === '.obsidian')) found.push(dir)
+  for (const e of entries) {
+    if (e.isDirectory() && !SKIP_DIRS.has(e.name) && !e.name.startsWith('.')) walkVaults(join(dir, e.name), depth + 1, found)
+  }
+  return found
+}
+
+// Prefere o que o git conhece (respeita .gitignore e não entra em clone aninhado);
+// cai para varrer o disco quando o .obsidian não está versionado.
+function findVaults(root) {
+  const fromGit = new Set()
+  for (const f of lines(git(root, ['ls-files', '--cached', '--others', '--exclude-standard']))) {
+    const at = f.indexOf('.obsidian/')
+    if (at !== -1 && (at === 0 || f[at - 1] === '/')) fromGit.add(join(root, f.slice(0, at)))
+  }
+  return fromGit.size ? [...fromGit] : walkVaults(root, 0, [])
+}
+
+function markdownFiles(dir, out = []) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (e.name.startsWith('.')) continue
+    const full = join(dir, e.name)
+    if (e.isDirectory()) markdownFiles(full, out)
+    else if (e.name.endsWith('.md')) out.push(full)
+  }
+  return out
+}
+
+// Nota de entrada: nome começando por _contexto, _índice ou README; a mais rasa primeiro.
+function entryNote(vault, notes) {
+  const score = (p) => {
+    const name = basename(p).normalize('NFC').toLowerCase()
+    if (/^_?(contexto|context)\b/u.test(name)) return 0
+    if (/^_?(índice|indice|index)\b/u.test(name)) return 1
+    if (name === 'readme.md') return 2
+    return 9
+  }
+  const ranked = notes.filter((p) => score(p) < 9).sort((a, b) => score(a) - score(b) || a.split(sep).length - b.split(sep).length)
+  return ranked[0] ? posix(relative(vault, ranked[0])) : null
+}
+
+function latestSessionNote(repoRoot) {
+  try {
+    const env = { ...process.env, EXONOUS_HANDOFF_CWD: repoRoot }
+    const command = process.platform === 'win32' ? 'cmd.exe' : 'exonous'
+    const args = process.platform === 'win32' ? ['/d', '/s', '/c', 'exonous handoff latest --json'] : ['handoff', 'latest', '--json']
+    const cwd = process.platform === 'win32' ? dirname(process.execPath) : repoRoot
+    const result = JSON.parse(execFileSync(command, args, { cwd, env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }))
+    if (result.status === 'found') return { sessionsVault: result.vault, note: posix(result.path), reason: null }
+    return { sessionsVault: result.vault || null, note: null, reason: result.status === 'unsupported-version' ? `handoff versão ${result.version} não suportada` : 'nenhuma nota: rode `exonous vault detect`' }
+  } catch (err) {
+    let reason = 'exonous handoff indisponível: confira a instalação do exonous'
+    try { reason = JSON.parse(String(err.stdout)).reason || reason } catch {}
+    return { sessionsVault: null, note: null, reason }
+  }
+}
+
+function cmdLocate(flags) {
+  const repo = repoInfo(resolve(flags.repo || process.cwd()))
+  const describe = (base) =>
+    findVaults(base).map((v) => {
+      const notes = markdownFiles(v)
+      return { path: posix(relative(base, v)) || '.', notes: notes.length, entry: entryNote(v, notes) }
+    })
+  const vaults = describe(repo.root)
+  // Worktree criado antes do vault existir: o vault está no checkout principal, não falta no projeto.
+  const vaultsInMainCheckout = !vaults.length && repo.mainCheckout !== repo.root ? describe(repo.mainCheckout) : []
+  const session = latestSessionNote(repo.root)
+  console.log(JSON.stringify({ repo, vaults, vaultsInMainCheckout, session }, null, 2))
+  if (!vaults.length) process.exitCode = EXIT_NO_VAULT
+}
+
+// Commits desde `since` + mudanças ainda não commitadas + arquivos novos não rastreados.
+function changedFiles(root, since) {
+  // Valor começando com "-" viraria opção do git (ex.: --output=arquivo).
+  if (since.startsWith('-')) fail(`--since inválido ("${since}"): use uma data AAAA-MM-DD ou um git ref existente.`)
+  const files = new Set(lines(git(root, ['ls-files', '--others', '--exclude-standard'])))
+  if (!hasHead(root)) {
+    for (const f of lines(git(root, ['ls-files', '--cached']))) files.add(f)
+    return files
+  }
+  for (const f of lines(git(root, ['diff', '--name-only', 'HEAD']))) files.add(f)
+  let committed
+  try {
+    committed = /^\d{4}-\d{2}-\d{2}$/.test(since)
+      ? git(root, ['log', `--since=${since} 00:00:00`, '--name-only', '--format='])
+      : git(root, ['diff', '--name-only', `${since}...HEAD`])
+  } catch (err) {
+    fail(`--since inválido ("${since}"): use uma data AAAA-MM-DD ou um git ref existente. ${String(err.stderr || '').trim()}`)
+  }
+  for (const f of lines(committed)) files.add(f)
+  return files
+}
+
+function lineCount(path) {
+  let stat
+  try {
+    stat = statSync(path)
+  } catch {
+    return null
+  }
+  if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return null
+  const buf = readFileSync(path)
+  if (buf.length === 0) return 0
+  let count = 0
+  for (const byte of buf) if (byte === 10) count++
+  return buf[buf.length - 1] === 10 ? count : count + 1
+}
+
+// Notas citam o caminho completo, um caminho parcial (`oms/state.ts`) ou só o nome (`money.ts`).
+function makeResolver(root) {
+  const known = lines(git(root, ['ls-files', '--cached', '--others', '--exclude-standard']))
+  const exact = new Set(known)
+  const byName = new Map()
+  for (const f of known) {
+    const name = f.slice(f.lastIndexOf('/') + 1)
+    byName.set(name, [...(byName.get(name) || []), f])
+  }
+  return (raw) => {
+    const ref = raw.replace(/\\/g, '/').replace(/^\.\//, '')
+    if (exact.has(ref)) return [ref]
+    const name = ref.slice(ref.lastIndexOf('/') + 1)
+    return (byName.get(name) || []).filter((f) => f.endsWith(`/${ref}`))
+  }
+}
+
+function cmdRefs(flags, positional) {
+  const repo = repoInfo(resolve(flags.repo || process.cwd()))
+  const vault = resolve(repo.root, positional[0] || '')
+  if (!positional[0] || !existsSync(join(vault, '.obsidian'))) fail('Uso: refs "<caminho do vault>" [--since <git-ref|AAAA-MM-DD>]', EXIT_NO_VAULT)
+  const changed = flags.since ? changedFiles(repo.root, flags.since) : null
+  const resolveRef = makeResolver(repo.root)
+  const sizes = new Map()
+  const broken = []
+  const ambiguous = []
+  const hostLike = new Set()
+  const touched = new Map()
+  let total = 0
+
+  for (const note of markdownFiles(vault)) {
+    const text = readFileSync(note, 'utf8')
+    const noteRel = posix(relative(repo.root, note))
+    for (const m of text.matchAll(REF)) {
+      const target = m[1]
+      if (HOST_LIKE.test(target)) {
+        hostLike.add(m[0])
+        continue
+      }
+      const candidates = resolveRef(target)
+      // Sem ponto nem barra e sem arquivo com esse nome, não é arquivo (ex.: `status:200`).
+      if (!candidates.length && !/[./]/.test(target)) continue
+      total++
+      if (changed && candidates.some((f) => changed.has(f))) {
+        touched.set(noteRel, (touched.get(noteRel) || new Set()).add(m[0]))
+      }
+      if (candidates.length > 1) {
+        ambiguous.push({ note: noteRel, ref: m[0], candidatos: candidates.slice(0, 5) })
+        continue
+      }
+      if (!candidates.length) {
+        broken.push({ note: noteRel, ref: m[0], problem: 'arquivo não existe neste repo' })
+        continue
+      }
+      const file = candidates[0]
+      if (!sizes.has(file)) sizes.set(file, lineCount(join(repo.root, file)))
+      const line = Number(m[3] || m[2])
+      if (sizes.get(file) !== null && line > sizes.get(file)) {
+        broken.push({ note: noteRel, ref: m[0], problem: `${file} tem ${sizes.get(file)} linhas` })
+      }
+    }
+  }
+
+  console.log(JSON.stringify({
+    vault: posix(relative(repo.root, vault)),
+    referencias: total,
+    quebradas: broken,
+    ambiguas: ambiguous,
+    ignoradasPorParecerHost: [...hostLike],
+    notasQueCitamArquivosAlterados: changed
+      ? [...touched].map(([note, refs]) => ({ note, refs: [...refs] }))
+      : 'passe --since para cruzar com arquivos alterados',
+  }, null, 2))
+}
+
+const { flags, positional } = parseArgs(process.argv.slice(2))
+const command = positional.shift()
+if (command === 'locate') cmdLocate(flags)
+else if (command === 'refs') cmdRefs(flags, positional)
+else fail('Uso: node doc.mjs <locate | refs "<vault>"> [--repo caminho] [--since git-ref|AAAA-MM-DD]')

package/assets/skills/issue-board/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: issue-board
+description: Mostra no terminal, em tabelas, as issues abertas que o dev tem para fazer em qualquer GitHub Project (v2), separadas por tipo, prioridade, dificuldade, status, repo ou um campo do board. O agente classifica o que o board não classifica. Use quando o usuário pedir "minhas issues", "o que tenho pra fazer", "mostra o board", "rankeia as issues", "separa as issues por dificuldade/tipo".
+---
+
+# Issue Board
+
+Use `exonous issue-board`: CLI nativa em Rust, com `gh` autenticado para buscar o board. O renderizador e a classificação funcionam offline sobre o cache.
+
+A skill não conhece nenhum projeto. O board (owner e número), os nomes dos campos e a lista de tipos moram em `config.json`, que é por pessoa e nunca vai versionado. Sem `types` no config, valem os tipos neutros embutidos: bug, feature, interface, dados, performance, segurança, infra, outros.
+
+## 1. Pré-requisitos
+
+O `fetch` checa a auth antes de tudo e depois o board. Trate pelo código de saída:
+
+1. **Código 4: sem `gh`.** Peça para instalar o GitHub CLI (https://cli.github.com) e pare.
+2. **Código 2: sem auth.** Pare e mande o usuário rodar no prompt:
+   ```
+   ! gh auth login -s read:project
+   ```
+   Se a mensagem citar escopo, é `! gh auth refresh -s read:project`. Não contorne, não use token de outra pessoa, não continue sem auth.
+3. **Código 3: board não definido ou inválido.**
+   - descubra o owner pelo remote do repo atual (`gh repo view --json owner -q .owner.login`), ou pergunte;
+   - liste os boards com `gh project list --owner <owner>`;
+   - pergunte qual usar com AskUserQuestion;
+   - copie `config.example.json` para `config.json` e preencha `owner` e `projectNumber`.
+
+   Para olhar outro board sem mexer no config, passe `--owner x --project-number n` em qualquer comando.
+4. **Campos do board (opcional).** Rode `gh project field-list <n> --owner <owner>` e ajuste `fields` no config se os nomes forem outros:
+   - `status`, `priority` e `size` são os nomes dos campos no board;
+   - `group` é um campo single-select extra que vira coluna e agrupamento (ex.: "Área", "Squad").
+
+   Só campos **single-select** são lidos; campo de texto, número ou iteration é ignorado.
+
+   Quando os valores de prioridade ou tamanho não forem P0–P3 / High / Low ou XS–XL / Small / Large, mapeie em `priorityMap` (valor → `P0..P3`) e `sizeMap` (valor → `1..3`). Valor sem mapa aparece cru na coluna.
+5. **Tipos (opcional).** Se o usuário quiser outras categorias, grave em `types` uma lista de `{ id, name, hint }`.
+
+## 2. Fluxo
+
+```bash
+exonous issue-board fetch
+exonous issue-board pending
+# classifique (seção 3), grave num arquivo temporário FORA do repo (ex.: $TMPDIR) e aplique:
+exonous issue-board classify <arquivo.json>
+exonous issue-board render
+exonous issue-board render --json
+```
+
+Flags de escopo e filtro (valem para `pending` e `render`):
+
+| Flag | Efeito |
+|---|---|
+| `--all` | board inteiro, não só as suas |
+| `--user login` | issues de outra pessoa |
+| `--por tipo\|prioridade\|dificuldade\|campo\|status\|repo` | agrupamento (padrão `tipo`); `campo` usa `fields.group` |
+| `--prioridade P0,P1` · `--dificuldade facil` · `--tipo bug` · `--campo valor` · `--repo nome` · `--status ready` | filtros: vários valores separados por vírgula; casam por trecho, sem diferenciar maiúscula nem acento (`--status ready` também pega "Not ready"); `--tipo` aceita id ou nome |
+
+O cache fica em `data/<owner>-<número>/` dentro da skill compartilhada em `~/.agents/skills/issue-board`; instalações antigas em `~/.claude/skills/issue-board` continuam legíveis. `--skill-dir <pasta>` seleciona outra cópia explicitamente.
+
+A saída do Bash nem sempre aparece para o usuário. Para colar na resposta, rode `exonous issue-board render --width 100` e cole a tabela em um bloco `text`, exatamente como saiu. Preserve bordas, colunas, cabeçalho e legenda.
+
+## 3. Como classificar
+
+Cada issue do `pending` vira `{ "key", "type", "priority", "difficulty", "note" }`:
+
+- `type`: um `id` da lista `types` que o `pending` devolve. Use o `hint` de cada tipo. Não invente tipo; se nada encaixa, use o mais genérico da lista.
+- `priority`:
+  - **P0**: quebra dado ou fluxo principal do usuário agora, ou bloqueia receita/entrega;
+  - **P1**: bug visível ou risco sério (segurança, vazamento de dados);
+  - **P2**: melhoria importante, sem dano em curso;
+  - **P3**: pode esperar.
+- `difficulty`: **1** até um dia · **2** poucos dias · **3** uma semana ou mais, ou depende de decisão.
+- `note` (opcional, até ~40 caracteres): o que ajuda a ordenar ("duplica #123", "decisão de produto", "só print, confirmar").
+
+Leia título **e** corpo antes de classificar. Issue com título vago e só imagem: classifique pelo título e anote "só print, confirmar".
+
+**O board vence.** Se `Priority` ou `Size` já estão preenchidos no board, o `render` usa esse valor. A sugestão do agente só aparece onde o campo está vazio, marcada com `~`. Não altere campos do board sem o usuário pedir.
+
+A classificação é gravada por `owner/repo#número` e reaproveitada nas próximas vezes: rode `pending` de novo e classifique só o que vier. Issue transferida muda de chave e volta ao `pending`.
+
+## 4. Resposta ao usuário
+
+1. A tabela, começando pelo cabeçalho do `render` (total, contagem por prioridade e legenda). Não escreva outra linha de total antes dela: repete o cabeçalho.
+2. Uma linha dizendo o que pegar primeiro: a issue de maior prioridade e, entre elas, a de menor dificuldade.