@aksp/opencrew 1.7.0 → 1.8.0

package/templates/_opencrew/core/scripts/entrega/argumentos.mjs

@@ -0,0 +1,46 @@
+// Linha de comando do `entregar.mjs`: as opções, a lista `caminho=formato` e a linha de uso.
+// Spec: fase-u3a1-pasta-de-entrega.md, §3 e §6 (repositório do OpenCrew).
+import { lerItemDaLista } from '../verificar/argumentos.mjs';
+
+export const USO = 'Uso: node _opencrew/core/scripts/entregar.mjs --crew "crews/<crew>" --run "<id>" --arquivo "<caminho=formato>[,<caminho=formato>…]" [--vai-publicar <canal>] [--ajuda]';
+
+const OPCAO = /^--(crew|run|arquivo|vai-publicar)(?:=(.*))?$/s;
+
+/** Texto que veio da linha de comando e volta numa mensagem: uma linha só, até 200 caracteres. */
+export const limpar = (valor) => String(valor).replace(/\s+/g, ' ').trim().slice(0, 200);
+
+function guardar(args, nome, valor) {
+  if (nome === 'arquivo') args.arquivos.push(valor);
+  else if (nome === 'vai-publicar') args.vaiPublicar.push(valor.trim().toLowerCase());
+  else args[nome] = valor;
+}
+
+/**
+ * `argv` → `{ crew, run, arquivos, vaiPublicar, ajuda, desconhecida }`. Opção vale como
+ * `--nome valor` e `--nome=valor`. `--arquivo` e `--vai-publicar` repetidos somam, e o que vem
+ * solto logo depois da lista é mais um item dela. `desconhecida`: a primeira opção que o script
+ * não conhece, ou null.
+ */
+export function lerArgs(argv) {
+  const args = { arquivos: [], vaiPublicar: [], ajuda: false, desconhecida: null };
+  let naLista = false;
+  for (let i = 0; i < argv.length; i++) {
+    const [, nome, colado] = argv[i].match(OPCAO) ?? [];
+    const solto = !nome && !argv[i].startsWith('--');
+    if (nome) guardar(args, nome, colado ?? (i + 1 < argv.length && !argv[i + 1].startsWith('--') ? argv[++i] : ''));
+    else if (argv[i] === '--ajuda') args.ajuda = true;
+    else if (solto && naLista) args.arquivos.push(argv[i]);
+    else args.desconhecida ??= argv[i];
+    naLista = nome ? nome === 'arquivo' : solto && naLista;
+  }
+  return args;
+}
+
+/** A lista de `--arquivo` → `[{ arquivo, formato }]` (`formato` null quando não veio `=formato`). */
+export function lerLista(arquivos) {
+  const textos = arquivos.join(',').split(',').map((s) => s.trim()).filter(Boolean);
+  return textos.map(lerItemDaLista).map((i) => (typeof i === 'string' ? { arquivo: i, formato: null } : i));
+}
+
+/** O `--run` é um segmento só: sem `/`, `\` nem `..`. */
+export const runValido = (run) => !/[\\/]/.test(run) && run !== '..' && run !== '.';

package/templates/_opencrew/core/scripts/entrega/canais.mjs

@@ -0,0 +1,51 @@
+// Canais da entrega: a pasta de cada formato (o `platform:` do best-practice), os nomes que o
+// LEIA-ME mostra e o que nunca entra numa entrega.
+// Spec: fase-u3a1-pasta-de-entrega.md, regras 1 e 3 (repositório do OpenCrew).
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { lerFrontmatter, lerTexto } from '../verificar/leitura.mjs';
+
+/** Pasta do canal → nome no LEIA-ME, na ordem em que as seções aparecem. */
+export const CANAIS = { instagram: 'Instagram', linkedin: 'LinkedIn', blog: 'Blog', email: 'E-mail', whatsapp: 'WhatsApp', twitter: 'X/Twitter', youtube: 'YouTube' };
+export const OUTROS = 'outros';
+export const EDITAVEIS = 'editaveis';
+export const ehCanal = (pasta) => Object.hasOwn(CANAIS, pasta);
+/** Como a pasta é chamada numa mensagem: o nome do canal, ou `outros/`. */
+export const nomeDaPasta = (pasta) => CANAIS[pasta] ?? `${pasta}/`;
+
+async function plataformaEm(raiz, pasta, formato) {
+  const arquivo = path.join(raiz, '_opencrew', ...pasta, `${formato}.md`);
+  if (!existsSync(arquivo)) return null;
+  const valor = lerFrontmatter(await lerTexto(arquivo))?.platform;
+  return typeof valor === 'string' && valor.trim() ? valor.trim().toLowerCase() : null;
+}
+
+/**
+ * Canal de um formato: o `platform:` de `_opencrew/best-practices.local/<formato>.md`, quando o
+ * arquivo o declara; senão, o do core. Sem formato, sem best-practice, sem `platform:` ou com
+ * plataforma que não é uma das sete pastas: null (o arquivo vai para `outros/`).
+ */
+export async function canalDoFormato(raiz, formato) {
+  if (!formato || !/^[a-z0-9-]+$/.test(formato)) return null;
+  const local = await plataformaEm(raiz, ['best-practices.local'], formato);
+  const plataforma = local ?? (await plataformaEm(raiz, ['core', 'best-practices'], formato));
+  return plataforma && ehCanal(plataforma) ? plataforma : null;
+}
+
+const PASTAS_DE_SERVICO = new Set(['entrega', 'entrega.tmp', 'export']);
+
+/**
+ * Arquivo de serviço nunca entra, mesmo listado: `verificacao-*.md`, `publicado.json`, o que está
+ * em `entrega/`, `entrega.tmp/` ou `export/` de uma execução e o `caption.txt` direto na pasta
+ * da execução (é ali que o publicador o grava; dentro de uma pasta `vN` ele é saída de passo).
+ * @param {string} rel caminho relativo ao projeto, com `/`
+ */
+export function ehDeServico(rel) {
+  const partes = rel.toLowerCase().split('/');
+  const nome = partes.at(-1);
+  if (/^verificacao-.*\.md$/.test(nome) || nome === 'publicado.json') return true;
+  const naSaida = partes[0] === 'crews' && partes[2] === 'output';
+  if (!naSaida) return false;
+  if (partes.slice(4, -1).some((p) => PASTAS_DE_SERVICO.has(p))) return true;
+  return nome === 'caption.txt' && partes.length === 5;
+}

package/templates/_opencrew/core/scripts/entrega/fora.mjs

@@ -0,0 +1,49 @@
+// Blocos de rótulo do arquivo de origem que não chegam à entrega: os de serviço (notas, checklist,
+// FORMAT) e, nos formatos lidos pelo leitor de peças, os que não são a peça do formato (os SLIDES
+// de um carrossel, por exemplo). A entrega não muda: o LEIA-ME só passa a dizer o que ficou fora.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e §6, ajuste da execução real (repositório do OpenCrew).
+import { semFrontmatter } from '../verificar/leitura.mjs';
+import { ROTULOS } from '../verificar/pecas.mjs';
+import { lerTrechos, marcar } from '../verificar/secoes.mjs';
+import { PRINCIPAL } from './leitor.mjs';
+import { ehServico, secoesDeRotulo, semComentarios } from './texto.mjs';
+
+export const MSG = {
+  fora: (blocos) => `Ficou fora do texto para colar: ${blocos.join(', ')}. Veja no arquivo de origem.`,
+  foraNaTela: (arquivo, blocos) => `${arquivo}: ficou fora do texto para colar: ${blocos.join(', ')}. Veja no arquivo de origem.`,
+};
+
+const tabelaDe = (formato) => (formato === 'twitter-thread' ? 'twitter-post' : formato);
+
+/** O bloco deste rótulo chega à entrega? `formato`: o do leitor de peças, ou null (só o de serviço sai). */
+function entra(rotulo, formato) {
+  if (ehServico(rotulo)) return false;
+  if (!formato) return true;
+  const papel = ROTULOS[tabelaDe(formato)]?.[rotulo];
+  return papel === PRINCIPAL[formato] || papel === 'parte' || rotulo === 'HASHTAGS';
+}
+
+/** As seções de rótulo como o leitor de peças as vê: cada uma vai até o próximo rótulo ou cabeçalho de peça. */
+function secoesDoLeitor(corpo, formato) {
+  const trechos = lerTrechos(marcar(corpo), tabelaDe(formato)).filter((t) => t.rotulo);
+  return trechos.map((t) => ({ rotulo: t.rotulo, texto: t.linhas.join('\n').trim() }));
+}
+
+/**
+ * Rótulos dos blocos com texto que ficam fora da entrega, cada um uma vez, na ordem do arquivo.
+ * @param {string} texto o arquivo de origem, sem BOM e com LF
+ * @param {string|null} [formato] formato lido pelo leitor de peças (`instagram-feed`,
+ *   `linkedin-post`, `twitter-post`, `twitter-thread`); null nos outros, em que só o bloco de
+ *   serviço fica fora
+ * @returns {string[]}
+ */
+export function blocosFora(texto, formato = null) {
+  const corpo = semComentarios(semFrontmatter(texto));
+  const secoes = formato ? secoesDoLeitor(corpo, formato) : secoesDeRotulo(corpo);
+  return [...new Set(secoes.filter((s) => s.rotulo && s.texto && !entra(s.rotulo, formato)).map((s) => s.rotulo))];
+}
+
+/** O aviso de um arquivo: `{ pasta, texto, tela }`, ou nenhum quando nada ficou fora. */
+export function avisoDeFora(item, blocos) {
+  return blocos.length ? [{ pasta: item.canal, texto: MSG.fora(blocos), tela: MSG.foraNaTela(item.rel, blocos) }] : [];
+}

package/templates/_opencrew/core/scripts/entrega/gravar.mjs

@@ -0,0 +1,83 @@
+// Gravação da entrega: montada em `entrega.tmp/`, ao lado, e trocada no fim. Nada pela metade:
+// em qualquer falha a entrega anterior fica como estava e não sobra pasta temporária. O script só
+// apaga a própria `entrega/` e os temporários que ele mesmo criou.
+// Spec: fase-u3a1-pasta-de-entrega.md, regras 12 e 15 (repositório do OpenCrew).
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const apagar = (pasta) => fs.rm(pasta, { recursive: true, force: true, maxRetries: 3 });
+
+/** 'pasta', 'arquivo' ou null (não existe). */
+async function tipoDe(caminho) {
+  try {
+    return (await fs.stat(caminho)).isDirectory() ? 'pasta' : 'arquivo';
+  } catch {
+    return null;
+  }
+}
+
+/** Temporário que sobrou de uma chamada interrompida: a pasta é do script; arquivo com o mesmo nome não é. */
+async function limparSobras({ entrega, tmp, antiga }) {
+  if ((await tipoDe(antiga)) === 'pasta') {
+    if (await tipoDe(entrega)) await apagar(antiga);
+    else await fs.rename(antiga, entrega); // a troca anterior parou no meio: a entrega volta
+  }
+  if ((await tipoDe(tmp)) === 'pasta') await apagar(tmp);
+}
+
+/** Grava um arquivo da entrega na pasta temporária: o texto gerado, ou os mesmos bytes da origem. */
+async function gravarArquivo(destino, a) {
+  await fs.mkdir(path.dirname(destino), { recursive: true });
+  if (a.texto != null) await fs.writeFile(destino, a.texto, 'utf8');
+  else await fs.copyFile(a.de, destino);
+}
+
+/** Põe a pasta nova no lugar da anterior; se a nova não entra, a anterior volta. */
+async function trocar({ entrega, tmp, antiga }, passo) {
+  const anterior = await tipoDe(entrega);
+  passo(entrega);
+  if (anterior === 'arquivo') throw new Error('entrega não é uma pasta');
+  if (anterior) await fs.rename(entrega, antiga);
+  try {
+    await fs.rename(tmp, entrega);
+  } catch (erro) {
+    if (anterior) await fs.rename(antiga, entrega);
+    throw erro;
+  }
+  passo(antiga);
+  if (anterior) await apagar(antiga);
+}
+
+/**
+ * Refaz `entrega/` do zero e grava, ao lado, o relatório da verificação.
+ * @param {string} execucao pasta da execução (`crews/<crew>/output/<run>/`), absoluta
+ * @param {object[]} arquivos `{ pasta, nome, texto | de }`
+ * @param {{ leiame: string, relatorio: string }} textos
+ * @returns {Promise<string|null>} null quando gravou tudo; senão, o caminho que não foi gravado
+ */
+export async function gravarEntrega(execucao, arquivos, { leiame, relatorio }) {
+  const pastas = { entrega: path.join(execucao, 'entrega'), tmp: path.join(execucao, 'entrega.tmp'), antiga: path.join(execucao, 'entrega.antiga.tmp') };
+  let alvo = pastas.tmp;
+  let criei = false;
+  const passo = (caminho) => { alvo = caminho; };
+  try {
+    await limparSobras(pastas);
+    await fs.mkdir(pastas.tmp);
+    criei = true;
+    for (const a of arquivos) {
+      passo(path.join(pastas.tmp, a.pasta, a.nome));
+      await gravarArquivo(alvo, a);
+    }
+    passo(path.join(pastas.tmp, 'LEIA-ME.md'));
+    await fs.writeFile(alvo, leiame, 'utf8');
+    await trocar(pastas, passo);
+    criei = false;
+    passo(path.join(execucao, 'verificacao-entrega.md'));
+    await fs.writeFile(alvo, relatorio, 'utf8');
+    return null;
+  } catch {
+    if (criei) await apagar(pastas.tmp).catch(() => {});
+    // O arquivo que falhou dentro da pasta temporária é citado pelo lugar em que ficaria.
+    return alvo.startsWith(pastas.tmp + path.sep) ? path.join(pastas.entrega, alvo.slice(pastas.tmp.length + 1)) : alvo;
+  }
+}

package/templates/_opencrew/core/scripts/entrega/leiame.mjs

@@ -0,0 +1,89 @@
+// O LEIA-ME.md da entrega: títulos fixos, na ordem da spec; seção sem conteúdo não aparece.
+// Arquivo da entrega é citado com caminho relativo à pasta do LEIA-ME; o de origem, relativo ao
+// projeto. Sem hora: as mesmas entradas geram os mesmos bytes. PT-BR fixo.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e §6 (repositório do OpenCrew).
+import { CANAIS, EDITAVEIS, OUTROS } from './canais.mjs';
+import { frasesDePendencia } from './pendencias.mjs';
+import { passosDe } from './passos.mjs';
+
+export const TEXTO = {
+  vaiPublicar: 'Esta crew publica este canal sozinha. Antes de postar à mão, confira se já saiu.',
+  pdf: 'Abra o arquivo que você quer (por exemplo, o artigo do blog) no navegador ou no editor de texto e use Imprimir → Salvar como PDF.',
+  semCanal: 'sem canal de publicação; está aqui para você usar como quiser.',
+  sobre: 'Esta pasta é refeita a cada entrega e fica fora do git: o que você editar aqui se perde. Para guardar, copie a pasta para outro lugar do projeto.',
+  pronto: 'Pronto',
+  naoPronto: 'Não está pronto',
+};
+
+const lista = (linhas) => linhas.map((l) => `- ${l}`).join('\n');
+const bloco = (titulo, linhas) => (linhas.length ? [`${titulo}\n${lista(linhas)}`] : []);
+const secao = (titulo, partes) => (partes.length ? [`## ${titulo}\n\n${partes.join('\n\n')}`] : []);
+
+/** Uma linha por arquivo entregue: o caminho na entrega, o título do bloco (se houver) e a origem. */
+function linhaDoArquivo(a) {
+  const titulo = a.titulo ? ` — ${a.titulo}` : '';
+  return `\`${a.pasta}/${a.nome}\`${titulo} — origem: \`${a.origem}\``;
+}
+
+/** Os avisos de uma pasta que o LEIA-ME mostra (o que só vai para a tela não tem `texto`). */
+const avisosDe = (d, pasta) => d.avisos.filter((a) => a.pasta === pasta && a.texto).map((a) => a.texto);
+
+/** `## Antes de usar`: os alertas de tamanho e, por canal que não está pronto, o que falta. */
+function antesDeUsar(d) {
+  const pastas = [...d.pastas, OUTROS].filter((p) => d.pendencias.has(p));
+  const frases = frasesDePendencia(pastas, d.pendencias);
+  const faltas = pastas.map((p, i) => `- ${frases[i]}\n${d.pendencias.get(p).map((l) => `  - ${l}`).join('\n')}`);
+  return secao('Antes de usar', [[...d.alertas.map((a) => `- ${a}`), ...faltas].join('\n')].filter(Boolean));
+}
+
+/** `## {Canal}`: o aviso de publicação, a situação, os arquivos, as pendências, os avisos e os passos. */
+function secaoDoCanal(d, pasta) {
+  const arquivos = d.arquivos.filter((a) => a.pasta === pasta);
+  const pendencias = d.pendencias.get(pasta) ?? [];
+  const passos = passosDe(pasta, arquivos, pendencias.length > 0).map((p, i) => `${i + 1}. ${p}`);
+  return secao(CANAIS[pasta], [
+    ...(d.vaiPublicar.includes(pasta) ? [TEXTO.vaiPublicar] : []),
+    `Situação: ${pendencias.length ? TEXTO.naoPronto : TEXTO.pronto}`,
+    ...bloco('Arquivos:', arquivos.map(linhaDoArquivo)),
+    ...bloco('Pendências:', pendencias),
+    ...bloco('Atenção:', avisosDe(d, pasta)),
+    ...(passos.length ? [`Passos:\n${passos.join('\n')}`] : []),
+  ]);
+}
+
+/** `## Outros arquivos` e `## Editáveis`: cada arquivo com a origem; em `outros`, a linha diz por que está ali. */
+function secaoDaPasta(d, pasta, titulo) {
+  const fim = pasta === OUTROS ? ` — ${TEXTO.semCanal}` : '';
+  const arquivos = d.arquivos.filter((a) => a.pasta === pasta).map((a) => `${linhaDoArquivo(a)}${fim}`);
+  const pendencias = d.pendencias.get(pasta) ?? [];
+  return secao(titulo, [
+    ...(arquivos.length ? [lista(arquivos)] : []),
+    ...bloco('Pendências:', pendencias),
+    ...bloco('Atenção:', avisosDe(d, pasta)),
+  ]);
+}
+
+/**
+ * @param {object} d
+ * @param {string} d.crew nome da crew · @param {string} d.run id da execução
+ * @param {string[]} d.pastas os canais presentes, na ordem das seções
+ * @param {object[]} d.arquivos `{ pasta, nome, tipo, origem, titulo, numerado }`
+ * @param {object[]} d.avisos `{ pasta, texto, tela }` (`tela`: como o aviso sai no resumo da tela)
+ * @param {Map<string, string[]>} d.pendencias por pasta · @param {string[]} d.alertas regra 34
+ * @param {string[]} d.naoConferido · @param {string[]} d.vaiPublicar canais que a crew publica
+ * @returns {string} o LEIA-ME, em UTF-8 sem BOM e com LF
+ */
+export function montarLeiame(d) {
+  const temMd = d.arquivos.some((a) => a.nome.toLowerCase().endsWith('.md'));
+  const partes = [
+    `# Entrega — ${d.crew} — ${d.run}`,
+    ...antesDeUsar(d),
+    ...d.pastas.flatMap((pasta) => secaoDoCanal(d, pasta)),
+    ...secaoDaPasta(d, OUTROS, 'Outros arquivos'),
+    ...secaoDaPasta(d, EDITAVEIS, 'Editáveis'),
+    ...secao('O que não foi conferido', [lista(d.naoConferido)]),
+    ...(temMd ? secao('Para ter um PDF', [TEXTO.pdf]) : []),
+    ...secao('Sobre esta pasta', [TEXTO.sobre]),
+  ];
+  return `${partes.join('\n\n')}\n`;
+}

package/templates/_opencrew/core/scripts/entrega/leitor.mjs

@@ -0,0 +1,120 @@
+// Peças que vêm do leitor do verificador (`lerPecas`): legenda, post e tweet, cada um com as
+// suas hashtags no fim — e o primeiro comentário do LinkedIn, que sai do texto do post.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e regra 4 (repositório do OpenCrew).
+import { semAcento } from '../verificar/leitura.mjs';
+import { lerPecas, listarHashtags } from '../verificar/pecas.mjs';
+import { lerTrechos, marcar, rotuloDe } from '../verificar/secoes.mjs';
+import { paraColar } from './texto.mjs';
+
+/** Peça principal de cada formato: sem ela, o arquivo vai inteiro. */
+export const PRINCIPAL = { 'instagram-feed': 'legenda', 'linkedin-post': 'post', 'twitter-post': 'tweet', 'twitter-thread': 'tweet' };
+const TITULO = /^(#{1,6})\s+(.*)$/s;
+const COMENTARIO = /(?<![\p{L}\p{N}])(?:comentarios?|comments?)(?![\p{L}\p{N}])/u;
+const marca = (n) => `⟦comentario:${n}⟧`;
+const MARCA = /^⟦comentario:(\d+)⟧$/;
+
+/**
+ * Tira do corpo as seções de comentário (cabeçalho com "comentário" ou "comment", até o próximo
+ * cabeçalho do mesmo nível ou acima, ou até um rótulo). No lugar de cada uma fica uma linha de
+ * marca: ela cai dentro do texto do post que vem antes.
+ * @returns {{ corpo: string, comentarios: string[] }}
+ */
+function tirarComentarios(corpo) {
+  const linhas = [];
+  const comentarios = [];
+  let nivel = 0; // nível do cabeçalho de comentário aberto; 0 = nenhum
+  for (const linha of corpo.split('\n')) {
+    const h = linha.match(TITULO);
+    if (nivel && (rotuloDe(linha) || (h && h[1].length <= nivel))) nivel = 0;
+    if (!nivel && h && COMENTARIO.test(semAcento(h[2]))) {
+      nivel = h[1].length;
+      linhas.push(marca(comentarios.push([]) - 1));
+    } else if (nivel) comentarios.at(-1).push(linha);
+    else linhas.push(linha);
+  }
+  return { corpo: linhas.join('\n'), comentarios: comentarios.map((c) => c.join('\n')) };
+}
+
+/** Texto da peça sem as linhas de marca, e os números dos comentários que estavam nele. */
+function separarMarcas(texto) {
+  const numeros = [];
+  const linhas = texto.split('\n').filter((linha) => {
+    const m = linha.trim().match(MARCA);
+    if (m) numeros.push(Number(m[1]));
+    return !m;
+  });
+  return { texto: linhas.join('\n'), numeros };
+}
+
+/** Cabeçalhos do corpo, na ordem: `[{ titulo, pai }]` (`pai`: o cabeçalho logo acima, ou null). */
+function cabecalhos(corpo) {
+  const lista = [];
+  let pilha = [];
+  for (const linha of corpo.split('\n')) {
+    const h = linha.match(TITULO);
+    if (!h) continue;
+    pilha = pilha.filter((c) => c.nivel < h[1].length);
+    lista.push({ titulo: h[2].trim(), pai: pilha.at(-1)?.titulo ?? null });
+    pilha.push({ nivel: h[1].length, titulo: h[2].trim() });
+  }
+  return lista;
+}
+
+/** Título do bloco de cada peça de cabeçalho: o cabeçalho logo acima do dela, quando houver. */
+function titulosDeBloco(corpo, pecas) {
+  const lista = cabecalhos(corpo);
+  let cursor = 0;
+  return pecas.map((p) => {
+    const i = p.origem === 'cabecalho' ? lista.findIndex((c, n) => n >= cursor && c.titulo === p.cabecalho) : -1;
+    if (i < 0) return null;
+    cursor = p.porParagrafo ? i : i + 1;
+    return lista[i].pai;
+  });
+}
+
+/** Hashtags da seção própria (rótulo ou cabeçalho) da legenda ou do post, sem as que já estão no texto. */
+function hashtagsDaPeca(pecas, p) {
+  const h = pecas.find((x) => x.tipo === 'hashtags' && x.de === p.tipo && x.ordem === p.ordem && x.formato === p.formato);
+  return h ? listarHashtags(h.texto).slice(listarHashtags(p.texto).length) : [];
+}
+
+/** Hashtags das seções `=== HASHTAGS ===` e de cabeçalho "Hashtags" de um arquivo de tweets. */
+export function hashtagsSoltas(corpo, tabela = 'twitter-post') {
+  const trechos = lerTrechos(marcar(corpo), tabela).filter((t) => t.rotulo === 'HASHTAGS' || t.tipos?.[0] === 'hashtags');
+  return trechos.flatMap((t) => listarHashtags(t.linhas.join('\n')));
+}
+
+const comHashtags = (texto, hashtags) => paraColar(hashtags.length ? `${texto}\n\n${hashtags.join(' ')}` : texto);
+
+/** Comentário de cada post: o que caiu no texto dele; os que sobraram vão, na ordem, para os posts sem comentário. */
+function distribuir(marcas, comentarios) {
+  const usados = new Set(marcas.flat());
+  const sobras = comentarios.map((_, n) => n).filter((n) => !usados.has(n));
+  return marcas.map((numeros) => (numeros.length ? numeros : sobras.splice(0, 1)).map((n) => comentarios[n]).join('\n\n'));
+}
+
+/**
+ * Lê as peças do formato num corpo já sem frontmatter e sem blocos de serviço.
+ * @returns {{ unidades: object[], temSlides: boolean, outros: string[] }} `unidades`: uma por
+ *   legenda, post ou tweet, `{ tipo, titulo, ordem, total, partes: [{ nome, sufixo, ext, tipo, texto }] }`
+ *   · `outros`: cabeçalhos das seções de outro canal, que não são separadas
+ */
+export function pecasDoLeitor(corpoOriginal, formato) {
+  const tabela = formato === 'twitter-thread' ? 'twitter-post' : formato;
+  const tipo = PRINCIPAL[formato];
+  const { corpo, comentarios } = tipo === 'post' ? tirarComentarios(corpoOriginal) : { corpo: corpoOriginal, comentarios: [] };
+  const pecas = lerPecas(corpo, tabela);
+  const principais = pecas.filter((p) => p.formato === tabela && p.tipo === tipo);
+  const limpas = principais.map((p) => separarMarcas(p.texto));
+  const doPost = distribuir(limpas.map((l) => l.numeros), comentarios);
+  const titulos = titulosDeBloco(corpo, principais);
+  const soltas = tipo === 'tweet' ? hashtagsSoltas(corpo) : [];
+  const unidades = principais.map((p, i) => {
+    const hashtags = tipo === 'tweet' ? (i === 0 ? soltas : []) : hashtagsDaPeca(pecas, p);
+    const partes = [{ nome: tipo, sufixo: '', ext: 'txt', tipo, texto: comHashtags(limpas[i].texto, hashtags) }];
+    if (doPost[i]?.trim()) partes.push({ nome: tipo, sufixo: '-comentario', ext: 'txt', tipo: 'comentario', texto: paraColar(doPost[i]) });
+    return { tipo, titulo: titulos[i], ordem: i + 1, total: principais.length, partes };
+  });
+  const outros = pecas.filter((p) => p.formato !== tabela && p.tipo !== 'hashtags' && p.cabecalho).map((p) => p.cabecalho);
+  return { unidades, temSlides: pecas.some((p) => p.formato === tabela && p.tipo === 'slides'), outros: [...new Set(outros)] };
+}

package/templates/_opencrew/core/scripts/entrega/longas.mjs

@@ -0,0 +1,109 @@
+// Peças que o leitor do verificador não lê: blog (`seo.txt` e `artigo.md`), e-mail (assunto,
+// prévia e corpo), mensagem de WhatsApp e os tweets de uma thread (`TWEET n/N`).
+// Recebem o texto do arquivo, sem BOM e com LF. Spec: fase-u3a1-pasta-de-entrega.md, §4.
+import { lerFrontmatter, semAcento, semFrontmatter } from '../verificar/leitura.mjs';
+import { lerPecas } from '../verificar/pecas.mjs';
+import { rotuloDe } from '../verificar/secoes.mjs';
+import { fecharMd, paraColar, secoesDeRotulo, semServico } from './texto.mjs';
+
+const parte = (nome, ext, texto) => ({ nome, sufixo: '', ext, tipo: nome, texto });
+const TITULO = /^#{1,6}\s+(.*)$/s;
+const palavra = (formas) => new RegExp(`(?<![\\p{L}\\p{N}])(?:${formas})(?![\\p{L}\\p{N}])`, 'u');
+
+// ── Blog ─────────────────────────────────────────────────────────────────────────────────────
+const FORA_DO_ARTIGO = new Set(['TITLE', 'TITLE TAG', 'META DESCRIPTION', 'TARGET KEYWORD']);
+const emUmaLinha = (valor) => String(valor).replace(/\s+/g, ' ').trim();
+
+/** Palavra-chave: do frontmatter; senão, o que vem depois de `Primary:` em `=== TARGET KEYWORD ===`. */
+function palavraChave(fm, secoes) {
+  const doRotulo = secoes.find((s) => s.rotulo === 'TARGET KEYWORD')?.texto.match(/Primary:[ \t]*([^|\n]+)/i)?.[1];
+  return [fm.palavra_chave, fm.keyword, doRotulo].find((v) => v != null && typeof v !== 'object' && String(v).trim());
+}
+
+/** @returns {object[]} uma unidade com `seo.txt` (só as linhas que existem) e `artigo.md` */
+export function pecasDoBlog(texto, formato) {
+  const fm = lerFrontmatter(texto) ?? {};
+  const secoes = secoesDeRotulo(semServico(semFrontmatter(texto)));
+  const lida = (tipo) => lerPecas(texto, formato).find((p) => p.tipo === tipo)?.texto;
+  const campos = [['Título', lida('titulo')], ['Meta description', lida('meta')], ['Palavra-chave', palavraChave(fm, secoes)], ['Slug', typeof fm.slug === 'object' ? null : fm.slug]];
+  const seo = campos.filter(([, v]) => v != null && emUmaLinha(v)).map(([campo, v]) => `${campo}: ${emUmaLinha(v)}\n`).join('');
+  const artigo = secoes.filter((s) => !FORA_DO_ARTIGO.has(s.rotulo) && s.texto).map((s) => s.texto).join('\n\n');
+  return [{ tipo: 'blog', partes: [parte('seo', 'txt', seo), parte('artigo', 'md', fecharMd(artigo))] }];
+}
+
+// ── E-mail ───────────────────────────────────────────────────────────────────────────────────
+const DO_ROTULO = { 'SUBJECT LINE': 'assunto', 'PREVIEW TEXT': 'previa' };
+const DO_CABECALHO = [['assunto', palavra('assuntos?|subject')], ['previa', palavra('previas?|preview')], ['corpo', /^(?:corpo|body)(?![\p{L}\p{N}])/u]];
+
+/** O que a linha abre: assunto, prévia ou corpo (linha de rótulo ou cabeçalho que nomeia); senão null. */
+function papelDaLinha(linha) {
+  const rotulo = rotuloDe(linha);
+  if (rotulo) return DO_ROTULO[rotulo] ?? 'corpo';
+  const h = linha.match(TITULO);
+  return h ? DO_CABECALHO.find(([, rx]) => rx.test(semAcento(h[1]).trim()))?.[0] ?? null : null;
+}
+
+/** Tira do fim das linhas o cabeçalho que vem logo antes de um assunto: é o título do bloco. */
+function tituloPendente(linhas) {
+  let fim = linhas.length;
+  while (fim && !linhas[fim - 1].trim()) fim--;
+  const h = fim ? linhas[fim - 1].match(TITULO) : null;
+  if (!h) return null;
+  linhas.length = fim - 1;
+  return h[1].trim();
+}
+
+/** Os e-mails do corpo, na ordem: cada assunto abre um. `[{ titulo, assunto, previa, corpo }]` (linhas). */
+function lerEmails(corpo) {
+  const novo = () => ({ titulo: null, assunto: [], previa: [], corpo: [] });
+  const emails = [novo()];
+  let alvo = 'corpo';
+  for (const linha of corpo.split('\n')) {
+    const papel = papelDaLinha(linha);
+    if (papel === 'assunto') {
+      const titulo = tituloPendente(emails.at(-1).corpo);
+      if (emails.at(-1).assunto.length) emails.push(novo());
+      emails.at(-1).titulo = titulo;
+    }
+    if (papel) alvo = papel;
+    else if (TITULO.test(linha) && alvo !== 'corpo') alvo = 'corpo'; // outro cabeçalho: é conteúdo
+    if (!papel) emails.at(-1)[alvo].push(linha);
+  }
+  return emails;
+}
+
+/** @returns {object[]} uma unidade por e-mail, com `assunto.txt`, `previa.txt` e `corpo.md` */
+export function pecasDoEmail(texto) {
+  const emails = lerEmails(semServico(semFrontmatter(texto)));
+  return emails.map((e) => ({
+    tipo: 'email',
+    titulo: e.titulo,
+    partes: [
+      parte('assunto', 'txt', paraColar(e.assunto.join('\n'))),
+      parte('previa', 'txt', paraColar(e.previa.join('\n'))),
+      parte('corpo', 'md', fecharMd(e.corpo.join('\n'))),
+    ],
+  }));
+}
+
+// ── WhatsApp ─────────────────────────────────────────────────────────────────────────────────
+/** @returns {object[]} uma unidade: os textos das seções, na ordem, separados por uma linha em branco */
+export function pecasDoWhatsapp(texto) {
+  const textos = secoesDeRotulo(semServico(semFrontmatter(texto))).map((s) => s.texto).filter(Boolean);
+  return [{ tipo: 'mensagem', partes: [parte('mensagem', 'txt', paraColar(textos.join('\n\n'), { whatsapp: true }))] }];
+}
+
+// ── Thread ───────────────────────────────────────────────────────────────────────────────────
+const TWEET_N = /^[\s*_#>-]{0,8}TWEET\s{1,3}\d{1,3}\s{0,3}\/\s{0,3}(?:\d{1,3}|N)(?![\p{L}\p{N}])/iu;
+
+/** Texto de cada bloco iniciado por `TWEET n/N` (sem essa linha), até o próximo bloco, rótulo ou cabeçalho. */
+export function tweetsDaThread(corpo) {
+  const blocos = [];
+  let atual = null;
+  for (const linha of corpo.split('\n')) {
+    if (TWEET_N.test(linha)) blocos.push((atual = []));
+    else if (rotuloDe(linha) || TITULO.test(linha)) atual = null;
+    else atual?.push(linha);
+  }
+  return blocos.map((b) => b.join('\n').trim()).filter(Boolean);
+}

package/templates/_opencrew/core/scripts/entrega/nomes.mjs

@@ -0,0 +1,78 @@
+// Nome de cada arquivo da entrega: peças do mesmo tipo no mesmo canal são numeradas; cópia cujo
+// nome já existe na pasta ganha o prefixo `2-`, `3-`. Nenhum arquivo é gravado por cima de outro.
+// Spec: fase-u3a-entrega-por-canal.md, regras 7 e 8, citadas pela fatia 1 (repositório do OpenCrew).
+
+export const MSG = {
+  mesmoNome: (arquivo, novo) => `${arquivo} tem o mesmo nome de outro e foi guardado como ${novo}.`,
+};
+
+const chave = (pasta, nome) => `${pasta}/${nome.toLowerCase()}`;
+
+/** Arquivos das unidades: `post.txt` quando há uma só no canal; `post-1.txt`, `post-1-comentario.txt`… com várias. */
+function nomearUnidades(unidades) {
+  const total = {};
+  for (const u of unidades) total[`${u.pasta}|${u.tipo}`] = (total[`${u.pasta}|${u.tipo}`] ?? 0) + 1;
+  const vez = {};
+  return unidades.flatMap((u) => {
+    const grupo = `${u.pasta}|${u.tipo}`;
+    vez[grupo] = (vez[grupo] ?? 0) + 1;
+    const numero = total[grupo] > 1 ? `-${vez[grupo]}` : '';
+    return u.partes.map((parte) => ({
+      pasta: u.pasta, nome: `${parte.nome}${numero}${parte.sufixo}.${parte.ext}`, tipo: parte.tipo, texto: parte.texto,
+      origem: u.origem, formato: u.formato, titulo: numero ? u.titulo ?? null : null, numerado: Boolean(numero), ordem: u.ordem, total: u.total,
+    }));
+  });
+}
+
+/** Cópias agrupadas por pasta da entrega e, dentro dela, por pasta de origem, na ordem da lista. */
+function grupos(copias) {
+  const porChave = new Map();
+  for (const c of copias) {
+    const id = `${c.pasta}|${c.pastaDeOrigem}`;
+    if (!porChave.has(id)) porChave.set(id, { pasta: c.pasta, copias: [] });
+    // O mesmo arquivo listado duas vezes para a mesma pasta é uma cópia só.
+    if (!porChave.get(id).copias.some((outra) => outra.nome === c.nome)) porChave.get(id).copias.push(c);
+  }
+  return [...porChave.values()];
+}
+
+/** O menor prefixo, a partir de `n-`, com que nenhum nome do grupo bate com um nome já usado. */
+function prefixoLivre(grupo, usados, n) {
+  while (grupo.copias.some((c) => usados.has(chave(grupo.pasta, `${n}-${c.nome}`)))) n += 1;
+  return n;
+}
+
+/**
+ * Cópias com o nome original. Quando um arquivo chegaria a uma pasta onde já há outro com esse
+ * nome, todos os que vêm da mesma pasta de origem ganham o prefixo (`2-`; os da pasta seguinte,
+ * `3-`). O aviso sai para cada arquivo cujo nome batia.
+ */
+function nomearCopias(copias, usados) {
+  const arquivos = [];
+  const avisos = [];
+  const proximo = {};
+  for (const grupo of grupos(copias)) {
+    const bate = (c) => usados.has(chave(grupo.pasta, c.nome));
+    const n = grupo.copias.some(bate) ? prefixoLivre(grupo, usados, proximo[grupo.pasta] ?? 2) : null;
+    if (n) proximo[grupo.pasta] = n + 1;
+    for (const c of grupo.copias) {
+      const nome = n ? `${n}-${c.nome}` : c.nome;
+      if (n && bate(c)) avisos.push({ pasta: c.pasta, texto: MSG.mesmoNome(c.origem, nome) });
+      arquivos.push({ ...c, nome });
+    }
+    for (const a of arquivos.slice(-grupo.copias.length)) usados.add(chave(a.pasta, a.nome));
+  }
+  return { arquivos, avisos };
+}
+
+/**
+ * @param {{ unidades: object[], copias: object[], avisos: object[] }} produtos o que `separar` devolve
+ * @returns {{ arquivos: object[], avisos: object[] }} `arquivos`: `{ pasta, nome, tipo, origem,
+ *   texto | de, … }`, na ordem da lista (as peças antes das cópias), sem dois com o mesmo caminho
+ */
+export function nomear({ unidades, copias, avisos }) {
+  const gerados = nomearUnidades(unidades);
+  const usados = new Set(gerados.map((a) => chave(a.pasta, a.nome)));
+  const copiados = nomearCopias(copias, usados);
+  return { arquivos: [...gerados, ...copiados.arquivos], avisos: [...avisos, ...copiados.avisos] };
+}