@orkastery/cli 0.6.0 → 0.6.2

package/dist/agendador-cpu.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JANELA_DA_SONDA_MS = exports.LIMIAR_STEAL_DO_AGENDADOR_PCT = exports.RESERVA_DO_GRUPO = exports.ENV_CPUS_DOCKER = exports.ENV_CPUS_DA_LANE = void 0;
+exports.cargaDoProcLoadavg = cargaDoProcLoadavg;
+exports.medirCpuDoGrupo = medirCpuDoGrupo;
+exports.planejarCpuDoGrupo = planejarCpuDoGrupo;
+exports.paredeClassicaSimulada = paredeClassicaSimulada;
+exports.paredeAgileSimulada = paredeAgileSimulada;
+/**
+ * RM-074: o plano de CPU do grupo do Agile Check.
+ *
+ * A lane hermetica deixa duas CPUs para a varredura e para a integracao. Cada conteiner recebe uma cota dessa fatia,
+ * em vez de enxergar a maquina inteira. Antes de lancar os comandos, o auxiliar do verify mede `/proc/loadavg` e uma
+ * janela de `/proc/stat`; sob carga ou steal, as pecas voltam a ordem do Classic e usam uma CPU a menos que a maquina.
+ */
+const node_fs_1 = require("node:fs");
+const steal_1 = require("./steal");
+exports.ENV_CPUS_DA_LANE = 'ORK_CHECK_CPUS_DA_LANE';
+exports.ENV_CPUS_DOCKER = 'ORK_CHECK_CPUS_DOCKER';
+exports.RESERVA_DO_GRUPO = 2;
+exports.LIMIAR_STEAL_DO_AGENDADOR_PCT = 10;
+exports.JANELA_DA_SONDA_MS = 250;
+const cpusValidas = (cpus) => Math.max(1, Math.floor(Number.isFinite(cpus) ? cpus : 1));
+/** A carga de um minuto de `/proc/loadavg`; entrada invalida ou ausencia nao inventam saturacao. */
+function cargaDoProcLoadavg(conteudo) {
+    if (!conteudo)
+        return null;
+    const carga = Number(conteudo.trim().split(/\s+/)[0]);
+    return Number.isFinite(carga) && carga >= 0 ? carga : null;
+}
+function lerProc(arquivo) {
+    try {
+        return (0, node_fs_1.readFileSync)(arquivo, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Mede a maquina dentro do proprio grupo, antes de qualquer comando: a carga nas duas pontas e o steal da janela.
+ * A leitura maior da carga impede uma subida durante a sonda de desaparecer na media de um minuto.
+ */
+async function medirCpuDoGrupo(janelaMs = exports.JANELA_DA_SONDA_MS) {
+    const statInicial = (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'));
+    const cargaInicial = cargaDoProcLoadavg(lerProc('/proc/loadavg'));
+    await new Promise((resolve) => setTimeout(resolve, janelaMs));
+    const cargaFinal = cargaDoProcLoadavg(lerProc('/proc/loadavg'));
+    const cargas = [cargaInicial, cargaFinal].filter((x) => x !== null);
+    return {
+        carga1: cargas.length ? Math.max(...cargas) : null,
+        stealPct: (0, steal_1.stealDaJanela)(statInicial, (0, steal_1.amostraDoProcStat)(lerProc('/proc/stat'))),
+    };
+}
+/** O plano unico que alimenta concorrencia das lanes, varredura e `docker run --cpus`. */
+function planejarCpuDoGrupo(cpusInformadas, medicao) {
+    const cpus = cpusValidas(cpusInformadas);
+    const classic = Math.max(1, cpus - 1);
+    const motivos = [];
+    if (cpus < 3)
+        motivos.push(`${cpus} CPU(s), sem duas CPUs livres para o grupo paralelo`);
+    if (medicao.carga1 !== null && medicao.carga1 >= classic)
+        motivos.push(`carga ${medicao.carga1} em /proc/loadavg (limiar ${classic})`);
+    if (medicao.stealPct !== null && medicao.stealPct >= exports.LIMIAR_STEAL_DO_AGENDADOR_PCT) {
+        motivos.push(`steal ${medicao.stealPct}% em /proc/stat (limiar ${exports.LIMIAR_STEAL_DO_AGENDADOR_PCT}%)`);
+    }
+    const saturado = motivos.length > 0;
+    const fatia = saturado ? classic : Math.min(exports.RESERVA_DO_GRUPO, cpus - 1);
+    const ferramentas = Math.max(1, Math.floor(fatia));
+    return {
+        cpus,
+        ordem: saturado ? 'classic' : 'paralela',
+        saturado,
+        motivo: motivos.join('; ') || `carga e steal abaixo dos limiares; ${fatia} CPU(s) reservadas ao grupo`,
+        cpusHermetica: saturado ? classic : Math.max(1, cpus - fatia),
+        cpusIntegracao: ferramentas,
+        cpusDaFatia: fatia,
+        ferramentasDaVarredura: ferramentas,
+        cpusPorContainer: Math.max(0.01, Math.floor((fatia / ferramentas) * 100) / 100),
+        medicao,
+    };
+}
+function paredeClassicaSimulada(cpus, trabalho) {
+    const concorrencia = Math.max(1, cpusValidas(cpus) - 1);
+    return (trabalho.hermetica + trabalho.varredura + trabalho.integracao) / concorrencia;
+}
+function paredeAgileSimulada(plano, trabalho) {
+    if (plano.ordem === 'classic') {
+        return trabalho.hermetica / plano.cpusHermetica + trabalho.varredura / plano.cpusDaFatia
+            + trabalho.integracao / plano.cpusIntegracao;
+    }
+    return Math.max(trabalho.hermetica / plano.cpusHermetica, trabalho.varredura / plano.cpusDaFatia + trabalho.integracao / plano.cpusIntegracao);
+}

package/dist/branch-de-estado.js

@@ -192,12 +192,17 @@ function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo
             exigirGit(raiz, ['read-tree', ponta], prefixo, { env });
         else
             exigirGit(raiz, ['read-tree', '--empty'], prefixo, { env });
-        for (const m of mudancas) {
+        for (const [i, m] of mudancas.entries()) {
             if (m.conteudo === null) {
                 exigirGit(raiz, ['update-index', '--force-remove', m.caminho], prefixo, { env });
             }
             else {
-                const blob = exigirGit(raiz, ['hash-object', '-w', '--stdin'], prefixo, { input: m.conteudo }).trim();
+                // `spawnSync` nem sempre fecha o pipe de entrada em runtimes hospedados, deixando o
+                // `hash-object --stdin` preso mesmo depois de receber todos os bytes. Um arquivo privado no
+                // mesmo diretorio temporario conserva o conteudo exato e torna o termino deterministico.
+                const conteudo = path.join(path.dirname(indice), `conteudo-${i}`);
+                fs.writeFileSync(conteudo, m.conteudo, { mode: 0o600 });
+                const blob = exigirGit(raiz, ['hash-object', '-w', conteudo], prefixo).trim();
                 exigirGit(raiz, ['update-index', '--add', '--cacheinfo', `100644,${blob},${m.caminho}`], prefixo, { env });
             }
         }

package/dist/changelog-check.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRUPOS_NAO_PUBLICADOS = exports.SECAO_NAO_PUBLICADO = exports.CHANGELOG = void 0;
+exports.ehTeste = ehTeste;
+exports.pedeLinha = pedeLinha;
+exports.linhasDaSecao = linhasDaSecao;
+exports.versoes = versoes;
+exports.changelogAplicavel = changelogAplicavel;
+exports.checarChangelog = checarChangelog;
+exports.basePadrao = basePadrao;
+/**
+ * RM-037: regra unica do CHANGELOG para o script do CI, `docs verificar --pr` e `ork verify`.
+ * O diff decide quais linhas a thread acrescentou; o texto do HEAD decide em que secao e grupo
+ * cada linha caiu; uma tag local `v<versao>` prova que a secao ja foi publicada.
+ */
+const node_child_process_1 = require("node:child_process");
+exports.CHANGELOG = 'CHANGELOG.md';
+exports.SECAO_NAO_PUBLICADO = 'Não publicado';
+exports.GRUPOS_NAO_PUBLICADOS = ['Adicionado', 'Alterado', 'Corrigido', 'Segurança'];
+const PASTAS_DE_PRODUTO = ['core/', 'adapters/', 'marketplaces/'];
+const DE_CI = [/^\.github\//, /^\.ork-ci\//, /^core\/scripts\/test-ci\.js$/, /^core\/scripts\/checar-[a-z0-9-]+\.cjs$/];
+const CORRECAO = 'acrescente em "## Não publicado" do CHANGELOG.md uma linha que diga o que muda para quem usa, ' +
+    'sob "### Adicionado", "### Alterado", "### Corrigido" ou "### Segurança" ' +
+    '(PR só de testes ou só de CI fica de fora: docs/guias/contribuir/pull-request.md)';
+function git(raiz, args) {
+    const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: raiz, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    return { ok: r.status === 0, saida: r.stdout ?? '' };
+}
+/** Arquivo de teste: pasta `test`, `tests` ou `__tests__`, ou nome `*.test.*`/`*.spec.*`. */
+function ehTeste(arquivo) {
+    const partes = arquivo.split('/');
+    return partes.slice(0, -1).some((p) => p === 'test' || p === 'tests' || p === '__tests__')
+        || /\.(test|spec)\.[A-Za-z0-9]+$/.test(partes[partes.length - 1]);
+}
+/** Arquivo de produto que exige uma entrada no CHANGELOG. */
+function pedeLinha(arquivo) {
+    return PASTAS_DE_PRODUTO.some((p) => arquivo.startsWith(p)) && !ehTeste(arquivo) && !DE_CI.some((re) => re.test(arquivo));
+}
+/** Linhas de texto de `## Não publicado`, mantida para consumidores e testes legados. */
+function linhasDaSecao(texto) {
+    const linhas = texto.replace(/\r\n/g, '\n').split('\n');
+    const inicio = linhas.findIndex((linha) => linha.trim() === `## ${exports.SECAO_NAO_PUBLICADO}`);
+    if (inicio < 0)
+        return null;
+    const corpo = [];
+    for (const linha of linhas.slice(inicio + 1)) {
+        if (/^## /.test(linha))
+            break;
+        if (linha.trim() && !/^#/.test(linha.trim()))
+            corpo.push(linha.trimEnd());
+    }
+    return corpo;
+}
+/** Versoes nos dois formatos historicos do arquivo. */
+function versoes(texto) {
+    return new Set([...texto.replace(/\r\n/g, '\n').matchAll(/^## \[?(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)\]?(?=\s|$)/gm)]
+        .map((m) => m[1]));
+}
+function changelogEm(raiz, ref) {
+    const r = git(raiz, ['show', `${ref}:${exports.CHANGELOG}`]);
+    return r.ok ? r.saida : '';
+}
+/**
+ * A regra protege um histórico publicado. Repositórios ainda sem versão `v*` ou sem
+ * CHANGELOG no HEAD não têm esse contrato para comparar e ficam fora do verificador.
+ */
+function changelogAplicavel(raiz, head = 'HEAD') {
+    const arquivo = git(raiz, ['cat-file', '-e', `${head}:${exports.CHANGELOG}`]);
+    if (!arquivo.ok)
+        return false;
+    const tags = git(raiz, ['tag', '--merged', head, '--list', 'v*']);
+    return tags.ok && tags.saida.split('\n').some((tag) => tag.trim().length > 1);
+}
+/** Linhas acrescentadas no arquivo, com o numero que ocupam no HEAD. */
+function linhasAcrescentadas(raiz, base, head) {
+    const d = git(raiz, ['diff', '--no-color', '--unified=0', '--no-renames', base, head, '--', exports.CHANGELOG]);
+    if (!d.ok)
+        return [];
+    const novas = [];
+    let numero = 0, emTrecho = false;
+    for (const linha of d.saida.replace(/\r\n/g, '\n').split('\n')) {
+        const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(linha);
+        if (hunk) {
+            numero = Number(hunk[1]);
+            emTrecho = true;
+            continue;
+        }
+        if (!emTrecho || linha.startsWith('\\ No newline'))
+            continue;
+        if (linha.startsWith('+')) {
+            novas.push({ numero, texto: linha.slice(1) });
+            numero++;
+        }
+        else if (!linha.startsWith('-'))
+            numero++;
+    }
+    return novas;
+}
+function contextos(texto) {
+    const porLinha = [{ secao: null, grupo: null, versao: null }];
+    let secao = null, grupo = null, versao = null;
+    for (const linha of texto.replace(/\r\n/g, '\n').split('\n')) {
+        const h2 = /^## (.+?)\s*$/.exec(linha);
+        if (h2) {
+            secao = h2[1];
+            grupo = null;
+            versao = /^\[?(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)\]?(?:\s|$)/.exec(secao)?.[1] ?? null;
+        }
+        else {
+            const h3 = /^### (.+?)\s*$/.exec(linha);
+            if (h3)
+                grupo = h3[1];
+        }
+        porLinha.push({ secao, grupo, versao });
+    }
+    return porLinha;
+}
+function tagPublicada(raiz, versao) {
+    return git(raiz, ['rev-parse', '--verify', '--quiet', `refs/tags/v${versao}^{commit}`]).ok;
+}
+/**
+ * Confere o diff da thread ate `head`.
+ *
+ * A referencia local da branch alvo pode estar atrasada em relacao ao commit que abriu a
+ * worktree. Quando a base carimbada tambem e ancestral do HEAD e vem depois da merge-base,
+ * ela delimita o que a thread de fato acrescentou. Se a branch alvo avancou para alem dela,
+ * a merge-base mais nova continua vencendo.
+ */
+function checarChangelog(raiz, opcoes = {}) {
+    const head = opcoes.head ?? 'HEAD', base = opcoes.base;
+    const indisponivel = (detalhe) => ({ ok: false, motivo: 'changelog.base-indisponivel', detalhe,
+        correcao: 'rode com o histórico completo do git (fetch-depth: 0 no CI) ou passe --base <ref>', arquivos: [], linhas: [] });
+    if (!git(raiz, ['rev-parse', '--verify', '--quiet', `${head}^{commit}`]).ok)
+        return indisponivel(`o head ${head} não existe neste repositório`);
+    if (!changelogAplicavel(raiz, head)) {
+        const temArquivo = git(raiz, ['cat-file', '-e', `${head}:${exports.CHANGELOG}`]).ok;
+        return { ok: true, motivo: null, arquivos: [], linhas: [], detalhe: temArquivo
+                ? 'regra do CHANGELOG não aplicável: o repositório ainda não tem versão publicada em tag v*'
+                : `regra do CHANGELOG não aplicável: ${exports.CHANGELOG} não existe em ${head}` };
+    }
+    if (!base)
+        return indisponivel('nenhuma base para comparar');
+    if (!git(raiz, ['rev-parse', '--verify', '--quiet', `${base}^{commit}`]).ok)
+        return indisponivel(`a base ${base} não existe neste repositório`);
+    const mb = git(raiz, ['merge-base', base, head]);
+    let ancestral = mb.saida.trim();
+    if (!mb.ok || !ancestral)
+        return indisponivel(`${base} e ${head} não têm ancestral comum`);
+    const carimbada = opcoes.baseCarimbada?.trim();
+    if (carimbada
+        && git(raiz, ['rev-parse', '--verify', '--quiet', `${carimbada}^{commit}`]).ok
+        && git(raiz, ['merge-base', '--is-ancestor', carimbada, head]).ok
+        && git(raiz, ['merge-base', '--is-ancestor', ancestral, carimbada]).ok) {
+        ancestral = carimbada;
+    }
+    const mudados = git(raiz, ['diff', '--name-only', '--no-renames', '-z', ancestral, head]);
+    const arquivos = (mudados.ok ? mudados.saida.split('\0') : []).filter(Boolean);
+    const pedem = arquivos.filter(pedeLinha);
+    const antes = changelogEm(raiz, ancestral), depois = changelogEm(raiz, head);
+    const novas = linhasAcrescentadas(raiz, ancestral, head);
+    const porLinha = contextos(depois);
+    // D4: uma entrada correta em Nao publicado nunca esconde uma edicao retrospectiva.
+    for (const linha of novas) {
+        if (!linha.texto.trim())
+            continue;
+        const contexto = porLinha[linha.numero] ?? { secao: null, grupo: null, versao: null };
+        if (contexto.versao && tagPublicada(raiz, contexto.versao)) {
+            return { ok: false, motivo: 'changelog.secao-publicada', arquivos: pedem, linhas: [linha.texto], secao: contexto.secao ?? undefined,
+                detalhe: `a linha nova ${linha.numero} caiu em "## ${contexto.secao}", versão já publicada pela tag v${contexto.versao}`,
+                correcao: `mova a linha para "## ${exports.SECAO_NAO_PUBLICADO}", sob um dos grupos permitidos` };
+        }
+    }
+    const entradasNaoPublicadas = novas.filter((linha) => {
+        const t = linha.texto.trim(), contexto = porLinha[linha.numero];
+        return !!t && !/^#{2,3} /.test(t) && contexto?.secao === exports.SECAO_NAO_PUBLICADO;
+    });
+    for (const linha of entradasNaoPublicadas) {
+        const grupo = porLinha[linha.numero]?.grupo ?? null;
+        if (!grupo)
+            return { ok: false, motivo: 'changelog.grupo-ausente', arquivos: pedem, linhas: [linha.texto], grupo,
+                detalhe: `a linha nova ${linha.numero} de "## ${exports.SECAO_NAO_PUBLICADO}" não está sob um título ###`,
+                correcao: `ponha a linha sob ${exports.GRUPOS_NAO_PUBLICADOS.map((g) => `"### ${g}"`).join(', ')}` };
+        if (!exports.GRUPOS_NAO_PUBLICADOS.includes(grupo)) {
+            return { ok: false, motivo: 'changelog.grupo-invalido', arquivos: pedem, linhas: [linha.texto], grupo,
+                detalhe: `a linha nova ${linha.numero} está sob "### ${grupo}", grupo que não vale em "## ${exports.SECAO_NAO_PUBLICADO}"`,
+                correcao: `use ${exports.GRUPOS_NAO_PUBLICADOS.map((g) => `"### ${g}"`).join(', ')}` };
+        }
+    }
+    if (pedem.length === 0)
+        return { ok: true, motivo: null, arquivos: [], linhas: [],
+            detalhe: arquivos.length === 0 ? `nada a conferir: ${head} não muda nada desde ${base}`
+                : 'nada pede linha: o PR não muda core/, adapters/ nem marketplaces/ fora de teste e de CI' };
+    const versaoNova = [...versoes(depois)].filter((v) => !versoes(antes).has(v));
+    if (versaoNova.length > 0)
+        return { ok: true, motivo: null, arquivos: pedem, linhas: [],
+            detalhe: `versão nova no ${exports.CHANGELOG}: ${versaoNova.join(', ')} (o PR de versão leva as linhas para ela)` };
+    if (linhasDaSecao(depois) === null)
+        return { ok: false, motivo: 'changelog.secao-ausente', arquivos: pedem, linhas: [],
+            detalhe: `o ${exports.CHANGELOG} de ${head} não tem a seção "## ${exports.SECAO_NAO_PUBLICADO}"`,
+            correcao: `abra a seção "## ${exports.SECAO_NAO_PUBLICADO}" no alto do ${exports.CHANGELOG} e acrescente a linha da mudança` };
+    if (entradasNaoPublicadas.length > 0)
+        return { ok: true, motivo: null, arquivos: pedem,
+            linhas: entradasNaoPublicadas.map((linha) => linha.texto),
+            detalhe: `${entradasNaoPublicadas.length} linha(s) nova(s) em "## ${exports.SECAO_NAO_PUBLICADO}" sob grupo permitido` };
+    return { ok: false, motivo: 'changelog.linha-ausente', arquivos: pedem, linhas: [],
+        detalhe: `o PR muda ${pedem.length} arquivo(s) de core/, adapters/ ou marketplaces/ (${pedem.slice(0, 3).join(', ')}${pedem.length > 3 ? ', ...' : ''}) e não acrescenta linha válida em "## ${exports.SECAO_NAO_PUBLICADO}" do ${exports.CHANGELOG}`,
+        correcao: CORRECAO };
+}
+/** Base padrao do CI: alvo do PR, main remota, main local. */
+function basePadrao(raiz, env = process.env) {
+    if (env.GITHUB_BASE_REF)
+        return `origin/${env.GITHUB_BASE_REF}`;
+    for (const ref of ['origin/main', 'main'])
+        if (git(raiz, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]).ok)
+            return ref;
+    return null;
+}