opensource-pipeline

Habilidade de Pipeline Open-Source

Torne qualquer projeto open-source com segurança através de um pipeline de 3 estágios: Fork (remover segredos) → Sanitize (verificar limpeza) → Package (CLAUDE.md + setup.sh + README).

Quando Ativar

• O usuário diz "torne este projeto open-source" ou "torne isto público"
• O usuário deseja 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 + sanitize + package
/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 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 nome de 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

Inicie o agente opensource-forker:

Agent(
  description="Fork {PROJETO} para open-source",
  subagent_type="opensource-forker",
  prompt="""
Fork projeto para lançamento open-source.

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

Siga o protocolo completo de fork:
1. Copie arquivos (exclua .git, node_modules, __pycache__, .venv)
2. Remova todos os segredos e credenciais
3. Substitua referências internas por placeholders
4. Gere .env.example
5. Limpe o histórico do git
6. Gere FORK_REPORT.md em {STAGING_PATH}/FORK_REPORT.md
"""
)

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

Passo 4: Executar Agente Sanitizador

Inicie o agente opensource-sanitizer:

Agent(
  description="Verificar sanitização de {PROJETO}",
  subagent_type="opensource-sanitizer",
  prompt="""
Verificar sanitização do fork open-source.

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

Execute TODAS as categorias de varredura:
1. Varredura de segredos (CRÍTICO)
2. Varredura de PII (CRÍTICO)
3. Varredura de referências internas (CRÍTICO)
4. Verificação de arquivos perigosos (CRÍTICO)
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 e reescanear, 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 COM AVISOS: Continue para o Passo 5.

Passo 5: Executar Agente Empacotador

Inicie o agente opensource-packager:

Agent(
  description="Empacotar {PROJETO} para open-source",
  subagent_type="opensource-packager",
  prompt="""
Gerar empacotamento open-source para o projeto.

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

Gerar:
1. CLAUDE.md (comandos, arquitetura, arquivos-chave)
2. setup.sh (bootstrap em um comando, tornar executável)
3. README.md (ou melhorar 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 Open-Source 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. Revisão: 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 (após 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 independentemente. Resolva o caminho: se PROJETO contiver /, trate como caminho. Caso contrário, verifique $HOME/opensource-staging/PROJETO, depois $HOME/PROJETO, depois 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 independentemente. Pergunte "Licença?" e "Descrição?", então:

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

---

/opensource list

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

Mostre cada projeto com seu progresso no 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 sanitizado

Anti-Padrões

• Nunca envie para o GitHub sem aprovação do usuário
• Nunca pule o sanitizador — ele é a barreira de segurança
• Nunca prossiga após um FAIL do sanitizador sem corrigir todas as descobertas críticas
• Nunca deixe .env, *.pem ou credentials.json no diretório de preparação

Melhores Práticas

• Sempre execute o pipeline completo (fork → sanitize → package) 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

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