@aksp/opencrew 1.7.1 → 1.8.0

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

@@ -0,0 +1,103 @@
+// Separa os itens da lista em produtos da entrega: peças que viram arquivo próprio (unidades),
+// cópias com o nome original e avisos. Não escreve nada: quem grava é `gravar.mjs`.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e regras 4, 8, 9 e 11 (repositório do OpenCrew).
+import path from 'node:path';
+import { lerItem } from '../verificar/arquivos.mjs';
+import { semFrontmatter } from '../verificar/leitura.mjs';
+import { EDITAVEIS, OUTROS } from './canais.mjs';
+import { avisoDeFora, blocosFora } from './fora.mjs';
+import { PRINCIPAL, hashtagsSoltas, pecasDoLeitor } from './leitor.mjs';
+import { pecasDoBlog, pecasDoEmail, pecasDoWhatsapp, tweetsDaThread } from './longas.mjs';
+import { emLf, fecharMd, paraColar, semServico } from './texto.mjs';
+
+export const MSG = {
+  // Só no resumo da tela: no LEIA-ME, a linha do arquivo em "Outros arquivos" já diz.
+  semCanal: (arquivo) => `${arquivo} não tem canal conhecido. Está em \`outros/\`.`,
+  semPeca: (peca, arquivo) => `Não encontrei ${peca} em ${arquivo}. Confira antes de colar.`,
+  outroCanal: (arquivo, cabecalho) => `${arquivo} tem uma seção de outro canal (${cabecalho}) que não foi separada. Ela continua no arquivo de origem.`,
+};
+
+const IMAGEM = new Set(['.png', '.jpg', '.jpeg']);
+const HTML = new Set(['.html', '.htm']);
+const DITA = { legenda: 'a legenda', post: 'o post', tweet: 'o tweet', blog: 'o artigo', email: 'o e-mail', mensagem: 'a mensagem' };
+const LONGAS = {
+  'blog-post': ['blog', pecasDoBlog], 'blog-seo': ['blog', pecasDoBlog],
+  'email-newsletter': ['email', pecasDoEmail], 'email-sales': ['email', pecasDoEmail],
+  'whatsapp-broadcast': ['mensagem', pecasDoWhatsapp],
+};
+
+const extensao = (item) => path.extname(item.abs).toLowerCase();
+const semExtensao = (item) => item.abs.slice(0, item.abs.length - path.extname(item.abs).length).toLowerCase();
+const ehImagem = (item) => IMAGEM.has(extensao(item));
+
+/** HTML editável: tem na lista uma imagem de mesmo nome, na mesma pasta. */
+const ehEditavel = (item, itens) => HTML.has(extensao(item)) && itens.some((i) => i.tipo === 'arquivo' && ehImagem(i) && semExtensao(i) === semExtensao(item));
+
+/** Cópia com o nome original: `de` (os mesmos bytes do arquivo) ou `texto` (o corpo tratado). */
+function copia(item, pasta, tipo, texto = null) {
+  const base = { pasta, nome: path.basename(item.abs), tipo, origem: item.rel, pastaDeOrigem: path.dirname(item.abs) };
+  return texto ? { ...base, texto } : { ...base, de: item.abs };
+}
+
+/** Tweets de uma thread escrita em blocos `TWEET n/N`; as hashtags soltas vão no fim do primeiro. */
+function daThread(corpo) {
+  const tweets = tweetsDaThread(corpo);
+  const soltas = tweets.length ? hashtagsSoltas(corpo) : [];
+  const unidades = tweets.map((t, i) => {
+    const texto = paraColar(i === 0 && soltas.length ? `${t}\n\n${soltas.join(' ')}` : t);
+    return { tipo: 'tweet', ordem: i + 1, total: tweets.length, partes: [{ nome: 'tweet', sufixo: '', ext: 'txt', tipo: 'tweet', texto }] };
+  });
+  return { unidades, temSlides: false, outros: [] };
+}
+
+/** As unidades de um arquivo de texto, pelo formato dele; `tipo`: a peça que não pode faltar; `fora`: os blocos que não entram. */
+function lerUnidades(texto, formato) {
+  if (LONGAS[formato]) return { tipo: LONGAS[formato][0], unidades: LONGAS[formato][1](texto, formato), temSlides: false, outros: [], fora: blocosFora(texto) };
+  const corpo = semServico(semFrontmatter(texto));
+  const thread = formato === 'twitter-thread' ? daThread(corpo) : null;
+  if (thread?.unidades.length) return { tipo: PRINCIPAL[formato], ...thread, fora: blocosFora(texto) };
+  return { tipo: PRINCIPAL[formato], ...pecasDoLeitor(corpo, formato), fora: blocosFora(texto, formato) };
+}
+
+/** Arquivo `.md` ou `.txt` de um formato com peças: as unidades, ou o arquivo inteiro, com aviso. */
+function separarPecas(item, texto, itens, p) {
+  const { tipo, unidades, temSlides, outros, fora } = lerUnidades(texto, item.formato);
+  const comArquivo = unidades.map((u) => ({ ...u, partes: u.partes.filter((parte) => parte.texto) })).filter((u) => u.partes.length);
+  for (const u of comArquivo) p.unidades.push({ ...u, pasta: item.canal, origem: item.rel, formato: item.formato });
+  for (const cabecalho of outros) p.avisos.push({ pasta: item.canal, texto: MSG.outroCanal(item.rel, cabecalho) });
+  const semImagem = !itens.some((i) => i.tipo === 'arquivo' && ehImagem(i) && i.formato === item.formato);
+  if (!comArquivo.length) p.avisos.push({ pasta: item.canal, texto: MSG.semPeca(DITA[tipo], item.rel) });
+  // O arquivo que vai inteiro leva todos os blocos: só há o que avisar quando ele não vai.
+  if (!comArquivo.length || (temSlides && semImagem)) p.copias.push(copia(item, item.canal, 'inteiro'));
+  else p.avisos.push(...avisoDeFora(item, fora));
+}
+
+/** Um item que existe → os produtos dele. */
+async function separarItem(item, itens, p) {
+  if (ehEditavel(item, itens)) return p.copias.push(copia(item, EDITAVEIS, 'editavel'));
+  if (!item.canal) {
+    p.avisos.push({ pasta: OUTROS, tela: MSG.semCanal(item.rel) });
+    return p.copias.push(copia(item, OUTROS, 'copia'));
+  }
+  const lido = ['.md', '.txt'].includes(extensao(item)) ? await lerItem(item.abs) : null;
+  if (lido?.tipo !== 'texto') return p.copias.push(copia(item, item.canal, ehImagem(item) ? 'imagem' : 'copia'));
+  const texto = emLf(lido.texto);
+  if (LONGAS[item.formato] || PRINCIPAL[item.formato]) return separarPecas(item, texto, itens, p);
+  // Roteiro ou artigo: o corpo, sem frontmatter e sem blocos de serviço; as linhas de rótulo ficam.
+  p.avisos.push(...avisoDeFora(item, blocosFora(texto)));
+  return p.copias.push(copia(item, item.canal, 'roteiro', fecharMd(semServico(semFrontmatter(texto)))));
+}
+
+/**
+ * @param {object[]} itens os itens da lista, já sem os arquivos de serviço:
+ *   `{ abs, rel, formato, canal, tipo }` (`tipo`: arquivo, pasta ou ausente)
+ * @returns {Promise<{ unidades: object[], copias: object[], avisos: object[] }>}
+ *   · `unidades`: `{ pasta, tipo, titulo, origem, formato, ordem, total, partes }`
+ *   · `copias`: `{ pasta, nome, tipo, origem, pastaDeOrigem, de | texto }`
+ *   · `avisos`: `{ pasta, texto, tela }` (`tela`: o texto do resumo da tela; sem `texto`, só sai lá)
+ */
+export async function separar(itens) {
+  const produtos = { unidades: [], copias: [], avisos: [] };
+  for (const item of itens.filter((i) => i.tipo === 'arquivo')) await separarItem(item, itens, produtos);
+  return produtos;
+}

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

@@ -0,0 +1,95 @@
+// Texto da entrega: o que sai do markdown num arquivo para colar, o que é bloco de serviço e as
+// seções de rótulo de um corpo. As expressões rodam linha a linha, sobre texto do usuário.
+// Spec: fase-u3a-entrega-por-canal.md, regra 6, citada pela fatia 1 (repositório do OpenCrew).
+import { rotuloDe } from '../verificar/secoes.mjs';
+import { semBom } from '../verificar/leitura.mjs';
+
+/** Sem o BOM e com LF. */
+export const emLf = (texto) => semBom(texto).replace(/\r\n?/g, '\n');
+
+/** Texto em markdown que vai para um arquivo: aparado, com uma quebra de linha no fim. */
+export function fecharMd(texto) {
+  const aparado = texto.trim();
+  return aparado ? `${aparado}\n` : '';
+}
+
+/** Texto para colar: sem espaço no fim das linhas, sem linhas em branco seguidas, aparado. */
+export const fechar = (texto) => fecharMd(texto.replace(/[ \t]+$/gm, '').replace(/\n{3,}/g, '\n\n'));
+
+/** Sem os comentários HTML (`<!-- … -->`); o que não fecha fica como está. */
+export function semComentarios(texto) {
+  let saida = '';
+  let i = 0;
+  for (;;) {
+    const abre = texto.indexOf('<!--', i);
+    const fecha = abre < 0 ? -1 : texto.indexOf('-->', abre + 4);
+    if (fecha < 0) return saida + texto.slice(i);
+    saida += texto.slice(i, abre);
+    i = fecha + 3;
+  }
+}
+
+/** Rótulo de bloco de serviço: termina em `NOTES`, `NOTE` ou `CHECKLIST`, ou é `FORMAT`. */
+export const ehServico = (rotulo) => rotulo === 'FORMAT' || /(?:^|\s)(?:NOTES?|CHECKLIST)$/.test(rotulo);
+
+/**
+ * Corpo sem os blocos de serviço: os comentários HTML e as seções de rótulo de serviço, cada uma
+ * até o próximo rótulo. As outras linhas de rótulo ficam.
+ */
+export function semServico(corpo) {
+  const linhas = [];
+  let fora = false;
+  for (const linha of semComentarios(corpo).split('\n')) {
+    const rotulo = rotuloDe(linha);
+    if (rotulo) fora = ehServico(rotulo);
+    if (!fora) linhas.push(linha);
+  }
+  return linhas.join('\n');
+}
+
+/** As seções de rótulo de um corpo, na ordem: `[{ rotulo, texto }]`; antes do primeiro, `rotulo` null. */
+export function secoesDeRotulo(corpo) {
+  const secoes = [{ rotulo: null, linhas: [] }];
+  for (const linha of corpo.split('\n')) {
+    const rotulo = rotuloDe(linha);
+    if (rotulo) secoes.push({ rotulo, linhas: [] });
+    else secoes.at(-1).linhas.push(linha);
+  }
+  return secoes.map((s) => ({ rotulo: s.rotulo, texto: s.linhas.join('\n').trim() }));
+}
+
+// O que nunca perde marcador: URL, e-mail, @usuário e #hashtag. Fica guardado enquanto a linha é
+// limpa e volta depois, igual.
+const PROTEGIDO = /(?:https?:\/\/|www\.|wa\.me\/)[^\s*]+|[\p{L}\p{N}._%+-]+@[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)+|(?<![\p{L}\p{N}_])[@#][\p{L}\p{N}_]+/gu;
+const [ABRE, FECHA] = [String.fromCharCode(0xe000), String.fromCharCode(0xe001)];
+const GUARDADO = new RegExp(`${ABRE}(\\d+)${FECHA}`, 'g');
+const LINK = /\[([^\]\n]+)\]\(\s*([^)\s]+)(?:\s+"[^"\n]*")?\s*\)/g;
+// O marcador só sai em par e colado ao texto que marca; nunca no meio de palavra.
+const NEGRITO = /\*\*(?=[^\s*])([^\n]+?)(?<=[^\s*])\*\*/g;
+const MARCADORES = [
+  NEGRITO,
+  /(?<![\p{L}\p{N}_])__(?=[^\s_])([^\n]+?)(?<=[^\s_])__(?![\p{L}\p{N}_])/gu,
+  /(?<![\p{L}\p{N}*])\*(?=[^\s*])([^*\n]+?)(?<=[^\s*])\*(?![\p{L}\p{N}*])/gu,
+  /(?<![\p{L}\p{N}_])_(?=[^\s_])([^_\n]+?)(?<=[^\s_])_(?![\p{L}\p{N}_])/gu,
+];
+
+/** `[texto](url)` vira `texto: url` (ou só a URL); negrito e itálico saem. No WhatsApp, `**x**` vira `*x*`. */
+function limparLinha(linha, whatsapp) {
+  const guardados = [];
+  const comLinks = linha.replace(LINK, (_, texto, url) => (texto.trim() === url ? url : `${texto}: ${url}`));
+  const mascarada = comLinks.replace(PROTEGIDO, (achado) => `${ABRE}${guardados.push(achado) - 1}${FECHA}`);
+  const limpa = whatsapp ? mascarada.replace(NEGRITO, '*$1*') : MARCADORES.reduce((t, rx) => t.replace(rx, '$1'), mascarada);
+  return limpa.replace(GUARDADO, (_, n) => guardados[Number(n)]);
+}
+
+/**
+ * Texto pronto para colar: as mesmas palavras, na mesma ordem, sem as linhas de rótulo, sem a
+ * linha `---`, sem os `#` de título e sem a sintaxe de negrito, itálico e link. Marcador de lista
+ * e citação ficam.
+ * @param {string} texto
+ * @param {{ whatsapp?: boolean }} [opcoes] no WhatsApp, `*x*` e `_x_` ficam e `**x**` vira `*x*`
+ */
+export function paraColar(texto, { whatsapp = false } = {}) {
+  const linhas = emLf(texto).split('\n').filter((linha) => linha.trim() !== '---' && !rotuloDe(linha));
+  return fechar(linhas.map((linha) => limparLinha(linha.replace(/^#{1,6}\s+/, ''), whatsapp)).join('\n'));
+}

package/templates/_opencrew/core/scripts/entregar.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// Entrega de uma execução: separa os arquivos aprovados por canal, com texto pronto para colar e
+// um LEIA-ME que diz o que fazer com cada arquivo.
+// Uso (na pasta do projeto): node _opencrew/core/scripts/entregar.mjs --crew "crews/<crew>"
+//   --run "<id>" --arquivo "<caminho=formato>[,<caminho=formato>…]" [--vai-publicar <canal>] [--ajuda]
+//   --arquivo: a lista do verificador (o "=formato" é opcional); entra o que estiver nela e existir.
+//   --vai-publicar: canal que a crew publica sozinha (pode repetir); o LEIA-ME avisa.
+// Grava só em crews/<crew>/output/<run>/: a pasta `entrega/` (refeita do zero a cada chamada,
+// montada em `entrega.tmp/`) e, ao lado, `verificacao-entrega.md`.
+// Última linha da saída (o runner lê esta linha): ENTREGA:OK (nenhuma pendência) ou
+// ENTREGA:INCOMPLETA (algum canal não está pronto, ou a gravação falhou).
+// Código de saída: 0 sempre que a linha ENTREGA: sai, e em --ajuda · 1 = erro de uso ou erro que
+// impediu a entrega inteira; com código 1 não há linha ENTREGA: e nada é escrito.
+// Spec: fase-u3a1-pasta-de-entrega.md (repositório do OpenCrew).
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { MSG as COMUM, erroDeUso, ehPrincipal, relativoAoProjeto } from './comum.mjs';
+import { formatarRelatorio, verificar } from './verificar.mjs';
+import { USO, lerArgs, lerLista, limpar, runValido } from './entrega/argumentos.mjs';
+import { CANAIS, OUTROS, canalDoFormato, ehCanal, ehDeServico } from './entrega/canais.mjs';
+import { separar } from './entrega/separar.mjs';
+import { nomear } from './entrega/nomes.mjs';
+import { alertasDeTamanho, frasesDePendencia, naoConferido, pendenciasPorPasta } from './entrega/pendencias.mjs';
+import { TEXTO, montarLeiame } from './entrega/leiame.mjs';
+import { gravarEntrega } from './entrega/gravar.mjs';
+
+const MSG = {
+  desconhecida: (opcao) => `Opção desconhecida: ${limpar(opcao)}.`,
+  semExecucao: (run, lista) => `Execução não encontrada: ${limpar(run)}. Execuções desta crew: ${lista.join(', ') || 'nenhuma'}.`,
+  nenhumArquivo: 'Nenhum arquivo da lista foi encontrado.',
+  deServico: (arquivo) => `${arquivo} é arquivo de serviço e não entra na entrega.`,
+  semCanal: (canal) => `Canal não encontrado nesta entrega: ${limpar(canal)}.`,
+  falhaDeEscrita: (arquivo) => `Não consegui gravar ${arquivo}. Feche o arquivo, ou espere a sincronização da pasta, e rode de novo.`,
+};
+
+const ehPasta = (p) => existsSync(p) && statSync(p).isDirectory();
+const tipoNoDisco = (p) => (!existsSync(p) ? 'ausente' : statSync(p).isDirectory() ? 'pasta' : 'arquivo');
+const execucoes = (saida) => (ehPasta(saida) ? readdirSync(saida, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort() : []);
+
+/** Erro de uso, na ordem da §6: `{ mensagem, comUso }`, ou null quando a chamada está certa. */
+function erroDeChamada(raiz, args, pedidos) {
+  if (args.desconhecida) return { mensagem: MSG.desconhecida(args.desconhecida), comUso: true };
+  const faltando = [['--crew', args.crew], ['--run', args.run], ['--arquivo', pedidos.length]].filter(([, v]) => !v).map(([opcao]) => opcao);
+  const comum = erroDeUso({ raiz, faltando, crew: args.crew, caminhos: pedidos.map((p) => p.arquivo) });
+  if (comum) return { mensagem: comum, comUso: faltando.length > 0 };
+  const crew = path.resolve(raiz, args.crew);
+  if (!existsSync(path.join(crew, 'crew.yaml'))) return { mensagem: COMUM.crewNaoEncontrada(args.crew) };
+  const saida = path.join(crew, 'output');
+  if (!runValido(args.run) || !ehPasta(path.join(saida, args.run))) return { mensagem: MSG.semExecucao(args.run, execucoes(saida)) };
+  return null;
+}
+
+/** Cada item da lista, uma vez: onde fica, se existe, se é de serviço e qual é o canal do formato. */
+async function classificar(raiz, pedidos) {
+  const itens = [];
+  const vistos = new Set();
+  for (const { arquivo, formato } of pedidos) {
+    const abs = path.resolve(raiz, arquivo);
+    if (vistos.has(`${abs}|${formato ?? ''}`)) continue;
+    vistos.add(`${abs}|${formato ?? ''}`);
+    const rel = relativoAoProjeto(raiz, arquivo);
+    itens.push({ arquivo, formato, abs, rel, tipo: tipoNoDisco(abs), servico: ehDeServico(rel), canal: await canalDoFormato(raiz, formato) });
+  }
+  return itens;
+}
+
+/** Verifica na origem, separa por canal e monta tudo o que a entrega mostra; não escreve nada. */
+async function montar(raiz, args, itens) {
+  const arquivosDaLista = itens.map((i) => (i.formato ? { arquivo: i.arquivo, formato: i.formato } : i.arquivo));
+  const verificacao = await verificar({ raiz, crew: args.crew, arquivos: arquivosDaLista, semPadraoDeBlog: true });
+  const { arquivos, avisos } = nomear(await separar(itens));
+  const pendencias = pendenciasPorPasta(raiz, itens, verificacao);
+  const presentes = new Set([...arquivos.map((a) => a.pasta), ...pendencias.keys()]);
+  const dados = {
+    crew: path.basename(path.resolve(raiz, args.crew)), run: args.run, arquivos, avisos, pendencias,
+    pastas: Object.keys(CANAIS).filter((c) => presentes.has(c)),
+    alertas: await alertasDeTamanho(raiz, itens, arquivos, verificacao),
+    naoConferido: naoConferido(raiz, itens, verificacao),
+    vaiPublicar: args.vaiPublicar,
+  };
+  return { dados, leiame: montarLeiame(dados), relatorio: `${formatarRelatorio(verificacao)}\n` };
+}
+
+/** O resumo da tela: a pasta, a situação de cada canal, o que falta, os avisos e o LEIA-ME. */
+function resumo(execucao, { crew, run, pastas, pendencias, avisos, alertas }, deServico) {
+  const comPendencia = [...pastas, OUTROS].filter((p) => pendencias.has(p));
+  const notas = [...alertas, ...deServico.map((i) => MSG.deServico(i.rel)), ...avisos.map((a) => a.tela ?? a.texto)];
+  return [
+    `Entrega da execução ${run} da crew ${crew}`,
+    `Pasta: ${execucao}/entrega`,
+    ...pastas.map((p) => `- ${CANAIS[p]}: ${pendencias.has(p) ? TEXTO.naoPronto : TEXTO.pronto}`),
+    ...frasesDePendencia(comPendencia, pendencias).flatMap((frase, i) => [frase, ...pendencias.get(comPendencia[i]).map((l) => `- ${l}`)]),
+    ...(notas.length ? ['Avisos:', ...notas.map((l) => `- ${l}`)] : []),
+    `LEIA-ME: ${execucao}/entrega/LEIA-ME.md`,
+  ];
+}
+
+async function entregar(raiz, args, itens, escrever) {
+  const validos = itens.filter((i) => !i.servico);
+  const execucao = relativoAoProjeto(raiz, path.join(args.crew, 'output', args.run));
+  const { dados, leiame, relatorio } = await montar(raiz, args, validos);
+  const falha = await gravarEntrega(path.resolve(raiz, execucao), dados.arquivos, { leiame, relatorio });
+  if (falha) {
+    escrever(MSG.falhaDeEscrita(relativoAoProjeto(raiz, falha)));
+    escrever('ENTREGA:INCOMPLETA');
+    return 0;
+  }
+  for (const linha of resumo(execucao, dados, itens.filter((i) => i.servico))) escrever(linha);
+  escrever(dados.pendencias.size ? 'ENTREGA:INCOMPLETA' : 'ENTREGA:OK');
+  return 0;
+}
+
+/**
+ * @param {string[]} argv
+ * @param {object} [deps] `cwd` (a pasta do projeto) e `escrever`
+ * @returns {Promise<number>} 0 = a linha `ENTREGA:` saiu (ou `--ajuda`) · 1 = erro de uso, ou erro
+ *   que impediu a entrega inteira (uma linha em PT-BR, sem linha `ENTREGA:`, nada escrito)
+ */
+export async function main(argv, { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`) } = {}) {
+  const args = lerArgs(argv);
+  const sair = (...linhas) => linhas.forEach((l) => escrever(l)) ?? 1;
+  if (args.ajuda) return sair(USO) && 0;
+  const pedidos = lerLista(args.arquivos);
+  const erro = erroDeChamada(cwd, args, pedidos);
+  if (erro) return sair(erro.mensagem, ...(erro.comUso ? [USO] : []));
+  try {
+    const itens = await classificar(cwd, pedidos);
+    const validos = itens.filter((i) => !i.servico);
+    if (!validos.some((i) => i.tipo === 'arquivo')) return sair(MSG.nenhumArquivo);
+    const canais = new Set(validos.map((i) => i.canal));
+    const fora = args.vaiPublicar.find((canal) => !ehCanal(canal) || !canais.has(canal));
+    if (fora !== undefined) return sair(MSG.semCanal(fora));
+    return await entregar(cwd, args, itens, escrever);
+  } catch (erroGeral) {
+    return sair(`Não consegui montar a entrega: ${limpar(erroGeral?.message ?? erroGeral)}`);
+  }
+}
+
+if (ehPrincipal(import.meta.url)) {
+  main(process.argv.slice(2)).then((code) => { process.exitCode = code; });
+}

package/templates/_opencrew/core/scripts/verificar/pecas.mjs

@@ -12,7 +12,7 @@ export const FORMATOS_DA_TABELA = [...BLOG, 'instagram-feed', 'linkedin-post', '
 const FORMATO_DA_PECA = { legenda: 'instagram-feed', slides: 'instagram-feed', post: 'linkedin-post', tweet: 'twitter-post' };
 // O que cada rótulo faz, por formato declarado. Sem formato declarado valem todos: os
 // inconfundíveis abrem peça e os outros só se juntam a uma peça já aberta.
-const ROTULOS = {
+export const ROTULOS = {
   'instagram-feed': { CAPTION: 'legenda', SLIDES: 'slides', HASHTAGS: 'hashtags' },
   'linkedin-post': { HOOK: 'post', BODY: 'parte', INSIGHTS: 'parte', CTA: 'parte', HASHTAGS: 'hashtags' },
   'twitter-post': { TWEET: 'tweet' },
@@ -159,8 +159,8 @@ function fechar(entradas) {
  * Lê as peças de um texto, na ordem em que aparecem.
  * @param {string} texto conteúdo de um arquivo `.md` ou `.txt`, já sem o BOM
  * @param {string|null} [formato] formato declarado (`caminho=formato`); null = sem formato declarado
- * @param {{ formatoDeBlog?: string }} [opcoes] sem formato declarado, o formato em que o título do
- *   frontmatter é medido (`--formato`)
+ * @param {{ formatoDeBlog?: string|null }} [opcoes] sem formato declarado, o formato em que o
+ *   título do frontmatter é medido (`--formato`); null = não é peça (a entrega chama assim)
  * @returns {object[]} peças `{ tipo, formato, texto, origem, cabecalho, ordem }`
  *   · `tipo`: titulo, meta, legenda, hashtags, slides, post ou tweet
  *   · `formato`: o formato cujo limite vale para a peça
@@ -180,7 +180,7 @@ export function lerPecas(texto, formato = null, { formatoDeBlog = 'blog-post' }
   if (BLOG.includes(tabela)) pecasDoBlog(e, texto, trechos, tabela, true);
   else {
     // Fora da tabela os rótulos não são lidos; sem formato declarado, título no frontmatter é blog.
-    if (formato == null) pecasDoBlog(e, texto, trechos, formatoDeBlog, false);
+    if (formato == null && formatoDeBlog) pecasDoBlog(e, texto, trechos, formatoDeBlog, false);
     const rotulos = tabela ? ROTULOS[tabela] : formato == null ? TODOS_OS_ROTULOS : {};
     for (const trecho of trechos) pecasDoTrecho(e, trecho, rotulos);
     pecaDoArquivoInteiro(e, marcas);

package/templates/_opencrew/core/scripts/verificar/secoes.mjs

@@ -110,18 +110,36 @@ function abrir(trechos, trecho) {
   return trechos.at(-1);
 }
 
+/**
+ * Peças a que algum cabeçalho de baixo do cabeçalho de nível 1 da posição `i` é candidato; a
+ * seção dele vai até o próximo de nível 1 ou até um rótulo.
+ */
+function tiposSobOTitulo(marcas, i, formato) {
+  const tipos = new Set();
+  let pilha = [marcas[i]];
+  for (let j = i + 1; j < marcas.length && !marcas[j].rotulo && marcas[j].nivel !== 1; j++) {
+    if (!marcas[j].nivel) continue;
+    pilha = pilha.filter((c) => c.nivel < marcas[j].nivel);
+    for (const tipo of candidaturas(marcas[j].norm, pilha.map((c) => c.norm), formato)) tipos.add(tipo);
+    pilha.push(marcas[j]);
+  }
+  return tipos;
+}
+
 /**
  * Percorre as marcas e devolve os trechos, na ordem do texto: `{ rotulo, linhas }` para cada
  * linha de rótulo e `{ titulo, tipos, canal, linhas }` para cada cabeçalho candidato a peça
  * (`canal`: na seção de hashtags, o formato do canal que o cabeçalho cita; senão null).
  * A seção de cabeçalho vai até o próximo cabeçalho do mesmo nível ou acima, ou até um rótulo; a
  * de rótulo, até o próximo rótulo ou até um cabeçalho candidato (regra 2).
+ * O cabeçalho de nível 1 que tem, abaixo dele, outro candidato à mesma peça é o título do
+ * arquivo: não abre essa peça (fase-u3a1-pasta-de-entrega.md, regra 4).
  */
 export function lerTrechos(marcas, formato) {
   const trechos = [];
   let pilha = []; // cabeçalhos abertos, do mais externo ao mais interno
   let rotulo = null; // seção de rótulo aberta
-  for (const m of marcas) {
+  for (const [i, m] of marcas.entries()) {
     if (m.rotulo) {
       pilha = [];
       rotulo = abrir(trechos, { rotulo: m.rotulo });
@@ -129,7 +147,9 @@ export function lerTrechos(marcas, formato) {
     }
     if (m.nivel) {
       pilha = pilha.filter((c) => c.nivel < m.nivel);
-      const tipos = candidaturas(m.norm, pilha.map((c) => c.norm), formato);
+      const todos = candidaturas(m.norm, pilha.map((c) => c.norm), formato);
+      const abaixo = m.nivel === 1 && todos.length ? tiposSobOTitulo(marcas, i, formato) : null;
+      const tipos = abaixo ? todos.filter((tipo) => !abaixo.has(tipo)) : todos;
       const canal = tipos[0] === 'hashtags' ? canalDe(m.norm) : null;
       const trecho = tipos.length ? abrir(trechos, { titulo: m.titulo, tipos, canal }) : null;
       pilha.push({ nivel: m.nivel, norm: m.norm, trecho });

package/templates/_opencrew/core/scripts/verificar.mjs

@@ -135,6 +135,8 @@ function resumir(arquivos, naoTexto, notas) {
  * @param {Array<string|{ arquivo: string, formato?: string }>} o.arquivos caminho (sem formato
  *   declarado) ou `{ arquivo, formato }` (formato declarado)
  * @param {string} [o.formato] limites de blog do item sem formato declarado que tem título no frontmatter
+ * @param {boolean} [o.semPadraoDeBlog] só a entrega passa true: no item sem formato declarado, o
+ *   título do frontmatter não é medido como blog (fase-u3a1-pasta-de-entrega.md, regra 17)
  * @param {Function} [o.regraDeTeste] SÓ PARA TESTE: regra extra, chamada com `{ arquivo, formato,
  *   texto }` em cada arquivo de texto; serve para simular uma regra que lança erro
  * @returns {Promise<object>} `{ arquivos, naoTexto, notas, bloqueios, alertas, naoMedidos, status }`
@@ -144,11 +146,11 @@ function resumir(arquivos, naoTexto, notas) {
  *   · `naoTexto`: caminhos que não são texto · `naoMedidos`: linhas "Não medido"/"Não verificado"
  *   · `status`: OK, BLOQUEADA ou AGUARDANDO_USUARIO
  */
-export async function verificar({ raiz, crew, arquivos, formato = 'blog-post', regraDeTeste }) {
+export async function verificar({ raiz, crew, arquivos, formato = 'blog-post', semPadraoDeBlog = false, regraDeTeste }) {
   const entradas = semRepetidas(raiz, arquivos.map(normalizar));
   const erro = erroDeUso({ raiz, crew, caminhos: entradas.map((e) => e.arquivo) });
   if (erro) throw new Error(erro);
-  const ctx = await prepararContexto(raiz, crew, formato);
+  const ctx = await prepararContexto(raiz, crew, semPadraoDeBlog ? null : formato);
   const resultado = [];
   const naoTexto = [];
   for (const entrada of entradas) {