@orkastery/cli 0.2.0

package/dist/evalrunner.js

@@ -0,0 +1,458 @@
+"use strict";
+/**
+ * `ork eval`: o runner de avaliacao do bloco B4.
+ *
+ * Ele julga duas coisas, e diz em voz alta que so uma delas ele consegue julgar.
+ *
+ *  1. **Os canarios** (`eval/fixtures/fx-*`): comportamento real do nucleo, exercitado ponta a
+ *     ponta contra git de verdade, comparado com o que a fixture declara esperar.
+ *  2. **O corpus das skills** (`eval/casos/*.json`): as regras que precisam EXISTIR no arquivo
+ *     da skill para o comportamento ser possivel. Isso e deterministico, e e o que o runner
+ *     verifica: apague a regra da separacao no reviewer e o caso dele fica vermelho.
+ *
+ * O que o runner NAO julga e a metade comportamental de cada caso, aquela em que um agente e
+ * posto na situacao e alguem ve se ele resiste a desculpa. Essa metade sai `unavailable` em
+ * toda execucao, nunca `passing`. Regra herdada do catalogo original e mantida de proposito:
+ * **lacuna e publicada como lacuna**, porque um runner que chamasse isso de verde estaria
+ * medindo a propria vontade.
+ *
+ * Regra de catalogo que este runner torna executavel: skill sem eval nao entra, e eval sem
+ * skill tambem nao fica.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIMO_DE_CASOS = exports.TIPOS_DE_CASO = void 0;
+exports.normalizar = normalizar;
+exports.intervaloDaTabelaDeDesculpas = intervaloDaTabelaDeDesculpas;
+exports.posicoesDaAssercao = posicoesDaAssercao;
+exports.dirDeCasos = dirDeCasos;
+exports.dirDeFixtures = dirDeFixtures;
+exports.lerCasos = lerCasos;
+exports.rodarCanarios = rodarCanarios;
+exports.rodarEval = rodarEval;
+exports.textoDoEval = textoDoEval;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const canarios_1 = require("./canarios");
+const catalogo_1 = require("./catalogo");
+const util_1 = require("./util");
+/** Os tres tipos que toda skill precisa cobrir. Menos que isso e cobertura de fachada. */
+exports.TIPOS_DE_CASO = ['caminho-feliz', 'racionalizacao', 'borda'];
+/** Minimo de casos por skill, para o corpus nao virar uma linha por skill. */
+exports.MINIMO_DE_CASOS = 3;
+// ---------------------------------------------------------------------------
+// A tabela de racionalizacoes, e por que ela nao pode ser a unica ancora
+// ---------------------------------------------------------------------------
+/**
+ * Normaliza o texto da skill para casamento: toda sequencia de espaco em branco vira um
+ * espaco so.
+ *
+ * Sem isso, reflowar um paragrafo de markdown (mover uma palavra para a linha seguinte)
+ * deixaria uma assercao vermelha sem que regra nenhuma tivesse mudado. Um eval que reprova
+ * por causa de quebra de linha treina o time a ignorar o eval, que e o pior resultado
+ * possivel para um corpus de regressao.
+ */
+function normalizar(texto) {
+    return texto.replace(/\s+/g, ' ');
+}
+/**
+ * Intervalo da secao "Racionalizacoes comuns" dentro do texto JA NORMALIZADO da skill.
+ *
+ * Existe porque uma skill pode LISTAR a desculpa na tabela e nao ter, em lugar nenhum, a regra
+ * que responde a ela. O caso passaria, e a skill nao seguraria nada. Por isso todo caso de
+ * racionalizacao precisa de ao menos uma ancora FORA desta tabela.
+ */
+function intervaloDaTabelaDeDesculpas(texto) {
+    const normalizado = normalizar(texto);
+    const inicio = normalizado.indexOf('## Racionalizacoes comuns');
+    if (inicio < 0)
+        return null;
+    const resto = normalizado.indexOf('## ', inicio + 25);
+    return { inicio, fim: resto < 0 ? normalizado.length : resto };
+}
+/** Todas as posicoes em que a assercao casa no texto normalizado da skill. */
+function posicoesDaAssercao(a, texto) {
+    const alvo = normalizar(texto);
+    const achadas = [];
+    if (a.tipo === 'casa') {
+        const regex = new RegExp(normalizar(a.valor), 'g');
+        let casado;
+        while ((casado = regex.exec(alvo)) !== null) {
+            achadas.push(casado.index);
+            if (casado[0].length === 0)
+                regex.lastIndex++;
+        }
+        return achadas;
+    }
+    const valor = normalizar(a.valor);
+    let de = alvo.indexOf(valor);
+    while (de >= 0) {
+        achadas.push(de);
+        de = alvo.indexOf(valor, de + 1);
+    }
+    return achadas;
+}
+// ---------------------------------------------------------------------------
+// Corpus das skills
+// ---------------------------------------------------------------------------
+function dirDeCasos(catalogo) {
+    return path.join(catalogo, 'eval', 'casos');
+}
+function dirDeFixtures(catalogo) {
+    return path.join(catalogo, 'eval', 'fixtures');
+}
+/** Le os arquivos de caso do disco. Arquivo ilegivel e falha, nunca zero casos em silencio. */
+function lerCasos(catalogo) {
+    const dir = dirDeCasos(catalogo);
+    const arquivos = [];
+    const falhas = [];
+    if (!fs.existsSync(dir))
+        return { arquivos, falhas };
+    for (const nome of fs.readdirSync(dir).sort()) {
+        if (!nome.endsWith('.json'))
+            continue;
+        const caminho = path.join(dir, nome);
+        try {
+            const lido = JSON.parse(fs.readFileSync(caminho, 'utf8'));
+            if (!lido.skill || !Array.isArray(lido.casos)) {
+                falhas.push({ codigo: 'fixture-invalida', detalhe: `${nome}: esperado { skill, casos[] }` });
+                continue;
+            }
+            arquivos.push(lido);
+        }
+        catch (e) {
+            falhas.push({ codigo: 'fixture-invalida', detalhe: `${nome}: ${e.message}` });
+        }
+    }
+    return { arquivos, falhas };
+}
+function avaliarSkill(arquivo, textoDaSkill, vistos) {
+    const falhas = [];
+    const skill = arquivo.skill;
+    const tabelaDeDesculpas = intervaloDaTabelaDeDesculpas(textoDaSkill);
+    let assercoes = 0;
+    if (arquivo.casos.length < exports.MINIMO_DE_CASOS) {
+        falhas.push({
+            codigo: 'cobertura-minima',
+            skill,
+            detalhe: `${arquivo.casos.length} caso(s); o minimo do catalogo e ${exports.MINIMO_DE_CASOS}`,
+        });
+    }
+    for (const tipo of exports.TIPOS_DE_CASO) {
+        if (!arquivo.casos.some((c) => c.tipo === tipo)) {
+            falhas.push({ codigo: 'tipo-faltando', skill, detalhe: `nenhum caso do tipo "${tipo}"` });
+        }
+    }
+    for (const caso of arquivo.casos) {
+        if (vistos.has(caso.id)) {
+            falhas.push({ codigo: 'id-duplicado', skill, caso: caso.id, detalhe: 'id repetido no corpus' });
+        }
+        vistos.add(caso.id);
+        if (!caso.id.startsWith(`${skill}/`)) {
+            falhas.push({
+                codigo: 'id-sem-prefixo',
+                skill,
+                caso: caso.id,
+                detalhe: `o id precisa comecar com "${skill}/"`,
+            });
+        }
+        if (caso.tipo === 'racionalizacao' && !(caso.racionalizacao ?? '').trim()) {
+            falhas.push({
+                codigo: 'racionalizacao-sem-desculpa',
+                skill,
+                caso: caso.id,
+                detalhe: 'caso de racionalizacao sem o campo `racionalizacao` com a desculpa',
+            });
+        }
+        let ancoraForaDaTabela = false;
+        for (const a of caso.assercoes) {
+            assercoes++;
+            if (!(a.porque ?? '').trim()) {
+                falhas.push({
+                    codigo: 'assercao-sem-porque',
+                    skill,
+                    caso: caso.id,
+                    detalhe: `assercao "${a.valor}" sem o campo \`porque\``,
+                });
+            }
+            let posicoes;
+            try {
+                posicoes = posicoesDaAssercao(a, textoDaSkill);
+            }
+            catch (e) {
+                falhas.push({
+                    codigo: 'padrao-invalido',
+                    skill,
+                    caso: caso.id,
+                    detalhe: `padrao "${a.valor}" invalido: ${e.message}`,
+                });
+                continue;
+            }
+            if (a.tipo === 'ausente') {
+                if (posicoes.length > 0) {
+                    falhas.push({
+                        codigo: 'assercao',
+                        skill,
+                        caso: caso.id,
+                        detalhe: `"${a.valor}" deveria estar AUSENTE da skill e aparece ${posicoes.length}x`,
+                    });
+                }
+                continue;
+            }
+            if (posicoes.length === 0) {
+                falhas.push({
+                    codigo: 'assercao',
+                    skill,
+                    caso: caso.id,
+                    detalhe: `"${a.valor}" nao existe em skills/.../${skill}/SKILL.md (${a.porque})`,
+                });
+                continue;
+            }
+            if (!tabelaDeDesculpas ||
+                posicoes.some((p) => p < tabelaDeDesculpas.inicio || p >= tabelaDeDesculpas.fim)) {
+                ancoraForaDaTabela = true;
+            }
+        }
+        if (caso.tipo === 'racionalizacao' && caso.assercoes.length > 0 && !ancoraForaDaTabela) {
+            falhas.push({
+                codigo: 'ancora-fora-da-tabela',
+                skill,
+                caso: caso.id,
+                detalhe: 'todas as ancoras deste caso estao dentro da tabela de racionalizacoes: a skill lista a desculpa mas nao carrega a regra que responde a ela',
+            });
+        }
+    }
+    return {
+        linha: { skill, casos: arquivo.casos.length, assercoes, falhas: falhas.length },
+        falhas,
+    };
+}
+function comparar(esperado, observado) {
+    const divergencias = [];
+    for (const [chave, valor] of Object.entries(esperado)) {
+        const veio = observado[chave];
+        if (JSON.stringify(veio) !== JSON.stringify(valor)) {
+            divergencias.push({ chave, esperado: valor, observado: veio });
+        }
+    }
+    return divergencias;
+}
+/** Roda os canarios cujas fixtures existem em `eval/fixtures/fx-*`. */
+function rodarCanarios(catalogo, filtro) {
+    const dir = dirDeFixtures(catalogo);
+    const resultados = [];
+    const falhas = [];
+    const temGit = (0, canarios_1.gitDisponivel)();
+    const nomes = fs.existsSync(dir) ? fs.readdirSync(dir).sort() : [];
+    for (const nome of nomes) {
+        if (!nome.startsWith('fx-'))
+            continue;
+        if (filtro && !filtro.includes(nome))
+            continue;
+        const caminho = path.join(dir, nome, 'caso.json');
+        if (!fs.existsSync(caminho)) {
+            falhas.push({ codigo: 'fixture-invalida', detalhe: `${nome}: falta caso.json` });
+            continue;
+        }
+        let fixture;
+        try {
+            fixture = JSON.parse(fs.readFileSync(caminho, 'utf8'));
+        }
+        catch (e) {
+            falhas.push({ codigo: 'fixture-invalida', detalhe: `${nome}: ${e.message}` });
+            continue;
+        }
+        const canario = (0, canarios_1.canarioPorId)(fixture.id ?? nome);
+        if (!canario) {
+            falhas.push({
+                codigo: 'canario-sem-executor',
+                detalhe: `${nome}: nenhum executor registrado para o canario "${fixture.id ?? nome}"`,
+            });
+            continue;
+        }
+        if (canario.precisaDeGit && !temGit) {
+            resultados.push({
+                id: canario.id,
+                sobre: canario.sobre,
+                estado: 'unavailable',
+                divergencias: [],
+                motivo: 'git nao esta nesta maquina: o canario sai unavailable, nunca passing',
+                observado: {},
+            });
+            continue;
+        }
+        try {
+            const observado = canario.rodar({ catalogo });
+            const divergencias = comparar(fixture.esperado ?? {}, observado);
+            resultados.push({
+                id: canario.id,
+                sobre: canario.sobre,
+                estado: divergencias.length === 0 ? 'passou' : 'falhou',
+                divergencias,
+                motivo: divergencias.length === 0 ? '' : `${divergencias.length} chave(s) divergente(s)`,
+                observado,
+            });
+            for (const d of divergencias) {
+                falhas.push({
+                    codigo: 'canario',
+                    caso: `${canario.id}/${d.chave}`,
+                    detalhe: `esperado ${JSON.stringify(d.esperado)}, observado ${JSON.stringify(d.observado)}`,
+                });
+            }
+        }
+        catch (e) {
+            resultados.push({
+                id: canario.id,
+                sobre: canario.sobre,
+                estado: 'falhou',
+                divergencias: [],
+                motivo: e.message,
+                observado: {},
+            });
+            falhas.push({ codigo: 'canario', caso: canario.id, detalhe: e.message });
+        }
+    }
+    // Canario registrado no codigo e sem fixture em disco tambem e defeito: a expectativa
+    // precisa ser dado versionado, revisavel por quem nao le TypeScript.
+    if (!filtro) {
+        for (const c of canarios_1.CANARIOS) {
+            if (!fs.existsSync(path.join(dir, c.id, 'caso.json'))) {
+                falhas.push({
+                    codigo: 'fixture-invalida',
+                    caso: c.id,
+                    detalhe: `o canario ${c.id} existe no codigo e nao tem eval/fixtures/${c.id}/caso.json`,
+                });
+            }
+        }
+    }
+    return { resultados, falhas };
+}
+// ---------------------------------------------------------------------------
+// Orquestracao
+// ---------------------------------------------------------------------------
+/** Roda o eval inteiro: canarios mais corpus das skills. */
+function rodarEval(opcoes) {
+    const { catalogo } = opcoes;
+    const falhas = [];
+    const linhas = [];
+    let canarios = [];
+    if (!opcoes.soSkills) {
+        const r = rodarCanarios(catalogo, opcoes.canarios);
+        canarios = r.resultados;
+        falhas.push(...r.falhas);
+    }
+    let totalDeCasos = 0;
+    let totalDeAssercoes = 0;
+    if (!opcoes.soCanarios) {
+        const { arquivos, falhas: falhasDeLeitura } = lerCasos(catalogo);
+        falhas.push(...falhasDeLeitura);
+        const doCatalogo = (0, catalogo_1.skillsDoCatalogo)(catalogo);
+        const comEval = new Set(arquivos.map((a) => a.skill));
+        const vistos = new Set();
+        for (const skill of doCatalogo) {
+            if (!comEval.has(skill.nome)) {
+                falhas.push({
+                    codigo: 'skill-sem-eval',
+                    skill: skill.nome,
+                    detalhe: `skill sem eval nao entra no catalogo: falta eval/casos/${skill.nome}.json`,
+                });
+            }
+        }
+        for (const arquivo of arquivos) {
+            if (opcoes.skills && !opcoes.skills.includes(arquivo.skill))
+                continue;
+            const skill = doCatalogo.find((s) => s.nome === arquivo.skill);
+            if (!skill) {
+                falhas.push({
+                    codigo: 'eval-sem-skill',
+                    skill: arquivo.skill,
+                    detalhe: 'ha casos para uma skill que nao existe no catalogo',
+                });
+                continue;
+            }
+            const texto = fs.readFileSync(skill.caminho, 'utf8');
+            const avaliada = avaliarSkill(arquivo, texto, vistos);
+            linhas.push(avaliada.linha);
+            falhas.push(...avaliada.falhas);
+            totalDeCasos += avaliada.linha.casos;
+            totalDeAssercoes += avaliada.linha.assercoes;
+        }
+    }
+    return {
+        catalogo,
+        skills: linhas,
+        canarios,
+        falhas,
+        totalDeCasos,
+        totalDeAssercoes,
+        metadeComportamental: 'unavailable',
+        ok: falhas.length === 0,
+    };
+}
+/** Texto de `ork eval`. */
+function textoDoEval(r) {
+    const linhas = [];
+    linhas.push(`ork eval, catalogo em ${r.catalogo}`);
+    linhas.push('');
+    if (r.canarios.length > 0) {
+        linhas.push('Canarios (comportamento real do nucleo, contra git de verdade)');
+        linhas.push('');
+        linhas.push((0, util_1.tabela)(['CANARIO', 'ESTADO', 'SOBRE'], r.canarios.map((c) => [c.id, c.estado, c.estado === 'passou' ? c.sobre : c.motivo || c.sobre])));
+        linhas.push('');
+    }
+    if (r.skills.length > 0) {
+        linhas.push('Corpus das skills (a metade estatica: as regras que precisam existir no arquivo)');
+        linhas.push('');
+        linhas.push((0, util_1.tabela)(['SKILL', 'CASOS', 'ASSERCOES', 'FALHAS'], r.skills.map((s) => [s.skill, String(s.casos), String(s.assercoes), String(s.falhas)])));
+        linhas.push('');
+    }
+    if (r.falhas.length > 0) {
+        linhas.push('Falhas');
+        for (const f of r.falhas) {
+            const onde = [f.skill, f.caso].filter(Boolean).join(' :: ');
+            linhas.push(`  [${f.codigo}] ${onde}`);
+            linhas.push(`           ${f.detalhe}`);
+        }
+        linhas.push('');
+    }
+    const passaram = r.canarios.filter((c) => c.estado === 'passou').length;
+    const indisponiveis = r.canarios.filter((c) => c.estado === 'unavailable').length;
+    linhas.push(`canarios: ${passaram}/${r.canarios.length} verdes` +
+        (indisponiveis > 0 ? ` (${indisponiveis} unavailable)` : ''));
+    linhas.push(`skills: ${r.skills.length} | casos: ${r.totalDeCasos} | assercoes: ${r.totalDeAssercoes} | falhas: ${r.falhas.length}`);
+    linhas.push('metade comportamental (o agente resiste a desculpa?): unavailable, julgada por humano ou por modelo, nunca por este runner');
+    linhas.push(r.ok ? 'VEREDITO: verde' : 'VEREDITO: vermelho');
+    return linhas.join('\n');
+}