@aksp/opencrew 1.11.0 → 1.13.0

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

@@ -2,7 +2,8 @@
 // Caminho da execução de uma crew: diz onde cada passo grava, de onde lê e se o arquivo gravado
 // está lá. Quem calcula é este script, igual em qualquer sistema — a IA não monta o caminho.
 // Uso (na pasta do projeto): node _opencrew/core/scripts/caminho.mjs <crew> <ação> --run <id> [opções]
-//   pasta    --run <id>                       cria crews/<crew>/output/<id>/
+//   pasta    [--run <id>]                     cria crews/<crew>/output/<id>/; sem --run, o id é a
+//                                             data e a hora do computador (AAAA-MM-DD-HHmmss)
 //   saida    --run <id> --arquivo <declarado> onde o passo grava (abre a pasta de versão seguinte)
 //   entrada  --run <id> --arquivo <declarado> a saída mais nova desse arquivo
 //   conferir --arquivo <caminho já resolvido> [--secoes N] [--tldr]
@@ -17,7 +18,7 @@
 import path from 'node:path';
 import { MSG, dentroDoProjeto, ehPrincipal, realDentroDe } from './comum.mjs';
 import { USO, erroDeArgumentos, lerArgs, limpar } from './caminho/argumentos.mjs';
-import { MOTIVO, daMaisNova, motivoDeReprovacao, naExecucao, normalizar, proximaVersao } from './caminho/nucleo.mjs';
+import { MOTIVO, daMaisNova, motivoDeReprovacao, naExecucao, normalizar, novoRun, proximaVersao } from './caminho/nucleo.mjs';
 import { criarPasta, ehPasta, lerTexto, pastasDe, temConteudo } from './caminho/disco.mjs';
 
 const ok = (caminho) => `CAMINHO:OK ${caminho}`;
@@ -31,7 +32,8 @@ const reprovado = (motivo) => `CAMINHO:REPROVADO ${motivo}`;
  */
 function erroDoArquivo(raiz, crew, { acao, run, arquivo }) {
   if (!dentroDoProjeto(raiz, arquivo)) return MSG.foraDoProjeto(limpar(arquivo));
-  const local = acao === 'conferir' ? null : naExecucao(arquivo, crew, run);
+  // `pasta` não usa arquivo, e `conferir` recebe o caminho já resolvido: nenhum dos dois o põe na execução.
+  const local = acao === 'conferir' || acao === 'pasta' ? null : naExecucao(arquivo, crew, run);
   if (!local) return null;
   if (!local.nome) return `Falta o nome do arquivo em --arquivo: ${limpar(arquivo)}`;
   const execucao = path.resolve(raiz, 'crews', crew, 'output', run);
@@ -88,23 +90,24 @@ function conferir(raiz, { arquivo, secoes, tldr }) {
   return motivo ? reprovado(motivo) : ok(caminho);
 }
 
-function responder(raiz, crew, args) {
+function responder(raiz, crew, args, agora) {
   if (args.acao === 'saida') return saida(raiz, crew, args);
   if (args.acao === 'entrada') return entrada(raiz, crew, args);
   if (args.acao === 'conferir') return conferir(raiz, args);
-  const pasta = `crews/${crew}/output/${args.run}`;
+  const run = args.run || novoRun(agora(), pastasDe(path.resolve(raiz, 'crews', crew, 'output')));
+  const pasta = `crews/${crew}/output/${run}`;
   criarPasta(path.resolve(raiz, pasta));
   return ok(pasta);
 }
 
 /**
  * @param {string[]} argv
- * @param {object} [deps] `cwd` (a pasta do projeto) e `escrever`
+ * @param {object} [deps] `cwd` (a pasta do projeto), `escrever` e `agora` (o relógio, para o id da execução)
  * @returns {number} 0 = a linha `CAMINHO:` saiu · 1 = erro de uso, ou falha ao ler ou criar pasta
  *   (a linha de uso e o motivo, ou só o erro; sem linha `CAMINHO:`)
  */
 export function main(argv, deps = {}) {
-  const { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`) } = deps;
+  const { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`), agora = () => new Date() } = deps;
   const args = lerArgs(argv);
   const local = localizar(cwd, args);
   if (local.erro) {
@@ -113,7 +116,7 @@ export function main(argv, deps = {}) {
     return 1;
   }
   try {
-    escrever(responder(cwd, local.crew, args));
+    escrever(responder(cwd, local.crew, args, agora));
     return 0;
   } catch (erro) {
     escrever(`Não consegui resolver o caminho: ${limpar(erro?.message ?? erro)}`);

package/templates/_opencrew/core/scripts/conferir-fontes/relatorio.mjs

@@ -7,7 +7,8 @@ const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
 
 export const MSG = {
   nadaACorrigir: 'Nada a corrigir.',
-  corrigidos: (n) => `${plural(n, 'caminho corrigido', 'caminhos corrigidos')} (cópia .bak ao lado de cada arquivo alterado).\n`,
+  corrigido: (arquivo, copia) => `Corrigi: ${arquivo} (cópia: ${copia})`,
+  comoCorrigir: 'Para trocar os caminhos que têm sugestão, rode de novo com --corrigir (cada arquivo alterado ganha uma cópia).',
   semCorrecaoAutomatica: (n) => `Não há correção automática para ${n} pendência(s): escolha um candidato ou corrija o caminho na crew.`,
   buscaParcial: (limite) => `Procurei só nos primeiros ${limite} itens do projeto; pode existir um arquivo com esse nome que eu não vi.`,
   linkParaFora: (arquivo) => `Não corrigi \`${arquivo}\`: é um link que aponta para fora da crew. O caminho citado nele continua como estava.`,
@@ -59,6 +60,7 @@ export function formatar(r) {
   }
   if (apontados.length) linhas.push(''); // sem pendência nem alerta, uma linha em branco só
   const alertas = contar('nao-portatil') + contar('nao-conferido');
-  linhas.push(`**Resumo: ${r.refs.length} fontes — ${contar('ok')} ok, ${contar('faltando')} pendentes, ${alertas} alertas**`, '');
+  const pendentes = contar('faltando');
+  linhas.push(`**Resumo: ${plural(r.refs.length, 'fonte', 'fontes')} — ${contar('ok')} ok, ${plural(pendentes, 'pendente', 'pendentes')}, ${plural(alertas, 'alerta', 'alertas')}**`, '');
   return linhas.join('\n');
 }

package/templates/_opencrew/core/scripts/conferir-fontes.mjs

@@ -87,18 +87,17 @@ export async function conferir({ raiz, crew, limite = LIMITE_DA_BUSCA }) {
   return { crew, raiz, refs, status, buscaParcial: Boolean(ctx.indice?.parcial), limite };
 }
 
+/** @returns {Promise<string>} o caminho da cópia que ficou */
 async function copiaDeSeguranca(arquivo) {
   const bak = existsSync(`${arquivo}.bak`) ? `${arquivo}.bak-${new Date().toISOString().replace(/[:.]/g, '-')}` : `${arquivo}.bak`;
   await copyFile(arquivo, bak);
+  return bak;
 }
 
-/** Regrava a citação num arquivo; a cópia .bak é feita uma vez por arquivo. */
+/** Regrava a citação num arquivo; a cópia .bak é feita uma vez por arquivo (`tocados`: arquivo → cópia). */
 async function regravar(arquivo, item, tocados) {
   const texto = await readFile(arquivo, 'utf8');
-  if (!tocados.has(arquivo)) {
-    await copiaDeSeguranca(arquivo);
-    tocados.add(arquivo);
-  }
+  if (!tocados.has(arquivo)) tocados.set(arquivo, await copiaDeSeguranca(arquivo));
   await writeFile(arquivo, trocarCitacao(texto, item, path.basename(arquivo) === 'crew.yaml'));
 }
 
@@ -118,9 +117,10 @@ function guardaDeEscrita(raiz, crew) {
  * Troca, nos arquivos da crew, cada caminho com sugestão única — só a citação que a coleta leu,
  * nunca um pedaço de outro texto. O que a guarda de escrita barra não muda: `avisar` recebe uma
  * linha por arquivo pulado, ou uma só quando a crew inteira é um link para fora do projeto.
+ * `gravado` recebe cada arquivo alterado e a cópia que ficou dele.
  * @returns quantos caminhos foram gravados, em ao menos um arquivo
  */
-export async function corrigir({ resultado, avisar = () => {} }) {
+export async function corrigir({ resultado, avisar = () => {}, gravado = () => {} }) {
   const { raiz, crew } = resultado;
   const comSugestao = resultado.refs.filter((i) => i.sugestao && i.estado !== 'ok');
   const podeGravar = comSugestao.length ? guardaDeEscrita(raiz, crew) : null;
@@ -128,7 +128,7 @@ export async function corrigir({ resultado, avisar = () => {} }) {
     if (comSugestao.length) avisar(MSG.crewLigadaParaFora(crew));
     return 0;
   }
-  const tocados = new Set();
+  const tocados = new Map();
   const pulados = new Set();
   let gravados = 0;
   for (const item of comSugestao) {
@@ -138,19 +138,22 @@ export async function corrigir({ resultado, avisar = () => {} }) {
     if (dentro.length) gravados += 1;
   }
   for (const arquivo of pulados) avisar(MSG.linkParaFora(relativoAoProjeto(raiz, arquivo)));
+  for (const [arquivo, copia] of tocados) gravado(relativoAoProjeto(raiz, arquivo), path.basename(copia));
   return gravados;
 }
 
-/** --corrigir: troca o que tem sugestão única, diz o que pulou e quantas pendências ficam sem correção. */
+/**
+ * --corrigir: troca o que tem sugestão única e diz cada arquivo alterado, com a cópia; o relatório
+ * sai uma vez só — o de depois, quando algo mudou. Diz também o que pulou e o que ficou sem correção.
+ */
 async function corrigirEAvisar(r, escrever) {
   const pulados = [];
-  const n = await corrigir({ resultado: r, avisar: (linha) => pulados.push(linha) });
-  let atual = r;
-  if (n) {
-    escrever(MSG.corrigidos(n));
-    atual = await conferir({ raiz: r.raiz, crew: r.crew });
-    escrever(formatar(atual));
-  }
+  const feitos = [];
+  const n = await corrigir({ resultado: r, avisar: (linha) => pulados.push(linha), gravado: (arquivo, copia) => feitos.push(MSG.corrigido(arquivo, copia)) });
+  const atual = n ? await conferir({ raiz: r.raiz, crew: r.crew }) : r;
+  for (const linha of feitos) escrever(linha);
+  if (n) escrever('');
+  escrever(formatar(atual));
   for (const linha of pulados) escrever(linha);
   const semSugestao = atual.refs.filter((i) => i.estado === 'faltando' && !i.sugestao).length;
   if (semSugestao) escrever(MSG.semCorrecaoAutomatica(semSugestao));
@@ -177,8 +180,11 @@ export async function main(argv, { cwd = process.cwd(), escrever = (s) => proces
   }
   try {
     let r = await conferir({ raiz: cwd, crew });
-    escrever(formatar(r));
     if (argv.includes('--corrigir')) r = await corrigirEAvisar(r, escrever);
+    else {
+      escrever(formatar(r));
+      if (r.refs.some((i) => i.sugestao && i.estado !== 'ok')) escrever(MSG.comoCorrigir);
+    }
     escrever(`FONTES:${r.status}`);
     return 0;
   } catch (erroDeLeitura) {

package/templates/_opencrew/core/scripts/conserto/achados.mjs

@@ -52,7 +52,7 @@ function formato(crew) {
   const n = passos.length;
   return [
     `${n} ${plural(n, 'passo que a revisão confere não diz', 'passos que a revisão confere não dizem')} o formato do texto.`,
-    `Sem o formato, o verificador mede ${plural(n, 'esse texto', 'cada um')} como post de blog.`,
+    'Sem o formato, o redator não recebe o guia desse tipo de texto, e o verificador procura no arquivo peças de rede (legenda, post, título de blog).',
     `Passos: ${passos.map((p) => `${p.numero} (${saidaDe(p)})`).join(', ')}`,
     'Para consertar: --aplicar "formato:<passo>=<formato>"',
   ];

package/templates/_opencrew/core/scripts/documento/markdown.mjs

@@ -37,6 +37,7 @@ function lerTabela(linhas, i, estado) {
   while (fim < linhas.length && linhas[fim].trim() && linhas[fim].includes('|')) fim++;
   const brutas = [linhas[i], ...linhas.slice(i + 2, fim)].map(celulas);
   const colunas = Math.max(...brutas.map((l) => l.length));
+  estado.avisos.celulas += brutas.slice(1).filter((l) => l.length > brutas[0].length).length;
   const completas = brutas.map((l) => [...l, ...Array(colunas - l.length).fill('')]);
   estado.por({ tipo: 'tabela', linhas: completas.map((l) => l.map((c) => lerLinha(c, estado.avisos))) });
   return fim;
@@ -56,7 +57,7 @@ function lerBloco(linha, avisos) {
 
 /** Onde os blocos se juntam: a quebra de página pedida vale para o próximo bloco, uma vez só. */
 function novoEstado() {
-  const estado = { blocos: [], avisos: { imagens: 0, desconhecidas: 0, semFim: 0, invalidos: 0 }, quebra: false };
+  const estado = { blocos: [], avisos: { imagens: 0, desconhecidas: 0, semFim: 0, invalidos: 0, celulas: 0 }, quebra: false };
   estado.por = (bloco) => {
     estado.blocos.push(estado.quebra ? { ...bloco, quebra: true } : bloco);
     estado.quebra = false;

package/templates/_opencrew/core/scripts/documento/pacote.mjs

@@ -22,6 +22,7 @@ function avisosDe(c) {
     c.imagens && plural(c.imagens, '1 imagem não incluída: o Word não leva imagem no texto.', '{n} imagens não incluídas: o Word não leva imagem no texto.'),
     c.desconhecidas && plural(c.desconhecidas, '1 linha com marcação desconhecida (`:::`) ficou como texto.', '{n} linhas com marcação desconhecida (`:::`) ficaram como texto.'),
     c.semFim && plural(c.semFim, 'Bloco de assinaturas sem a linha `:::` no fim: ficou como texto.', '{n} blocos de assinaturas sem a linha `:::` no fim: ficaram como texto.'),
+    c.celulas && plural(c.celulas, '1 linha de tabela com mais células que o cabeçalho: a coluna a mais ficou sem título.', '{n} linhas de tabela com mais células que o cabeçalho: a coluna a mais ficou sem título.'),
     c.invalidos && plural(c.invalidos, '1 caractere inválido removido.', '{n} caracteres inválidos removidos.'),
   ].filter(Boolean);
 }

package/templates/_opencrew/core/scripts/documento/perfil.mjs

@@ -10,6 +10,7 @@ export const PADRAO = Object.freeze({
 
 export const MSG = {
   chave: (n, chave) => `Perfil, linha ${n}: não conheço a chave ${chave}.`,
+  grafia: (n, certa) => `Perfil, linha ${n}: a chave se escreve ${certa}: em minúsculas, sem acento, no começo da linha e sem espaço antes dos dois-pontos.`,
   valor: (n, chave, esperado, valor) => `Perfil, linha ${n}: ${chave} precisa ser ${esperado}. Recebi: ${valor}.`,
 };
 
@@ -38,6 +39,17 @@ const CHAVES = {
   tamanho_corpo_pt: { esperado: 'um número de 8 a 14 (aceita meio ponto)', ler: (valor) => (numero(valor) >= 8 && numero(valor) <= 14 && Number.isInteger(numero(valor) * 2) ? numero(valor) : undefined) },
 };
 
+// Linha que parece "chave: valor" mas não foi lida como chave: maiúscula, acento ou espaço antes.
+const QUASE = /^[ \t]*([\p{L}0-9_]+)[ \t]*:(?!\/\/)/u;
+const semAcento = (s) => s.normalize('NFD').replace(/\p{Diacritic}/gu, '').toLowerCase();
+
+/** A chave conhecida que a linha quis escrever, quando não a escreveu do jeito certo; senão, null. */
+function chaveQuaseCerta(linha) {
+  const [, escrita] = QUASE.exec(linha) ?? [];
+  const certa = escrita ? semAcento(escrita) : '';
+  return Object.hasOwn(CHAVES, certa) && !linha.startsWith(`${certa}:`) ? certa : null;
+}
+
 /** Tira as aspas em volta do valor, se as duas pontas têm a mesma. */
 function semAspas(valor) {
   const v = valor.trim();
@@ -58,6 +70,8 @@ export function lerPerfil(bruto) {
   const semBom = bruto.charCodeAt(0) === 0xfeff ? bruto.slice(1) : bruto;
   for (const [i, linha] of semBom.split(/\r\n?|\n/).entries()) {
     const [, chave, escrito = ''] = LINHA.exec(linha.trimEnd()) ?? [];
+    const quase = chave ? null : chaveQuaseCerta(linha);
+    if (quase) return { perfil, linhas, erro: MSG.grafia(i + 1, quase) };
     if (!chave) continue;
     if (!Object.hasOwn(CHAVES, chave)) return { perfil, linhas, erro: MSG.chave(i + 1, chave) };
     linhas[chave] = i + 1;

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

@@ -14,6 +14,8 @@ export const MSG = {
 };
 /** A lista fixa do que o script nunca confere. */
 export const NUNCA_CONFERIDO = ['Links e fatos citados no texto.', 'Texto dentro das imagens.', 'Aparência final em cada rede.'];
+/** Canal que não é de rede: nele não há imagem a publicar nem aparência de rede a conferir. */
+const SEM_REDE = new Set(['documentos']);
 
 const ehNaoMedido = (i) => i.item === NAO_MEDIDO || i.item === NAO_VERIFICADO;
 const origem = (arquivo) => `origem: \`${arquivo}\``;
@@ -63,7 +65,8 @@ export function naoConferido(raiz, itens, r) {
     }
   }
   if (r.naoTexto.length) linhas.push(`${NAO_VERIFICADO} — não é texto: ${r.naoTexto.join(', ')}`);
-  return [...linhas, ...NUNCA_CONFERIDO];
+  const temRede = itens.some((i) => i.canal && !SEM_REDE.has(i.canal));
+  return [...linhas, ...(temRede ? NUNCA_CONFERIDO : NUNCA_CONFERIDO.slice(0, 1))];
 }
 
 const LIMITE = { legenda: 'caption_max_chars', post: 'post_max_chars', tweet: 'tweet_max_chars' };

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

@@ -80,7 +80,8 @@ function separarPecas(item, texto, itens, p) {
 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) });
+    // `texto-livre` é o formato de quem não tem canal: estar em `outros/` é o esperado, não um aviso.
+    if (item.formato !== 'texto-livre') 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.

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

@@ -0,0 +1,20 @@
+// O que o Word não vai converter, visto antes do revisor: no texto de formato `documento-oficial`
+// o verificador lê as mesmas marcações que o conversor e põe um alerta para cada tipo de sobra.
+// Alerta, nunca bloqueio: quem decide é o revisor. Spec: fase-u5a-polimento-do-uso.md, regra 6.
+import { lerMarkdown } from '../documento/markdown.mjs';
+import { item } from './regras.mjs';
+
+export const FORMATO_DE_DOCUMENTO = 'documento-oficial';
+const NOME = 'Documento Word';
+const plural = (n, um, varios) => (n === 1 ? um : varios.replace('{n}', n));
+const FRASES = [
+  ['imagens', '1 imagem não entra no documento', '{n} imagens não entram no documento'],
+  ['desconhecidas', '1 marcação `:::` desconhecida vai como texto', '{n} marcações `:::` desconhecidas vão como texto'],
+  ['semFim', '1 bloco de assinaturas sem a linha `:::` do fim vai como texto', '{n} blocos de assinaturas sem a linha `:::` do fim vão como texto'],
+];
+
+/** Os alertas de um texto que vai virar Word; lista vazia quando tudo converte. */
+export function alertasDeDocumento(texto) {
+  const { avisos } = lerMarkdown(texto);
+  return FRASES.filter(([chave]) => avisos[chave]).map(([chave, um, varios]) => item(NOME, null, null, 'alerta', plural(avisos[chave], um, varios)));
+}

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

@@ -108,7 +108,8 @@ function naoMedidos({ pecas, corpo, formato, limites }, semLimite, medidas) {
   for (const cabecalho of BLOG.includes(formato) ? secoesDeOutroCanal(corpo) : []) {
     linhas.push(item(NAO_MEDIDO, null, null, null, `seção de outro canal num arquivo de blog: ${curto(cabecalho)}`));
   }
-  if (formato && !tipos && limites[formato] && !medidas) {
+  // Formato que não declara limite nenhum (documento-oficial, texto-livre) não tem o que medir.
+  if (formato && !tipos && Object.keys(limites[formato] ?? {}).length && !medidas) {
     linhas.push(item(NAO_MEDIDO, null, null, null, `o verificador ainda não mede os limites do formato ${formato}`));
   }
   return linhas;

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

@@ -25,6 +25,7 @@ import { lerLimites, lerDominioDoSite, semFrontmatter } from './verificar/leitur
 import { lerProibicoes } from './verificar/proibicoes.mjs';
 import { lerPecas } from './verificar/pecas.mjs';
 import { medirPecas } from './verificar/medicao.mjs';
+import { FORMATO_DE_DOCUMENTO, alertasDeDocumento } from './verificar/documento.mjs';
 import { regrasGerais, temVariavel, item, FALTA_INFO, NAO_MEDIDO, NAO_VERIFICADO } from './verificar/regras.mjs';
 import { formatarRelatorio } from './verificar/relatorio.mjs';
 import { MSG as GRAVACAO, caminhoDoRelatorio, gravarRelatorio } from './verificar/gravacao.mjs';
@@ -86,7 +87,8 @@ async function verificarArquivo({ arquivo, formato }, ctx, regraDeTeste) {
   const envio = /^(email|whatsapp)-/.test(formato ?? '');
   if (envio && temVariavel(lido.texto)) ctx.notas.add(NOTA_VARIAVEL);
   const gerais = regrasGerais(lido.texto, ctx.proibidos, { variavelBloqueia: !envio });
-  const extras = regraDeTeste ? (await regraDeTeste({ arquivo, formato, texto: lido.texto })) ?? [] : [];
+  const doWord = formato === FORMATO_DE_DOCUMENTO && lido.comPecas ? alertasDeDocumento(lido.texto) : [];
+  const extras = [...doWord, ...(regraDeTeste ? (await regraDeTeste({ arquivo, formato, texto: lido.texto })) ?? [] : [])];
   const naoMedido = (i) => i.item === NAO_MEDIDO;
   const itens = [...medidos.filter((i) => !naoMedido(i)), ...gerais, ...extras, ...medidos.filter(naoMedido)];
   return { itens, fecho: fechoDe(itens, medidas, formato) };