@orkastery/cli 0.5.6 → 0.6.0

package/dist/busca-semantica.js

@@ -22,6 +22,7 @@ exports.fundirRrf = fundirRrf;
 exports.buscarPorSignificado = buscarPorSignificado;
 exports.textoDaBuscaPorSignificado = textoDaBuscaPorSignificado;
 const indice_vetorial_1 = require("./indice-vetorial");
+const locale_1 = require("./locale");
 exports.MODOS_DE_BUSCA = ['hibrido', 'vetor', 'fts'];
 /** D9: constante da fusao RRF. */
 exports.RRF_K = 60;
@@ -185,17 +186,18 @@ function buscarPorSignificado(o) {
  * id do FTS fora do universo e o aviso de cobertura vivem nele, e o texto os perdia na busca que deu certo.
  */
 function textoDaBuscaPorSignificado(r) {
-    const linhas = [`Busca por significado (NAO deterministica; modo ${r.modo}, origem ${r.origem}${r.modeloUsado ? ` ${r.modeloUsado}` : ''})`];
+    const m = (0, locale_1.msg)().operacao.restante.memory.busca;
+    const linhas = [m.titulo(r.modo, r.origem, r.modeloUsado ?? '')];
     if (r.motivo)
-        linhas.push(`  motivo: ${r.motivo}${r.detalhe ? `; ${r.detalhe}` : ''}`);
+        linhas.push(m.motivo(r.motivo, r.detalhe));
     else if (r.detalhe)
-        linhas.push(`  detalhe: ${r.detalhe}`);
+        linhas.push(m.detalhe(r.detalhe));
     linhas.push('');
     r.resultados.forEach((e, i) => {
-        const sim = e.similaridade === null ? '' : `  similaridade ${e.similaridade}`;
+        const sim = e.similaridade === null ? '' : m.similaridade(e.similaridade);
         linhas.push(`  ${i + 1}. [${e.collection}] ${e.id}  score ${e.score}  ${e.fontes.join('+')}${sim}`);
         linhas.push(`      ${e.resumo}`);
     });
-    linhas.push('', `  ${r.resultados.length} resultado(s); busca por tag continua em ork memory search --tags`);
+    linhas.push('', m.resumo(r.resultados.length));
     return linhas.join('\n');
 }

package/dist/catalogo.js

@@ -52,6 +52,7 @@ exports.skillsDoCatalogo = skillsDoCatalogo;
 exports.referenciasDoCatalogo = referenciasDoCatalogo;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const locale_1 = require("./locale");
 /** O que precisa existir para um diretorio ser a raiz do catalogo. */
 const MARCAS = ['skills', 'references', 'eval'];
 function ehRaizDoCatalogo(dir) {
@@ -81,7 +82,7 @@ function raizDoCatalogo(inicial) {
 function exigirCatalogo(inicial) {
     const raiz = raizDoCatalogo(inicial);
     if (!raiz) {
-        throw new Error('catalogo do Orkastery nao encontrado (esperado um diretorio com skills/, references/ e eval/)');
+        throw new locale_1.ErroDoCatalogo((m) => m.adapter.catalogoNaoEncontrado);
     }
     return raiz;
 }

package/dist/changelog-reconciliacao.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * RM-063 (F7): a reconciliacao deterministica do CHANGELOG no merge da base na branch da thread.
+ *
+ * Incidente de 12 e 13/10/2026: os PRs #153 e #154 ficaram prontos e esperaram de 5 a 6 horas pelo condutor, e cada
+ * merge da outra maquina na `main` reabria o conflito no CHANGELOG. Duas formas do mesmo defeito:
+ *
+ *  - o PR de versao troca `## Não publicado` pela secao da versao (`## [0.5.6] - ...`), e o merge da `main` na branch
+ *    poe os itens da thread DENTRO da versao publicada, sem conflito nenhum; o `checar-changelog` do CI acusa
+ *    `changelog.linha-ausente`;
+ *  - duas threads acrescentam item no topo do mesmo grupo de `## Não publicado`, e o merge conflita so no CHANGELOG.
+ *
+ * O condutor resolvia a mao, com um script. Aqui a mesma regra, num lugar so e sem adivinhar: os itens que a thread
+ * acrescentou a `## Não publicado` (os que nem a base comum nem a `main` tem) voltam para la, no mesmo grupo
+ * (`### Adicionado`, `### Corrigido`...), no fim dele e na ordem da thread. O resto do arquivo e o da `main` (no conflito)
+ * ou o do merge (sem conflito): as secoes publicadas nunca recebem nem perdem item da thread por esta funcao. Item que a
+ * thread tirou de `## Não publicado` (a linha reescrita, por exemplo) sai tambem de la, e so de la.
+ *
+ * Funcao pura: recebe os tres textos (base comum, o da thread e o da `main`) e, quando houve, o resultado do merge sem
+ * conflito. Quem roda o git e decide se o conflito e so no CHANGELOG e `conducao-batida.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECAO_NAO_PUBLICADA = exports.ARQUIVO_DO_CHANGELOG = void 0;
+exports.temMarcadorDeConflito = temMarcadorDeConflito;
+exports.reconciliarChangelog = reconciliarChangelog;
+exports.ARQUIVO_DO_CHANGELOG = 'CHANGELOG.md';
+exports.SECAO_NAO_PUBLICADA = '## Não publicado';
+/** A ordem dos grupos que o CHANGELOG ja usa; grupo fora dela vai para o fim da secao. */
+const ORDEM_DOS_GRUPOS = ['Adicionado', 'Alterado', 'Mudado', 'Corrigido', 'Removido', 'Segurança'];
+/** As pontas do conflito do git; o `=======` sozinho tambem e o sublinhado de um titulo setext, e nao conta. */
+const INICIO_DO_CONFLITO = /^<{7}( |$)/m;
+const FIM_DO_CONFLITO = /^>{7}( |$)/m;
+const ehTitulo = (l) => /^#{1,6} /.test(l);
+const ehSecao = (l) => /^## /.test(l);
+const ehGrupo = (l) => /^### /.test(l);
+const ehItem = (l) => /^[-*] /.test(l);
+const emBranco = (l) => l.trim() === '';
+const recuada = (l) => /^\s+\S/.test(l);
+const chaveDe = (linhas) => linhas.map((l) => l.trimEnd()).join('\n');
+/** As linhas do texto, sem o `\r` do Windows. */
+function linhasDe(texto) {
+    return texto.replace(/\r\n/g, '\n').split('\n');
+}
+/**
+ * Os itens de lista de primeiro nivel do CHANGELOG, com a secao e o grupo de cada um. O item vai da linha `- ` ate a
+ * proxima linha que nao e continuacao dele: continuacao e a linha recuada, e a linha em branco so continua o item
+ * quando a seguinte nao vazia e recuada.
+ */
+function itensDe(linhas) {
+    const itens = [];
+    let secao = null, grupo = null;
+    for (let i = 0; i < linhas.length; i++) {
+        const l = linhas[i];
+        if (ehSecao(l)) {
+            secao = l.trim();
+            grupo = null;
+            continue;
+        }
+        if (ehGrupo(l)) {
+            grupo = l.replace(/^###\s+/, '').trim();
+            continue;
+        }
+        if (ehTitulo(l) || !ehItem(l))
+            continue;
+        let fim = i + 1;
+        while (fim < linhas.length) {
+            const c = linhas[fim];
+            if (recuada(c)) {
+                fim++;
+                continue;
+            }
+            if (emBranco(c)) {
+                let k = fim;
+                while (k < linhas.length && emBranco(linhas[k]))
+                    k++;
+                if (k < linhas.length && recuada(linhas[k])) {
+                    fim = k;
+                    continue;
+                }
+            }
+            break;
+        }
+        itens.push({ secao, grupo, inicio: i, fim, chave: chaveDe(linhas.slice(i, fim)) });
+        i = fim - 1;
+    }
+    return itens;
+}
+/** As linhas [inicio, fim) da secao `## Não publicado`, sem o titulo; `null` sem ela. */
+function faixaDaSecao(linhas) {
+    const titulo = linhas.findIndex((l) => l.trim() === exports.SECAO_NAO_PUBLICADA);
+    if (titulo < 0)
+        return null;
+    let fim = titulo + 1;
+    while (fim < linhas.length && !ehSecao(linhas[fim]))
+        fim++;
+    return { titulo, inicio: titulo + 1, fim };
+}
+/** Junta as linhas em branco seguidas numa so (MD012), fora dos blocos de codigo cercados, que ficam como estao. */
+function semBrancosRepetidos(linhas) {
+    const saida = [];
+    let cerca = null;
+    for (const l of linhas) {
+        const marca = /^\s*(`{3,}|~{3,})/.exec(l)?.[1] ?? null;
+        if (marca && (cerca === null || marca[0] === cerca[0]))
+            cerca = cerca === null ? marca : null;
+        if (cerca === null && !marca && emBranco(l) && saida.length > 0 && emBranco(saida[saida.length - 1]))
+            continue;
+        saida.push(cerca === null && emBranco(l) ? '' : l);
+    }
+    return saida;
+}
+/** Quantas vezes cada linha nao vazia aparece (sem o espaco do fim). */
+function contagem(linhas) {
+    const m = new Map();
+    for (const l of linhas) {
+        const k = l.trimEnd();
+        if (k.trim())
+            m.set(k, (m.get(k) ?? 0) + 1);
+    }
+    return m;
+}
+/** As linhas que a thread acrescentou (do lado dela, alem das da base) e que o resultado nao tem tantas vezes. */
+function linhasPerdidas(base, nosso, resultado) {
+    const daBase = contagem(base), doResultado = contagem(resultado);
+    const perdidas = [];
+    for (const [linha, vezes] of contagem(nosso)) {
+        const acrescentadas = vezes - (daBase.get(linha) ?? 0);
+        if (acrescentadas > 0 && (doResultado.get(linha) ?? 0) < acrescentadas)
+            perdidas.push(linha);
+    }
+    return perdidas;
+}
+/** Tira os grupos `### ...` que ficaram sem item nenhum por causa da remocao (os que ja eram vazios ficam). */
+function semGruposEsvaziados(linhas, esvaziados) {
+    const tirar = new Set();
+    for (const g of esvaziados) {
+        let k = g + 1;
+        while (k < linhas.length && emBranco(linhas[k]))
+            k++;
+        if (k >= linhas.length || ehTitulo(linhas[k]))
+            tirar.add(g);
+    }
+    return linhas.filter((_, i) => !tirar.has(i));
+}
+/** O indice do titulo do grupo dentro da faixa, ou -1. */
+function grupoNaFaixa(linhas, faixa, grupo) {
+    for (let i = faixa.inicio; i < faixa.fim; i++) {
+        if (ehGrupo(linhas[i]) && linhas[i].replace(/^###\s+/, '').trim() === grupo)
+            return i;
+    }
+    return -1;
+}
+/** Onde o item entra no grupo: depois da ultima linha nao vazia antes do proximo titulo. */
+function fimDoGrupo(linhas, titulo, limite) {
+    let fim = titulo + 1;
+    while (fim < limite && !ehTitulo(linhas[fim]))
+        fim++;
+    while (fim > titulo + 1 && emBranco(linhas[fim - 1]))
+        fim--;
+    return fim;
+}
+/** Garante a secao `## Não publicado` antes da primeira versao e devolve as linhas com ela. */
+function comSecao(linhas) {
+    if (faixaDaSecao(linhas))
+        return linhas;
+    const primeira = linhas.findIndex((l) => ehSecao(l));
+    const em = primeira < 0 ? linhas.length : primeira;
+    return [...linhas.slice(0, em), exports.SECAO_NAO_PUBLICADA, '', ...linhas.slice(em)];
+}
+/** Insere o item no grupo dele em `## Não publicado`, criando o grupo na ordem do CHANGELOG quando falta. */
+function inserirNoGrupo(linhas, grupo, item) {
+    const faixa = faixaDaSecao(linhas);
+    if (grupo === null) {
+        // Item solto na secao (sem `###`): entra antes do primeiro grupo, depois dos soltos que ja estao la.
+        let em = faixa.inicio;
+        while (em < faixa.fim && !ehGrupo(linhas[em]))
+            em++;
+        while (em > faixa.inicio && emBranco(linhas[em - 1]))
+            em--;
+        return [...linhas.slice(0, em), ...(em === faixa.inicio ? [''] : []), ...item, '', ...linhas.slice(em)];
+    }
+    const titulo = grupoNaFaixa(linhas, faixa, grupo);
+    if (titulo >= 0) {
+        const em = fimDoGrupo(linhas, titulo, faixa.fim);
+        const vazio = em === titulo + 1;
+        return [...linhas.slice(0, em), ...(vazio ? [''] : []), ...item, ...linhas.slice(em)];
+    }
+    // O grupo ainda nao existe na secao: entra antes do primeiro grupo que vem depois dele na ordem conhecida.
+    const ordem = (g) => { const i = ORDEM_DOS_GRUPOS.indexOf(g); return i < 0 ? ORDEM_DOS_GRUPOS.length : i; };
+    let em = faixa.fim;
+    for (let i = faixa.inicio; i < faixa.fim; i++) {
+        if (ehGrupo(linhas[i]) && ordem(linhas[i].replace(/^###\s+/, '').trim()) > ordem(grupo)) {
+            em = i;
+            break;
+        }
+    }
+    return [...linhas.slice(0, em), '', `### ${grupo}`, '', ...item, '', ...linhas.slice(em)];
+}
+/** O texto tem as duas pontas de um conflito do git? */
+function temMarcadorDeConflito(texto) {
+    return INICIO_DO_CONFLITO.test(texto) && FIM_DO_CONFLITO.test(texto);
+}
+/**
+ * Reconcilia o CHANGELOG depois do merge da base na branch da thread. Os itens da thread em `## Não publicado`
+ * voltam para la, no mesmo grupo; o que a thread tirou de la sai de la; o resto e o da `main` ou o do merge.
+ */
+function reconciliarChangelog(e) {
+    const base = linhasDe(e.base), nosso = linhasDe(e.nosso), deles = linhasDe(e.deles);
+    const daBase = itensDe(base), dosNossos = itensDe(nosso), dosDeles = itensDe(deles);
+    const chavesDaBase = new Set(daBase.map((i) => i.chave));
+    const chavesDosDeles = new Set(dosDeles.map((i) => i.chave));
+    // Os itens da thread: em `## Não publicado` do lado dela, e em nenhum lugar da base comum nem da `main`.
+    const vistos = new Set();
+    const daThread = dosNossos.filter((i) => i.secao === exports.SECAO_NAO_PUBLICADA && !chavesDaBase.has(i.chave) &&
+        !chavesDosDeles.has(i.chave) && !vistos.has(i.chave) && (vistos.add(i.chave), true));
+    // O que a thread tirou de `## Não publicado`: estava la na base comum e nao esta mais em lugar nenhum do lado dela.
+    const chavesDosNossos = new Set(dosNossos.map((i) => i.chave));
+    const tiradas = new Set(daBase.filter((i) => i.secao === exports.SECAO_NAO_PUBLICADA && !chavesDosNossos.has(i.chave)).map((i) => i.chave));
+    const textoInicial = e.mesclado && !temMarcadorDeConflito(e.mesclado) ? e.mesclado : e.deles;
+    const crlf = textoInicial.includes('\r\n');
+    const fimDeLinha = textoInicial.endsWith('\n');
+    let linhas = linhasDe(textoInicial);
+    if (fimDeLinha)
+        linhas.pop();
+    const original = chaveDe(linhas);
+    // A thread que nao acrescentou nem tirou item de "Não publicado" nao muda nada: o arquivo fica como o merge (ou a main)
+    // o deixou, sem normalizar o que nao e dela.
+    if (!daThread.length && !tiradas.size) {
+        return { texto: textoInicial, perdidas: linhasPerdidas(base, nosso, linhas), itens: [], devolvidos: 0, mudou: false };
+    }
+    // 1. Tira os itens da thread de onde o merge os pos, e os tirados pela thread de `## Não publicado`. O item da thread
+    // que o merge deixou em `## Não publicado`, no grupo dele, fica onde esta (a primeira vez); as outras copias saem.
+    const grupoDaThread = new Map(daThread.map((i) => [i.chave, i.grupo]));
+    const noLugar = new Set();
+    const remover = itensDe(linhas).filter((i) => {
+        if (i.secao === exports.SECAO_NAO_PUBLICADA && tiradas.has(i.chave))
+            return true;
+        if (!grupoDaThread.has(i.chave))
+            return false;
+        if (i.secao === exports.SECAO_NAO_PUBLICADA && i.grupo === grupoDaThread.get(i.chave) && !noLugar.has(i.chave)) {
+            noLugar.add(i.chave);
+            return false;
+        }
+        return true;
+    });
+    const gruposTocados = new Set();
+    for (const i of remover) {
+        for (let g = i.inicio - 1; g >= 0; g--) {
+            if (ehGrupo(linhas[g])) {
+                gruposTocados.add(g);
+                break;
+            }
+            if (ehSecao(linhas[g]))
+                break;
+        }
+    }
+    const linhasRemovidas = new Set();
+    for (const i of remover)
+        for (let k = i.inicio; k < i.fim; k++)
+            linhasRemovidas.add(k);
+    // Os titulos de grupo que ficaram vazios saem, com o indice ajustado pela remocao.
+    const novoIndice = new Map();
+    let n = 0;
+    const filtradas = [];
+    for (let k = 0; k < linhas.length; k++) {
+        if (linhasRemovidas.has(k))
+            continue;
+        novoIndice.set(k, n++);
+        filtradas.push(linhas[k]);
+    }
+    linhas = semGruposEsvaziados(filtradas, new Set([...gruposTocados].map((g) => novoIndice.get(g)).filter((g) => g !== undefined)));
+    // 2. Os itens da thread que nao ficaram no lugar entram em `## Não publicado`, no grupo de cada um, na ordem da thread.
+    const aDevolver = daThread.filter((i) => !noLugar.has(i.chave));
+    if (aDevolver.length)
+        linhas = comSecao(linhas);
+    for (const i of aDevolver)
+        linhas = inserirNoGrupo(linhas, i.grupo, nosso.slice(i.inicio, i.fim).map((l) => l.trimEnd()));
+    linhas = semBrancosRepetidos(linhas);
+    while (linhas.length && emBranco(linhas[linhas.length - 1]))
+        linhas.pop();
+    const quebra = crlf ? '\r\n' : '\n';
+    const texto = linhas.join(quebra) + (fimDeLinha ? quebra : '');
+    return {
+        texto,
+        perdidas: linhasPerdidas(base, nosso, linhas),
+        itens: daThread.map((i) => ({ grupo: i.grupo, titulo: nosso[i.inicio].trim().slice(0, 200) })),
+        devolvidos: aDevolver.length,
+        mudou: chaveDe(linhas) !== original,
+    };
+}