@aksp/opencrew 1.9.0 → 1.11.0

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

@@ -17,7 +17,7 @@ const ehPasta = async (p) => fs.stat(p).then((s) => s.isDirectory(), () => false
 /** Grava um arquivo que ainda não existe ali: se existir, falha (nunca por cima). */
 async function gravarNovo(alvo, a) {
   await fs.mkdir(path.dirname(alvo), { recursive: true });
-  if (a.texto != null) await fs.writeFile(alvo, a.texto, { encoding: 'utf8', flag: 'wx' });
+  if ((a.bytes ?? a.texto) != null) await fs.writeFile(alvo, a.bytes ?? a.texto, { encoding: 'utf8', flag: 'wx' });
   else await fs.copyFile(a.de, alvo, constants.COPYFILE_EXCL);
 }
 

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

@@ -0,0 +1,104 @@
+// Documentos na entrega: o item cujo formato tem a plataforma `documento` vai para a pasta
+// `documentos/`. Texto (`.md` ou `.txt`) vira Word, inteiro, com o perfil de documento oficial do
+// projeto, se existir: os mesmos bytes que o `documento.mjs` grava para o mesmo texto e o mesmo
+// perfil. Outro tipo de arquivo é copiado como está, com aviso. Erro ao converter (inclusive
+// perfil inválido) é pendência de `documentos`, que nunca vira ressalva: os outros canais seguem.
+// Este módulo só lê: quem grava é `gravar.mjs`.
+// Spec: fase-u3b-documento-word.md, decisão 9, regra 12 e §6 (repositório do OpenCrew).
+import { existsSync, promises as fs, statSync } from 'node:fs';
+import path from 'node:path';
+import { PERFIL, gerarDocx, lerPerfilDoProjeto } from '../documento.mjs';
+import { limpar } from './argumentos.mjs';
+
+/** A pasta da entrega e o tipo do arquivo que é (ou vai virar) um Word. */
+export const DOCUMENTOS = 'documentos';
+export const WORD = 'documento';
+const TEXTO = /\.(md|txt)$/i;
+
+export const MSG = {
+  copiado: (arquivo) => `${arquivo}: só converto .md ou .txt em Word. Copiei o arquivo como está.`,
+  erro: (arquivo, motivo) => `Não consegui gerar o Word de ${arquivo}: ${limpar(motivo).replace(/\.+$/, '')}.`,
+  aviso: (arquivo, aviso) => `${arquivo}: ${aviso}`,
+  semPerfil: 'Sem papel timbrado: este projeto não tem perfil de documento oficial. Para criar o seu: node _opencrew/core/scripts/documento.mjs --criar-perfil',
+  semTexto: 'o arquivo não tem texto para converter',
+  naoUtf8: 'o arquivo não está em UTF-8',
+};
+/** A linha de "O que não foi conferido" da entrega que tem um Word. */
+export const NAO_CONFERIDO = 'Como o documento abre no Word.';
+
+/** O tipo do arquivo em `documentos/`: texto que vira Word, ou cópia como está. */
+export const tipoDoDocumento = (arquivo) => (TEXTO.test(arquivo) ? WORD : 'copia');
+export const naoConferidoDoWord = (arquivos) => (arquivos.some((a) => a.pasta === DOCUMENTOS && a.tipo === WORD) ? [NAO_CONFERIDO] : []);
+
+/** O perfil do projeto, lido uma vez: `{}` sem perfil, `{ perfil, logotipo }` ou `{ erro }`. */
+async function perfilDoProjeto(raiz) {
+  const arquivo = path.join(raiz, PERFIL);
+  if (!existsSync(arquivo) || !statSync(arquivo).isFile()) return {};
+  try {
+    return await lerPerfilDoProjeto(raiz, PERFIL);
+  } catch (falha) {
+    return { erro: falha?.message ?? falha };
+  }
+}
+
+/** O texto do arquivo, em UTF-8; null quando os bytes não são UTF-8. */
+function decodificar(bytes) {
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+/** O Word de um texto: `{ bytes, avisos }`, ou `{ erro }` com o motivo. */
+async function converter(copia, lido, gerar) {
+  if (lido.erro) return { erro: lido.erro };
+  try {
+    const texto = decodificar(await fs.readFile(copia.de));
+    if (texto === null) return { erro: MSG.naoUtf8 };
+    const documento = gerar({ texto, perfil: lido.perfil, logotipo: lido.logotipo });
+    return documento.vazio ? { erro: MSG.semTexto } : documento;
+  } catch (falha) {
+    return { erro: falha?.message ?? falha };
+  }
+}
+
+/** A cópia do texto vira o arquivo Word: cada origem é um grupo, para dois nomes iguais não se perderem. */
+const comoWord = (copia, bytes) => ({ ...copia, nome: copia.nome.replace(TEXTO, '.docx'), de: null, bytes, pastaDeOrigem: copia.de });
+const aviso = (texto) => ({ pasta: DOCUMENTOS, texto });
+const pendencia = (linha) => ({ linha, chave: null, preencher: null });
+
+/** Um arquivo de `documentos/` → o que entra em `copias`, `avisos` ou `pendencias`. */
+async function tratar(copia, lido, gerar, saida) {
+  if (copia.tipo !== WORD) {
+    saida.avisos.push(aviso(MSG.copiado(copia.origem)));
+    return saida.copias.push(copia);
+  }
+  const r = await converter(copia, lido, gerar);
+  if (r.erro) return saida.pendencias.push(pendencia(MSG.erro(copia.origem, r.erro)));
+  saida.avisos.push(...r.avisos.map((a) => aviso(MSG.aviso(copia.origem, a))));
+  return saida.copias.push(comoWord(copia, r.bytes));
+}
+
+/**
+ * Converte os textos que `separar` pôs em `documentos/`. Sem nenhum, devolve o que recebeu e não
+ * lê o perfil.
+ * @param {string} raiz a pasta do projeto
+ * @param {{ unidades: object[], copias: object[], avisos: object[] }} produtos o que `separar` devolve
+ * @param {function} [gerar] quem monta o Word (`gerarDocx`); os testes trocam para injetar um erro
+ * @returns {Promise<{ produtos: object, pendencias: object[] }>} `produtos`: os mesmos, com o Word
+ *   (`{ …, nome: '<nome>.docx', bytes }`) no lugar de cada texto convertido e os avisos da conversão ·
+ *   `pendencias`: uma por texto que não foi convertido, `{ linha, chave: null, preencher: null }`
+ */
+export async function converterDocumentos(raiz, produtos, gerar = gerarDocx) {
+  const saida = { copias: [], avisos: [...produtos.avisos], pendencias: [] };
+  if (!produtos.copias.some((c) => c.pasta === DOCUMENTOS)) return { produtos, pendencias: [] };
+  const lido = produtos.copias.some((c) => c.pasta === DOCUMENTOS && c.tipo === WORD) ? await perfilDoProjeto(raiz) : {};
+  for (const copia of produtos.copias) {
+    if (copia.pasta === DOCUMENTOS) await tratar(copia, lido, gerar, saida);
+    else saida.copias.push(copia);
+  }
+  // Sem perfil, o Word sai sem cabeçalho: a entrega diz, para ninguém procurar um timbre que não existe.
+  if (!lido.perfil && !lido.erro && saida.copias.some((c) => c.pasta === DOCUMENTOS && c.bytes)) saida.avisos.push(aviso(MSG.semPerfil));
+  return { produtos: { ...produtos, copias: saida.copias, avisos: saida.avisos }, pendencias: saida.pendencias };
+}

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

@@ -25,10 +25,10 @@ async function limparSobras({ entrega, tmp, antiga }) {
   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. */
+/** Grava um arquivo da entrega na pasta temporária: os bytes ou o texto gerados, 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');
+  if ((a.bytes ?? a.texto) != null) await fs.writeFile(destino, a.bytes ?? a.texto, 'utf8');
   else await fs.copyFile(a.de, destino);
 }
 
@@ -51,7 +51,7 @@ async function trocar({ entrega, tmp, antiga }, passo) {
 /**
  * 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 {object[]} arquivos `{ pasta, nome, texto | bytes | de }`
  * @param {{ leiame: string, relatorio: string }} textos
  * @returns {Promise<string|null>} null quando gravou tudo; senão, o caminho que não foi gravado
  */

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

@@ -5,7 +5,7 @@
 // (ressalvas, a cópia e "Sobre esta pasta"), no repositório do OpenCrew.
 import { CANAIS, EDITAVEIS, OUTROS } from './canais.mjs';
 import { frasesDePendencia } from './pendencias.mjs';
-import { passosDe } from './passos.mjs';
+import { NAO_EDITE_O_WORD, passosDe } from './passos.mjs';
 
 export const TEXTO = {
   vaiPublicar: 'Esta crew publica este canal sozinha. Antes de postar à mão, confira se já saiu.',
@@ -64,7 +64,8 @@ function secaoDoCanal(d, pasta) {
   // Na cópia, o canal que não foi copiado traz só a situação e o que falta.
   if (d.ehCopia && pendencias.length) return secao(CANAIS[pasta], [situacao, ...bloco('Pendências:', pendencias)]);
   const arquivos = d.arquivos.filter((a) => a.pasta === pasta);
-  const passos = passosDe(pasta, arquivos, pendencias.length > 0, d.ressalvas.has(pasta)).map((p, i) => `${i + 1}. ${p}`);
+  const daPasta = passosDe(pasta, arquivos, pendencias.length > 0, d.ressalvas.has(pasta));
+  const passos = daPasta.filter((p) => !d.ehCopia || p !== NAO_EDITE_O_WORD).map((p, i) => `${i + 1}. ${p}`);
   return secao(CANAIS[pasta], [
     ...(d.vaiPublicar.includes(pasta) ? [TEXTO.vaiPublicar] : []),
     situacao,

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

@@ -7,7 +7,9 @@
 export const ANTES_DE_POSTAR = 'Antes de postar, resolva o que está em Pendências. Corrija no arquivo de origem e peça para montar a entrega de novo: o que você mudar nesta pasta se perde.';
 /** O primeiro passo do canal entregue com ressalva. */
 export const CONFIRA_AS_RESSALVAS = 'Antes de postar, confira as ressalvas em "Antes de usar".';
-const MARKDOWN = 'Este texto está em markdown: se o seu editor não aceitar, ajuste títulos, negrito e links depois de colar.';
+/** O passo de `documentos` que só vale na pasta da entrega (a cópia não é refeita). Spec: fase-u3b-documento-word.md, §6. */
+export const NAO_EDITE_O_WORD = 'Não edite o Word dentro desta pasta: ela é refeita a cada entrega. Para mexer, copie o arquivo para outra pasta do projeto.';
+const MARKDOWN ='Este texto está em markdown: se o seu editor não aceitar, ajuste títulos, negrito e links depois de colar.';
 
 // Cada passo: [o que o faz aparecer, o texto]. null = sempre que o canal tem arquivo; um tipo de
 // arquivo = só quando a entrega tem arquivo desse tipo no canal; `tipo:um` e `tipo:varios` = só
@@ -58,6 +60,12 @@ const PASSOS = {
     [null, 'Confira e publique.'],
   ],
   youtube: [['roteiro', '`youtube/{arquivo}` é o roteiro para gravar: não é texto para colar.']],
+  documentos: [
+    ['documento', 'Abra `documentos/{arquivo}` no Word e confira: cabeçalho, páginas, tabelas e assinaturas.'],
+    ['documento', NAO_EDITE_O_WORD],
+    ['documento', 'Para ter um PDF: abra o documento no Word e use Arquivo → Salvar como → PDF.'],
+    ['documento', 'O Word é uma cópia do texto. O que você mudar nele não volta sozinho: altere o texto e gere de novo.'],
+  ],
 };
 // "texto": o roteiro e o arquivo que foi inteiro (carrossel em texto, peça não encontrada).
 const TIPOS = { texto: ['roteiro', 'inteiro'] };
@@ -100,5 +108,7 @@ function doQuadro(pasta, arquivos) {
 export function passosDe(pasta, arquivos, comPendencia = false, comRessalva = false) {
   const passos = doQuadro(pasta, arquivos);
   const antes = comPendencia ? ANTES_DE_POSTAR : comRessalva ? CONFIRA_AS_RESSALVAS : null;
-  return antes && passos.length ? [antes, ...passos] : passos;
+  // Documento não se posta: imprime-se, assina-se, protocola-se.
+  const frase = pasta === 'documentos' ? antes?.replace('Antes de postar', 'Antes de usar') : antes;
+  return frase && passos.length ? [frase, ...passos] : passos;
 }

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

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { lerItem } from '../verificar/arquivos.mjs';
 import { semFrontmatter } from '../verificar/leitura.mjs';
 import { EDITAVEIS, OUTROS } from './canais.mjs';
+import { DOCUMENTOS, tipoDoDocumento } from './documentos.mjs';
 import { avisoDeFora, blocosFora } from './fora.mjs';
 import { PRINCIPAL, hashtagsSoltas, pecasDoLeitor } from './leitor.mjs';
 import { pecasDoBlog, pecasDoEmail, pecasDoWhatsapp, tweetsDaThread } from './longas.mjs';
@@ -82,6 +83,8 @@ async function separarItem(item, itens, p) {
     p.avisos.push({ pasta: OUTROS, tela: MSG.semCanal(item.rel) });
     return p.copias.push(copia(item, OUTROS, 'copia'));
   }
+  // Documento oficial: vai inteiro, sem procura de peças; `documentos.mjs` converte o texto em Word.
+  if (item.canal === DOCUMENTOS) return p.copias.push(copia(item, DOCUMENTOS, tipoDoDocumento(item.abs)));
   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);

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

@@ -11,6 +11,8 @@
 //   --aceitar-pendencias: as pendências deste momento viram ressalvas ("entregar assim mesmo"); a
 //     ressalva vale enquanto a pendência dela existir: a que some sai do `ressalvas.json`.
 //   --vai-publicar: canal que a crew publica sozinha (pode repetir); o LEIA-ME avisa.
+// Item de formato com a plataforma `documento` (`.md` ou `.txt`) sai em `entrega/documentos/`, em
+// Word, com o perfil de documento oficial do projeto (fase-u3b-documento-word.md, regra 12).
 // Grava em crews/<crew>/output/<run>/: a pasta `entrega/` (refeita do zero a cada chamada, montada
 // em `entrega.tmp/`), `verificacao-entrega.md`, `ressalvas.json` (as pendências aceitas que ainda
 // existem) e `copia.json` (o retrato do que foi copiado, para a comparação seguinte). Fora
@@ -29,6 +31,7 @@ import { formatarRelatorio, verificar } from './verificar.mjs';
 import { USO, lerArgs, lerLista, limpar, runValido } from './entrega/argumentos.mjs';
 import { CANAIS, canalDoFormato, ehCanal, ehDeServico } from './entrega/canais.mjs';
 import { MSG as DESTINO, escolherDestino, validarDestino } from './entrega/destino.mjs';
+import { DOCUMENTOS, converterDocumentos, naoConferidoDoWord } from './entrega/documentos.mjs';
 import { MSG as COPIA, guardar } from './entrega/guardar.mjs';
 import { gravarEntrega } from './entrega/gravar.mjs';
 import { montarLeiame } from './entrega/leiame.mjs';
@@ -84,15 +87,18 @@ async function classificar(raiz, pedidos) {
 async function montar(raiz, args, itens, aceitas) {
   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 separados = await converterDocumentos(raiz, await separar(itens), args.gerarDocx);
+  const { arquivos, avisos } = nomear(separados.produtos);
   const todas = pendenciasPorPasta(raiz, itens, verificacao);
+  // O texto que não virou Word é pendência de `documentos` (fase-u3b-documento-word.md, regra 12).
+  if (separados.pendencias.length) todas.set(DOCUMENTOS, [...(todas.get(DOCUMENTOS) ?? []), ...separados.pendencias]);
   const presentes = new Set([...arquivos.map((a) => a.pasta), ...todas.keys()]);
   const dados = {
     crew: path.basename(path.resolve(raiz, args.crew)), run: args.run, arquivos, avisos,
     ...separarPendencias(todas, aceitas, args.aceitar),
     pastas: Object.keys(CANAIS).filter((c) => presentes.has(c)),
     alertas: await alertasDeTamanho(raiz, itens, arquivos, verificacao),
-    naoConferido: naoConferido(raiz, itens, verificacao),
+    naoConferido: [...naoConferido(raiz, itens, verificacao), ...naoConferidoDoWord(arquivos)],
     vaiPublicar: args.vaiPublicar,
   };
   return { dados, relatorio: `${formatarRelatorio(verificacao)}\n` };
@@ -137,12 +143,13 @@ async function entregar(raiz, args, itens, escrever) {
 
 /**
  * @param {string[]} argv
- * @param {object} [deps] `cwd` (a pasta do projeto) e `escrever`
+ * @param {object} [deps] `cwd` (a pasta do projeto), `escrever` e `gerarDocx` (quem monta o Word
+ *   de um documento oficial; sem ele, o do `documento.mjs`)
  * @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);
+export async function main(argv, { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`), gerarDocx } = {}) {
+  const args = { ...lerArgs(argv), gerarDocx };
   const sair = (...linhas) => linhas.forEach((l) => escrever(l)) ?? 1;
   if (args.ajuda) return sair(USO) && 0;
   const pedidos = lerLista(args.arquivos);

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

@@ -12,6 +12,8 @@ const MARCADORES = new Set(['prefira', 'preferir', 'use', 'usar', 'utilize', 'ut
 const NEGACOES = new Set('nao nunca nem jamais sem evite evitar proibido proibida proibidos proibidas vetado vetada parar pare deixar deixe'.split(' '));
 // Com estas expressões a linha está escrita ao contrário: todos os termos continuam proibidos.
 const SEM_TROCA = /(?<![\p{L}\p{N}])(?:em vez de|ao inves de|no lugar de)(?![\p{L}\p{N}])/u;
+// Começo de um item de lista: `-`, `*`, `+` ou numerado.
+const MARCA_DE_ITEM = /^\s*(?:[-*+]|\d{1,3}[.)])\s+/;
 
 /** Fichas da linha, na ordem: termos entre aspas, e palavras e setas de fora das aspas. */
 function fichas(linha) {
@@ -74,9 +76,32 @@ function itensDaSecao(texto) {
   const inicio = titulos.findIndex((t) => t && semAcento(t[2]).replace(/^[^\p{L}\p{N}]+/u, '').startsWith('proibicoes explicitas'));
   if (inicio < 0) return [];
   const acima = new RegExp(`^#{1,${titulos[inicio][1].length}}\\s`);
-  const resto = linhas.slice(inicio + 1);
-  const fim = resto.findIndex((l) => acima.test(l) || l.trim() === '---');
-  return resto.slice(0, fim < 0 ? resto.length : fim).filter((l) => /^\s*(?:[-*+]|\d{1,3}[.)])\s+/.test(l));
+  const fim = linhas.findIndex((l, i) => i > inicio && (acima.test(l) || l.trim() === '---'));
+  const daSecao = linhas.map((texto, indice) => ({ texto, indice })).slice(inicio + 1, fim < 0 ? linhas.length : fim);
+  return daSecao.filter((l) => MARCA_DE_ITEM.test(l.texto));
+}
+
+/**
+ * Item que o usuário deixou para o revisor: termina em "(revisão humana)" ou começa por "Sem trava
+ * automática". Não é trava de texto nem pendência. Spec: fase-u4a-conserto-de-crews.md, regra 8.
+ */
+export function ehRevisaoHumana(linha) {
+  const item = semAcento(linha.replace(MARCA_DE_ITEM, '')).trim();
+  return item.endsWith('(revisao humana)') || item.startsWith('sem trava automatica');
+}
+
+/**
+ * Os itens da seção de proibições, numerados a partir de 1 na ordem do arquivo.
+ * @returns {Array<{ n: number, indice: number, texto: string, pendente: boolean }>} `indice`: a
+ *   linha no arquivo · `texto`: o item sem a marca de lista · `pendente`: sem termo entre aspas e
+ *   sem a marca de revisão humana
+ */
+export function itensDeProibicao(texto) {
+  return itensDaSecao(texto).map((l, i) => {
+    const { proibidos, preferidos } = lerLinha(l.texto);
+    const pendente = !proibidos.length && !preferidos.length && !ehRevisaoHumana(l.texto);
+    return { n: i + 1, indice: l.indice, texto: l.texto.replace(MARCA_DE_ITEM, '').trim(), pendente };
+  });
 }
 
 /**
@@ -88,9 +113,9 @@ export async function lerProibicoes(raiz, crew) {
   const arquivo = path.resolve(raiz, crew, '_memory', 'memories.md');
   const r = { existe: existsSync(arquivo), termos: [], preferidos: [], semAspas: 0 };
   if (!r.existe) return r;
-  for (const linha of itensDaSecao(await lerTexto(arquivo))) {
+  for (const { texto: linha } of itensDaSecao(await lerTexto(arquivo))) {
     const { proibidos, preferidos } = lerLinha(linha);
-    if (!proibidos.length && !preferidos.length) r.semAspas += 1;
+    if (!proibidos.length && !preferidos.length && !ehRevisaoHumana(linha)) r.semAspas += 1;
     r.termos.push(...proibidos);
     r.preferidos.push(...preferidos);
   }