pipeline-de-codigo-aberto

Habilidade de Pipeline de Código Aberto

Disponibilize qualquer projeto como código aberto com segurança por meio de um pipeline de 3 estágios: Fork (remover segredos) → Sanitizar (verificar limpeza) → Empacotar (CLAUDE.md + setup.sh + README).

Quando Ativar

• O usuário diz "abra esse projeto como código aberto" ou "torne isso público"
• O usuário quer preparar um repositório privado para lançamento público
• O usuário precisa remover segredos antes de enviar para o GitHub
• O usuário invoca /opensource fork, /opensource verify ou /opensource package

Comandos

Comando	Ação
/opensource fork PROJETO	Pipeline completo: fork + sanitizar + empacotar
/opensource verify PROJETO	Executar sanitizador em repositório existente
/opensource package PROJETO	Gerar CLAUDE.md + setup.sh + README
/opensource list	Mostrar todos os projetos em preparação
/opensource status PROJETO	Mostrar relatórios de um projeto em preparação

Protocolo

/opensource fork PROJETO

Pipeline completo — o fluxo de trabalho principal.

Passo 1: Coletar Parâmetros

Resolva o caminho do projeto. Se PROJETO contiver /, trate como um caminho (absoluto ou relativo). Caso contrário, verifique: diretório de trabalho atual, $HOME/PROJETO, depois pergunte ao usuário.

SOURCE_PATH="<caminho absoluto resolvido>"
STAGING_PATH="$HOME/opensource-staging/${NOME_DO_PROJETO}"

Pergunte ao usuário:

1. "Qual projeto?" (se não encontrado)
2. "Licença? (MIT / Apache-2.0 / GPL-3.0 / BSD-3-Clause)"
3. "Organização ou usuário do GitHub?" (padrão: detectar via gh api user -q .login)
4. "Nome do repositório no GitHub?" (padrão: nome do projeto)
5. "Descrição para o README?" (analisar o projeto para sugestão)

Passo 2: Criar Diretório de Preparação

mkdir -p $HOME/opensource-staging/

Passo 3: Executar Agente Forker

Invoque o agente opensource-forker:

Agent(
  description="Fork {PROJETO} para código aberto",
  subagent_type="opensource-forker",
  prompt="""
Faça um fork do projeto para lançamento como código aberto.

Fonte: {SOURCE_PATH}
Destino: {STAGING_PATH}
Licença: {licenca_escolhida}

Siga o protocolo completo de fork:
1. Copiar arquivos (excluir .git, node_modules, __pycache__, .venv)
2. Remover todos os segredos e credenciais
3. Substituir referências internas por placeholders
4. Gerar .env.example
5. Limpar histórico do git
6. Gerar FORK_REPORT.md em {STAGING_PATH}/FORK_REPORT.md
"""
)

Aguarde a conclusão. Leia {STAGING_PATH}/FORK_REPORT.md.

Passo 4: Executar Agente Sanitizador

Invoque o agente opensource-sanitizer:

Agent(
  description="Verificar sanitização de {PROJETO}",
  subagent_type="opensource-sanitizer",
  prompt="""
Verifique a sanitização do fork de código aberto.

Projeto: {STAGING_PATH}
Fonte (para referência): {SOURCE_PATH}

Execute TODAS as categorias de varredura:
1. Varredura de segredos (CRÍTICA)
2. Varredura de PII (CRÍTICA)
3. Varredura de referências internas (CRÍTICA)
4. Verificação de arquivos perigosos (CRÍTICA)
5. Completude da configuração (AVISO)
6. Auditoria do histórico do git

Gere SANITIZATION_REPORT.md dentro de {STAGING_PATH}/ com veredito PASS/FAIL.
"""
)

Aguarde a conclusão. Leia {STAGING_PATH}/SANITIZATION_REPORT.md.

Se FAIL: Mostre as descobertas ao usuário. Pergunte: "Corrigir estes itens e revarrer, ou abortar?"

• Se corrigir: Aplique correções, reexecute o sanitizador (máximo 3 tentativas — após 3 FAILs, apresente todas as descobertas e peça ao usuário para corrigir manualmente)
• Se abortar: Limpe o diretório de preparação

Se PASS ou PASS WITH WARNINGS: Continue para o Passo 5.

Passo 5: Executar Agente Empacotador

Invoque o agente opensource-packager:

Agent(
  description="Empacotar {PROJETO} para código aberto",
  subagent_type="opensource-packager",
  prompt="""
Gere o pacote de código aberto para o projeto.

Projeto: {STAGING_PATH}
Licença: {licenca_escolhida}
Nome do projeto: {NOME_DO_PROJETO}
Descrição: {descricao}
Repositório GitHub: {github_repo}

Gere:
1. CLAUDE.md (comandos, arquitetura, arquivos-chave)
2. setup.sh (bootstrapping com um comando, torná-lo executável)
3. README.md (ou aprimore o existente)
4. LICENSE
5. CONTRIBUTING.md
6. .github/ISSUE_TEMPLATE/ (bug_report.md, feature_request.md)
"""
)

Passo 6: Revisão Final

Apresente ao usuário:

Fork de Código Aberto Pronto: {NOME_DO_PROJETO}

Localização: {STAGING_PATH}
Licença: {licenca}
Arquivos gerados:
  - CLAUDE.md
  - setup.sh (executável)
  - README.md
  - LICENSE
  - CONTRIBUTING.md
  - .env.example ({N} variáveis)

Sanitização: {veredito_sanitizacao}

Próximos passos:
  1. Revisar: cd {STAGING_PATH}
  2. Criar repositório: gh repo create {github_org}/{github_repo} --public
  3. Enviar: git remote add origin ... && git push -u origin main

Prosseguir com a criação no GitHub? (sim/não/revisar primeiro)

Passo 7: Publicar no GitHub (com aprovação do usuário)

cd "{STAGING_PATH}"
gh repo create "{github_org}/{github_repo}" --public --source=. --push --description "{descricao}"

---

/opensource verify PROJETO

Execute o sanitizador de forma independente. Resolva o caminho: se PROJETO contiver /, trate como um caminho. Caso contrário, verifique $HOME/opensource-staging/PROJETO, depois $HOME/PROJETO, e então o diretório atual.

Agent(
  subagent_type="opensource-sanitizer",
  prompt="Verificar sanitização de: {caminho_resolvido}. Execute todas as 6 categorias de varredura e gere SANITIZATION_REPORT.md."
)

---

/opensource package PROJETO

Execute o empacotador de forma independente. Pergunte por "Licença?" e "Descrição?", depois:

Agent(
  subagent_type="opensource-packager",
  prompt="Empacotar: {caminho_resolvido} ..."
)

---

/opensource list

ls -d $HOME/opensource-staging/*/

Mostre cada projeto com o progresso do pipeline (presença de FORK_REPORT.md, SANITIZATION_REPORT.md, CLAUDE.md).

---

/opensource status PROJETO

cat $HOME/opensource-staging/${PROJETO}/SANITIZATION_REPORT.md
cat $HOME/opensource-staging/${PROJETO}/FORK_REPORT.md

Estrutura de Preparação

$HOME/opensource-staging/
  meu-projeto/
    FORK_REPORT.md           # Do agente forker
    SANITIZATION_REPORT.md   # Do agente sanitizador
    CLAUDE.md                # Do agente empacotador
    setup.sh                 # Do agente empacotador
    README.md                # Do agente empacotador
    .env.example             # Do agente forker
    ...                      # Arquivos do projeto sanitizados

Antipadrões

• Nunca enviar para o GitHub sem aprovação do usuário
• Nunca pular o sanitizador — ele é o portão de segurança
• Nunca prosseguir após uma falha do sanitizador sem corrigir todas as descobertas críticas
• Nunca deixar .env, *.pem ou credentials.json no diretório de preparação

Melhores Práticas

• Sempre execute o pipeline completo (fork → sanitizar → empacotar) para novos lançamentos
• O diretório de preparação persiste até ser explicitamente limpo — use-o para revisão
• Reexecute o sanitizador após quaisquer correções manuais antes de publicar
• Parametrize segredos em vez de excluí-los — preserve a funcionalidade do projeto

Habilidades Relacionadas

Veja security-review para padrões de detecção de segredos usados pelo sanitizador.