@aksp/opencrew 1.10.0 → 1.12.0

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

@@ -0,0 +1,55 @@
+// A gravação do conserto: o que impede de gravar é visto antes de tocar em qualquer arquivo; cada
+// arquivo alterado ganha antes a cópia `.bak` (a que já existe fica).
+// Spec: fase-u4a-conserto-de-crews.md, regras 1 e 2 (repositório do OpenCrew).
+import { accessSync, constants, existsSync, writeFileSync } from 'node:fs';
+import { relativoAoProjeto } from '../comum.mjs';
+
+const MSG = {
+  naoUtf8: (arquivo) => `Não altero ${arquivo}: o arquivo não está em UTF-8. Salve-o em UTF-8 e rode de novo.`,
+  somenteLeitura: (arquivo) => `Não consigo gravar em ${arquivo} (arquivo protegido ou aberto em outro programa). Nada foi gravado.`,
+  parouNoMeio: (gravados, arquivo, motivo) => `A gravação parou em ${arquivo}: ${motivo}. Já gravados: ${gravados.join(', ') || 'nenhum'} (a cópia .bak de cada um tem o texto de antes).`,
+};
+
+const INVALIDO = String.fromCharCode(0xfffd); // o que sobra de um byte que não é UTF-8
+
+function podeGravar(arquivo) {
+  try {
+    accessSync(arquivo, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** O que impede a gravação, visto antes de tocar em qualquer arquivo: texto que não é UTF-8, arquivo protegido. */
+export function erroAntesDeGravar(raiz, mudancas) {
+  const rel = (m) => relativoAoProjeto(raiz, m.arquivo);
+  const estranho = mudancas.find((m) => m.antes?.includes(INVALIDO));
+  if (estranho) return MSG.naoUtf8(rel(estranho));
+  const fechado = mudancas.find((m) => m.antes !== null && !podeGravar(m.arquivo));
+  return fechado ? MSG.somenteLeitura(rel(fechado)) : null;
+}
+
+/**
+ * Grava as mudanças; antes de cada arquivo, a cópia `.bak` do que estava lá (se ainda não existe).
+ * @returns {string[]} as linhas do relatório, com os caminhos relativos ao projeto
+ */
+export function gravar(raiz, mudancas) {
+  const linhas = [];
+  const gravados = [];
+  for (const { arquivo, antes, depois } of mudancas) {
+    const rel = relativoAoProjeto(raiz, arquivo);
+    const copia = `${arquivo}.bak`;
+    const jaHavia = existsSync(copia);
+    try {
+      if (antes !== null && !jaHavia) writeFileSync(copia, antes, 'utf8');
+      writeFileSync(arquivo, depois, 'utf8');
+    } catch (falha) {
+      throw new Error(MSG.parouNoMeio(gravados, rel, falha?.code ?? falha?.message ?? falha), { cause: falha });
+    }
+    gravados.push(rel);
+    linhas.push(`Gravei: ${rel}`);
+    if (antes !== null) linhas.push(`Cópia: ${rel}.bak${jaHavia ? ' (mantive a cópia que já existia)' : ''}`);
+  }
+  return linhas;
+}

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

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// Conserto de uma crew que já existe: mostra o que falta para as melhorias do runtime valerem nela
+// e, com --aplicar, grava um item por vez. Quem grava em `crews/` é este script, não a IA.
+// Uso (na pasta do projeto):
+//   node _opencrew/core/scripts/conserto.mjs --crew "crews/<crew>"                      só lê
+//   node _opencrew/core/scripts/conserto.mjs --crew "crews/<crew>" --aplicar "<item>"   grava
+// Itens de --aplicar: manifesto · nome:<agente>=<Nome Sobrenome> · formato:<passo>=<formato> ·
+//   fonte:<caminho>=<para que> · proibicao:<n>=<trecho> · proibicao:<n>=revisao-humana ·
+//   irreversivel:<passo> (ver --ajuda).
+// Só grava `crew.yaml`, `crew-party.csv`, `agents/*.agent.md`, `pipeline/steps/*.md` e
+// `_memory/memories.md` da crew, e a cópia `<arquivo>.bak` de cada um (a cópia que já existe
+// não é sobrescrita). Nunca apaga.
+// Última linha da saída: CONSERTO:OK (nada a consertar) · CONSERTO:PENDENTE (há achados) ·
+// CONSERTO:APLICADO (tudo o que foi pedido está gravado) · CONSERTO:ERRO (nada foi gravado).
+// Código de saída: 0, menos com CONSERTO:ERRO (1).
+// Spec: fase-u4a-conserto-de-crews.md (repositório do OpenCrew).
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { ehPrincipal, erroDeUso } from './comum.mjs';
+import { diagnosticar } from './conserto/achados.mjs';
+import { planejar } from './conserto/aplicar.mjs';
+import { AJUDA, lerArgs, lerItem, limpar } from './conserto/argumentos.mjs';
+import { lerCrew } from './conserto/crew.mjs';
+import { gravar } from './conserto/gravar.mjs';
+
+const MSG = {
+  estranho: (arg) => `Argumento desconhecido: ${limpar(arg)}. Veja as opções com --ajuda.`,
+  semYaml: (crew) => `A pasta ${limpar(crew)} não tem \`crew.yaml\`: não é uma crew.`,
+  itemDesconhecido: (item) => `Item desconhecido em --aplicar: ${limpar(item)}. Veja os itens com --ajuda.`,
+  emDia: (nome) => `A crew "${nome}" está em dia: não há o que consertar.`,
+  titulo: (nome, n) => `Conserto da crew "${nome}" — ${n} ${n === 1 ? 'achado' : 'achados'}`,
+  jaEstava: (item) => `Já estava assim: ${item}`,
+  falha: (motivo) => `Não consegui consertar: ${String(motivo).replace(/\s+/g, ' ').trim()}`,
+};
+
+/** O que está errado na chamada, antes de ler a crew; ou null. */
+function erroDaChamada(raiz, args) {
+  if (args.estranho !== undefined) return MSG.estranho(args.estranho);
+  const deUso = erroDeUso({ raiz, faltando: args.crew ? [] : ['--crew'], crew: args.crew });
+  if (deUso) return deUso;
+  if (!existsSync(path.resolve(raiz, args.crew, 'crew.yaml'))) return MSG.semYaml(args.crew);
+  const desconhecido = args.itens.find((i) => !lerItem(i));
+  return desconhecido === undefined ? null : MSG.itemDesconhecido(desconhecido);
+}
+
+/** As linhas do diagnóstico: um bloco por achado e a linha de situação. */
+function relatorio(crew) {
+  const achados = diagnosticar(crew);
+  if (!achados.length) return [MSG.emDia(crew.nome), 'CONSERTO:OK'];
+  const blocos = achados.flatMap(({ codigo, linhas: [titulo, ...resto] }) => ['', `[${codigo}] ${titulo}`, ...resto.map((l) => `  ${l}`)]);
+  return [MSG.titulo(crew.nome, achados.length), ...blocos, '', 'CONSERTO:PENDENTE'];
+}
+
+/** As linhas de um `--aplicar`: o que foi gravado, as cópias e a linha de situação. */
+function aplicar(raiz, crew, itens) {
+  const plano = planejar(crew, itens.map(lerItem));
+  if (plano.erro) return [plano.erro, 'CONSERTO:ERRO'];
+  return [...gravar(raiz, plano.mudancas), ...plano.iguais.map(MSG.jaEstava), 'CONSERTO:APLICADO'];
+}
+
+/**
+ * @param {string[]} argv
+ * @param {object} [deps] `cwd` (a pasta do projeto) e `escrever`
+ * @returns {number} 0 = a crew foi lida (e, com --aplicar, gravada) · 1 = CONSERTO:ERRO
+ */
+export function main(argv, deps = {}) {
+  const { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`) } = deps;
+  const args = lerArgs(argv);
+  if (args.ajuda) return AJUDA.forEach((l) => escrever(l)) ?? 0;
+  let linhas;
+  try {
+    const erro = erroDaChamada(cwd, args);
+    const crew = erro ? null : lerCrew(cwd, args.crew);
+    linhas = erro ? [erro, 'CONSERTO:ERRO'] : args.itens.length ? aplicar(cwd, crew, args.itens) : relatorio(crew);
+  } catch (falha) {
+    linhas = [MSG.falha(falha?.message ?? falha), 'CONSERTO:ERRO'];
+  }
+  linhas.forEach((l) => escrever(l));
+  return linhas.at(-1) === 'CONSERTO:ERRO' ? 1 : 0;
+}
+
+if (ehPrincipal(import.meta.url)) process.exitCode = main(process.argv.slice(2));

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/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);
   }

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) };