@fontdata/ai-harness 3.3.1 → 4.0.0

package/dist/versao/config.js

@@ -0,0 +1,325 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+export const VERSAO_CONFIG_PATH = join('.ai-harness', 'versao.json');
+export const EXTRATORES_SIMPLES = ['dproj', 'pubspec', 'pyproject', 'csproj', 'versoes-txt'];
+export const EXTRATORES_ACEITOS = ['json:<caminho>', 'dproj', 'regex', 'pubspec', 'pyproject', 'csproj', 'versoes-txt'];
+export const BUMPS_PADRAO = ['auto', 'major', 'minor', 'patch', 'build'];
+export const SEGMENTOS_MIN = 1;
+export const SEGMENTOS_MAX = 4;
+export class VersaoConfigErro extends Error {
+    problemas;
+    constructor(problemas, origem = 'versao.json') {
+        super(`${origem} inválido:\n${problemas.map((p) => `- ${p}`).join('\n')}`);
+        this.problemas = problemas;
+        this.name = 'VersaoConfigErro';
+    }
+}
+const CAMPOS_RAIZ = ['$schema', 'arquivos', 'tag', 'segmentos', 'formato', 'bump', 'apps', 'changelogs', 'gerador', 'naoTocar', 'commit', 'validar'];
+const CAMPOS_ARQUIVO = ['caminho', 'extrator', 'padrao', 'formato', 'padding'];
+const CAMPOS_APP = ['caminhos', 'arquivos', 'tag', 'changelogs'];
+const CAMPOS_BUMP = ['padrao'];
+const MODELO_FORMATO = /^[^{}]*(?:\{[1-9]\d*\}[^{}]*)+$/;
+const MARCADORES_TAG = new Set(['{versao}', '{app}']);
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Converte o caminho do extrator `json:` numa lista de chaves; `null` quando a sintaxe é inválida.
+ * Chaves separadas por ponto; `["..."]` (string JSON) aceita qualquer chave, inclusive vazia ou com ponto.
+ */
+export function parseCaminhoJson(texto) {
+    const chaves = [];
+    let i = 0;
+    while (i < texto.length) {
+        const resto = texto.slice(i);
+        const colchete = /^\[("(?:[^"\\]|\\.)*")\]/.exec(resto);
+        if (colchete) {
+            try {
+                chaves.push(JSON.parse(colchete[1]));
+            }
+            catch {
+                return null;
+            }
+            i += colchete[0].length;
+        }
+        else {
+            const nome = /^[^.[\]"]+/.exec(resto);
+            if (!nome)
+                return null;
+            chaves.push(nome[0]);
+            i += nome[0].length;
+        }
+        if (i === texto.length || texto[i] === '[')
+            continue;
+        if (texto[i] !== '.')
+            return null;
+        i += 1;
+        if (i === texto.length || texto[i] === '[' || texto[i] === '.')
+            return null;
+    }
+    return chaves.length > 0 ? chaves : null;
+}
+function contarGrupos(padrao) {
+    return (new RegExp(`${padrao}|`).exec('')?.length ?? 1) - 1;
+}
+function contarSegmentosDoFormato(formato) {
+    return formato.match(/\{\d+\}/g)?.length ?? 0;
+}
+class Validador {
+    problemas = [];
+    erro(caminho, mensagem) {
+        this.problemas.push(`${caminho}: ${mensagem}`);
+    }
+    camposDesconhecidos(obj, aceitos, prefixo) {
+        for (const chave of Object.keys(obj)) {
+            if (!aceitos.includes(chave)) {
+                this.erro(prefixo ? `${prefixo}.${chave}` : chave, `campo desconhecido; os aceitos são ${aceitos.filter((c) => c !== '$schema').join(', ')}`);
+            }
+        }
+    }
+    texto(valor, caminho) {
+        if (valor === undefined)
+            return undefined;
+        if (typeof valor !== 'string' || valor.trim() === '') {
+            this.erro(caminho, 'deve ser um texto não vazio');
+            return undefined;
+        }
+        return valor;
+    }
+    caminhoRelativo(valor, caminho) {
+        const texto = this.texto(valor, caminho);
+        if (texto === undefined)
+            return undefined;
+        if (isAbsolute(texto) || /^[A-Za-z]:[\\/]/.test(texto) || texto.split(/[\\/]/).includes('..')) {
+            this.erro(caminho, `deve ser relativo à raiz do projeto, sem "..": "${texto}"`);
+            return undefined;
+        }
+        return texto;
+    }
+    listaDeCaminhos(valor, caminho, obrigatoria = false) {
+        if (valor === undefined) {
+            if (obrigatoria)
+                this.erro(caminho, 'é obrigatório: lista de caminhos relativos à raiz');
+            return [];
+        }
+        if (!Array.isArray(valor)) {
+            this.erro(caminho, 'deve ser uma lista de caminhos');
+            return [];
+        }
+        if (obrigatoria && valor.length === 0)
+            this.erro(caminho, 'deve ter ao menos um caminho');
+        return valor.flatMap((item, indice) => this.caminhoRelativo(item, `${caminho}[${indice}]`) ?? []);
+    }
+    tag(valor, caminho) {
+        const tag = this.texto(valor, caminho);
+        if (tag === undefined)
+            return undefined;
+        const desconhecidos = (tag.match(/\{[^}]*\}/g) ?? []).filter((m) => !MARCADORES_TAG.has(m));
+        if (!tag.includes('{versao}'))
+            this.erro(caminho, `deve conter {versao}: "${tag}"`);
+        else if (desconhecidos.length > 0)
+            this.erro(caminho, `marcador desconhecido ${desconhecidos.join(', ')}; use {versao} e {app}`);
+        else
+            return tag;
+        return undefined;
+    }
+    formato(valor, caminho, segmentos) {
+        const formato = this.texto(valor, caminho);
+        if (formato === undefined)
+            return undefined;
+        if (!MODELO_FORMATO.test(formato)) {
+            this.erro(caminho, `deve ser um modelo como "{1}.{3}.{2}.{2}", com a largura de cada segmento entre chaves: "${formato}"`);
+            return undefined;
+        }
+        if (segmentos !== undefined && contarSegmentosDoFormato(formato) !== segmentos) {
+            this.erro(caminho, `tem ${contarSegmentosDoFormato(formato)} segmentos, mas segmentos é ${segmentos}`);
+            return undefined;
+        }
+        return formato;
+    }
+    padding(valor, caminho, segmentos) {
+        if (valor === undefined)
+            return undefined;
+        if (!Array.isArray(valor) || valor.some((n) => typeof n !== 'number' || !Number.isInteger(n) || n < 1)) {
+            this.erro(caminho, 'deve ser uma lista com a largura mínima (inteiro >= 1) de cada segmento');
+            return undefined;
+        }
+        if (segmentos !== undefined && valor.length !== segmentos) {
+            this.erro(caminho, `tem ${valor.length} larguras, mas segmentos é ${segmentos}`);
+            return undefined;
+        }
+        return valor;
+    }
+    extrator(item, caminho) {
+        const bruto = item.extrator;
+        const aceitos = `os aceitos são ${EXTRATORES_ACEITOS.join(', ')}`;
+        if (typeof bruto !== 'string' || bruto === '') {
+            this.erro(`${caminho}.extrator`, `é obrigatório; ${aceitos}`);
+            return undefined;
+        }
+        if (bruto !== 'regex' && item.padrao !== undefined)
+            this.erro(`${caminho}.padrao`, 'só vale com o extrator regex');
+        if (bruto.startsWith('json:')) {
+            const chaves = parseCaminhoJson(bruto.slice('json:'.length));
+            if (chaves)
+                return { tipo: 'json', caminho: chaves };
+            this.erro(`${caminho}.extrator`, `caminho JSON inválido em "${bruto}"; use chaves separadas por ponto e ["..."] para chave vazia ou com ponto, ex.: json:packages[""].version`);
+            return undefined;
+        }
+        if (bruto === 'regex')
+            return this.regex(item.padrao, `${caminho}.padrao`);
+        if (EXTRATORES_SIMPLES.includes(bruto))
+            return { tipo: bruto };
+        this.erro(`${caminho}.extrator`, `extrator desconhecido "${bruto}"; ${aceitos}`);
+        return undefined;
+    }
+    regex(valor, caminho) {
+        if (typeof valor !== 'string' || valor === '') {
+            this.erro(caminho, 'é obrigatório com o extrator regex: expressão com um grupo de captura para a versão');
+            return undefined;
+        }
+        let grupos;
+        try {
+            grupos = contarGrupos(valor);
+        }
+        catch (erro) {
+            this.erro(caminho, `expressão regular inválida: ${erro.message}`);
+            return undefined;
+        }
+        if (grupos < 1) {
+            this.erro(caminho, 'a expressão precisa de um grupo de captura com a versão, ex.: version = "([^"]+)"');
+            return undefined;
+        }
+        return { tipo: 'regex', padrao: valor };
+    }
+    arquivos(valor, caminho, segmentos) {
+        if (valor === undefined)
+            return [];
+        if (!Array.isArray(valor)) {
+            this.erro(caminho, 'deve ser uma lista de { caminho, extrator }');
+            return [];
+        }
+        return valor.flatMap((item, indice) => {
+            const prefixo = `${caminho}[${indice}]`;
+            if (!isObject(item)) {
+                this.erro(prefixo, 'deve ser um objeto { caminho, extrator }');
+                return [];
+            }
+            this.camposDesconhecidos(item, CAMPOS_ARQUIVO, prefixo);
+            if (item.caminho === undefined)
+                this.erro(`${prefixo}.caminho`, 'é obrigatório');
+            const arquivoCaminho = this.caminhoRelativo(item.caminho, `${prefixo}.caminho`);
+            const extrator = this.extrator(item, prefixo);
+            const formato = this.formato(item.formato, `${prefixo}.formato`, segmentos);
+            const padding = this.padding(item.padding, `${prefixo}.padding`, segmentos);
+            if (arquivoCaminho === undefined || extrator === undefined)
+                return [];
+            const arquivo = { caminho: arquivoCaminho, extrator };
+            if (formato !== undefined)
+                arquivo.formato = formato;
+            if (padding !== undefined)
+                arquivo.padding = padding;
+            return [arquivo];
+        });
+    }
+    app(nome, valor, segmentos) {
+        const prefixo = `apps.${nome}`;
+        if (!isObject(valor)) {
+            this.erro(prefixo, 'deve ser um objeto com caminhos, arquivos, tag e changelogs');
+            return undefined;
+        }
+        this.camposDesconhecidos(valor, CAMPOS_APP, prefixo);
+        const app = {
+            caminhos: this.listaDeCaminhos(valor.caminhos, `${prefixo}.caminhos`, true),
+            arquivos: this.arquivos(valor.arquivos, `${prefixo}.arquivos`, segmentos),
+            changelogs: this.listaDeCaminhos(valor.changelogs, `${prefixo}.changelogs`),
+        };
+        const tag = this.tag(valor.tag, `${prefixo}.tag`);
+        if (tag !== undefined)
+            app.tag = tag;
+        return app;
+    }
+}
+/** Valida o JSON bruto do `versao.json` e devolve a config normalizada; lança `VersaoConfigErro` com todos os problemas. */
+export function validarVersaoConfig(bruto, origem) {
+    const v = new Validador();
+    if (!isObject(bruto))
+        throw new VersaoConfigErro(['a raiz deve ser um objeto JSON'], origem);
+    v.camposDesconhecidos(bruto, CAMPOS_RAIZ, '');
+    let segmentos;
+    if (bruto.segmentos !== undefined) {
+        const s = bruto.segmentos;
+        if (typeof s === 'number' && Number.isInteger(s) && s >= SEGMENTOS_MIN && s <= SEGMENTOS_MAX)
+            segmentos = s;
+        else
+            v.erro('segmentos', `deve ser um inteiro de ${SEGMENTOS_MIN} a ${SEGMENTOS_MAX}`);
+    }
+    let padrao = 'auto';
+    if (bruto.bump !== undefined) {
+        if (!isObject(bruto.bump))
+            v.erro('bump', 'deve ser um objeto { padrao }');
+        else {
+            v.camposDesconhecidos(bruto.bump, CAMPOS_BUMP, 'bump');
+            const p = bruto.bump.padrao;
+            if (p === undefined)
+                padrao = 'auto';
+            else if (BUMPS_PADRAO.includes(p))
+                padrao = p;
+            else
+                v.erro('bump.padrao', `valor "${String(p)}" inválido; use ${BUMPS_PADRAO.join(', ')}`);
+        }
+    }
+    const apps = {};
+    if (bruto.apps !== undefined) {
+        if (!isObject(bruto.apps))
+            v.erro('apps', 'deve ser um objeto { <nome>: { caminhos, ... } }');
+        else {
+            for (const [nome, valor] of Object.entries(bruto.apps)) {
+                if (nome.trim() === '') {
+                    v.erro('apps', 'o nome do app não pode ser vazio');
+                    continue;
+                }
+                const app = v.app(nome, valor, segmentos);
+                if (app)
+                    apps[nome] = app;
+            }
+        }
+    }
+    const config = {
+        arquivos: v.arquivos(bruto.arquivos, 'arquivos', segmentos),
+        bump: { padrao },
+        apps,
+        changelogs: v.listaDeCaminhos(bruto.changelogs, 'changelogs'),
+        naoTocar: v.listaDeCaminhos(bruto.naoTocar, 'naoTocar'),
+    };
+    const opcionais = {
+        tag: v.tag(bruto.tag, 'tag'),
+        segmentos,
+        formato: v.formato(bruto.formato, 'formato', segmentos),
+        gerador: v.texto(bruto.gerador, 'gerador'),
+        commit: v.texto(bruto.commit, 'commit'),
+        validar: v.texto(bruto.validar, 'validar'),
+    };
+    for (const [chave, valor] of Object.entries(opcionais)) {
+        if (valor !== undefined)
+            Object.assign(config, { [chave]: valor });
+    }
+    if (v.problemas.length > 0)
+        throw new VersaoConfigErro(v.problemas, origem);
+    return config;
+}
+/** Lê `.ai-harness/versao.json` da raiz; `null` quando o arquivo não existe, erro quando é inválido. */
+export function carregarVersaoConfig(raiz) {
+    const caminho = join(raiz, VERSAO_CONFIG_PATH);
+    if (!existsSync(caminho))
+        return null;
+    const origem = VERSAO_CONFIG_PATH.split('\\').join('/');
+    let bruto;
+    try {
+        bruto = JSON.parse(readFileSync(caminho, 'utf8').replace(/^\uFEFF/, ''));
+    }
+    catch (erro) {
+        throw new VersaoConfigErro([`JSON inválido: ${erro.message}`], origem);
+    }
+    return validarVersaoConfig(bruto, origem);
+}

package/dist/versao/detectar.js

@@ -0,0 +1,332 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { SEGMENTOS_MAX, SEGMENTOS_MIN } from './config.js';
+import { criarExtrator } from './extratores/index.js';
+import { formatarVersao } from './formato.js';
+const json = (...caminho) => ({ tipo: 'json', caminho });
+const CANDIDATOS = [
+    { casa: /^package\.json$/, extratores: [json('version')] },
+    { casa: /^package-lock\.json$/, extratores: [json('version'), json('packages', '', 'version')] },
+    { casa: /^app\.json$/, extratores: [json('expo', 'version')] },
+    { casa: /^composer\.json$/, extratores: [json('version')] },
+    { casa: /^pubspec\.yaml$/, extratores: [{ tipo: 'pubspec' }] },
+    { casa: /^pyproject\.toml$/, extratores: [{ tipo: 'pyproject' }] },
+    { casa: /\.csproj$/i, extratores: [{ tipo: 'csproj' }] },
+    { casa: /\.dproj$/i, extratores: [{ tipo: 'dproj' }] },
+    { casa: /^vers(?:o|õ)es\.txt$/i, extratores: [{ tipo: 'versoes-txt' }] },
+];
+const PASTAS_IGNORADAS = new Set(['node_modules', 'dist', 'build', '__history', '__recovery', 'bin', 'obj']);
+const MODELOS_TAG = [
+    ['V{versao}', /^V\d+(?:\.\d+)+$/],
+    ['v{versao}', /^v\d+(?:\.\d+)+$/],
+    ['{versao}', /^\d+(?:\.\d+)+$/],
+    ['{app}-v{versao}', /^.+-v\d+(?:\.\d+)+$/],
+];
+/** Texto do extrator como escrito no `versao.json` (inverso do `parseCaminhoJson`). */
+export function extratorParaTexto(cfg) {
+    if (cfg.tipo !== 'json')
+        return cfg.tipo;
+    const caminho = cfg.caminho
+        .map((chave, i) => (/^[^.[\]"]+$/.test(chave) ? `${i > 0 ? '.' : ''}${chave}` : `[${JSON.stringify(chave)}]`))
+        .join('');
+    return `json:${caminho}`;
+}
+function juntar(base, nome) {
+    return base ? `${base}/${nome}` : nome;
+}
+function varrer(raiz, base, profundidade) {
+    let entradas;
+    try {
+        entradas = readdirSync(join(raiz, base), { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    entradas.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const achados = [];
+    for (const e of entradas) {
+        if (e.isFile()) {
+            const candidato = CANDIDATOS.find((c) => c.casa.test(e.name));
+            for (const extrator of candidato?.extratores ?? [])
+                achados.push({ caminho: juntar(base, e.name), extrator });
+        }
+    }
+    if (profundidade > 0) {
+        for (const e of entradas) {
+            if (e.isDirectory() && !e.name.startsWith('.') && !PASTAS_IGNORADAS.has(e.name)) {
+                achados.push(...varrer(raiz, juntar(base, e.name), profundidade - 1));
+            }
+        }
+    }
+    return achados;
+}
+function lerFontes(raiz, arquivos, problemas) {
+    return arquivos.map((arquivo) => {
+        const fonte = { caminho: arquivo.caminho, extrator: arquivo.extrator, ocorrencias: [] };
+        if (arquivo.formato !== undefined)
+            fonte.formato = arquivo.formato;
+        if (arquivo.padding !== undefined)
+            fonte.padding = arquivo.padding;
+        const absoluto = join(raiz, arquivo.caminho);
+        const descricao = `${arquivo.caminho} (${extratorParaTexto(arquivo.extrator)})`;
+        if (!existsSync(absoluto)) {
+            problemas.push(`${descricao}: arquivo não encontrado`);
+            return fonte;
+        }
+        try {
+            fonte.ocorrencias = criarExtrator(arquivo.extrator).ler(arquivo.caminho, readFileSync(absoluto));
+        }
+        catch (erro) {
+            problemas.push(`${descricao}: ${erro.message}`);
+            return fonte;
+        }
+        if (fonte.ocorrencias.length === 0)
+            problemas.push(`${descricao}: versão não encontrada`);
+        return fonte;
+    });
+}
+function numeros(valor) {
+    const m = /^\d+(?:\.\d+)*/.exec(valor.trim());
+    return m ? m[0].split('.').map(Number) : null;
+}
+function chaveDeComparacao(valor) {
+    return valor.trim().replace(/\d+/g, (d) => d.replace(/^0+(?=\d)/, ''));
+}
+function compararNumeros(a, b) {
+    if (!a || !b)
+        return (a ? 1 : 0) - (b ? 1 : 0);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const d = (a[i] ?? 0) - (b[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+function formatoDoValor(valor) {
+    const v = valor.trim();
+    if (!/^\d+(?:\.\d+)+$/.test(v))
+        return null;
+    return v.split('.').map((s) => `{${s.length}}`).join('.');
+}
+function temZeroAEsquerda(valor) {
+    return formatoDoValor(valor) !== null && valor.trim().split('.').some((s) => /^0\d/.test(s));
+}
+/**
+ * A versão atual é a maior entre as ocorrências, escrita no `formato` quando há; as que não batem com ela,
+ * comparadas por segmento numérico (`5.000.05.01` = `5.0.5.1`), viram divergências.
+ */
+function analisar(fontes, formato) {
+    const ocorrencias = fontes.flatMap((f) => f.ocorrencias);
+    let maior;
+    for (const o of ocorrencias) {
+        if (!maior || compararNumeros(numeros(o.valor), numeros(maior.valor)) > 0)
+            maior = o;
+    }
+    if (!maior)
+        return { versaoAtual: null, divergencias: [] };
+    let versaoAtual = maior.valor.trim();
+    if (formato && /^\d+(?:\.\d+)*$/.test(versaoAtual)) {
+        try {
+            versaoAtual = formatarVersao(numeros(versaoAtual), formato);
+        }
+        catch {
+            versaoAtual = maior.valor.trim();
+        }
+    }
+    const referencia = chaveDeComparacao(maior.valor);
+    const divergencias = ocorrencias
+        .filter((o) => chaveDeComparacao(o.valor) !== referencia)
+        .map((o) => ({
+        arquivo: o.arquivo,
+        grupo: o.grupo ?? null,
+        linha: o.linha,
+        valor: o.valor,
+        versaoAtual,
+        mensagem: `${o.arquivo}${o.grupo ? ` (${o.grupo})` : ''}, linha ${o.linha}: ${o.valor} difere da versão atual ${versaoAtual}`,
+    }));
+    return { versaoAtual, divergencias };
+}
+function inferirTag(raiz, padrao) {
+    const r = spawnSync('git', ['tag', '--list'], { cwd: raiz, encoding: 'utf8' });
+    if (r.error || r.status !== 0)
+        return padrao;
+    const contagem = new Map();
+    for (const tag of r.stdout.split('\n').map((t) => t.trim())) {
+        const modelo = MODELOS_TAG.find(([, regex]) => regex.test(tag))?.[0];
+        if (modelo)
+            contagem.set(modelo, (contagem.get(modelo) ?? 0) + 1);
+    }
+    let melhor = null;
+    for (const [modelo] of MODELOS_TAG) {
+        const n = contagem.get(modelo) ?? 0;
+        if (n > 0 && (!melhor || n > melhor[1]))
+            melhor = [modelo, n];
+    }
+    return melhor?.[0] ?? padrao;
+}
+function ehMonorepoPnpm(raiz) {
+    const caminho = join(raiz, 'pnpm-workspace.yaml');
+    if (!existsSync(caminho))
+        return false;
+    try {
+        const pacotes = parseYaml(readFileSync(caminho, 'utf8'))?.packages;
+        return Array.isArray(pacotes) && pacotes.some((p) => typeof p === 'string' && /^(?:\.\/)?apps\//.test(p));
+    }
+    catch {
+        return false;
+    }
+}
+function appsDoMonorepo(raiz) {
+    if (!ehMonorepoPnpm(raiz))
+        return [];
+    try {
+        return readdirSync(join(raiz, 'apps'), { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith('.') && !PASTAS_IGNORADAS.has(e.name))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function segmentosUnanimes(fontes) {
+    const contagens = new Set(fontes.flatMap((f) => f.ocorrencias.map((o) => numeros(o.valor)?.length ?? 0)));
+    const [unica] = contagens;
+    return contagens.size === 1 && unica >= SEGMENTOS_MIN && unica <= SEGMENTOS_MAX ? unica : null;
+}
+function inferirFormato(fontes) {
+    let escolhida;
+    for (const o of fontes.flatMap((f) => f.ocorrencias)) {
+        if (!temZeroAEsquerda(o.valor))
+            continue;
+        if (!escolhida || compararNumeros(numeros(o.valor), numeros(escolhida.valor)) > 0)
+            escolhida = o;
+    }
+    return escolhida ? formatoDoValor(escolhida.valor) : null;
+}
+function aplicarFormatoPorArquivo(fontes, formato) {
+    if (!formato)
+        return;
+    for (const fonte of fontes) {
+        const valor = fonte.ocorrencias.find((o) => formatoDoValor(o.valor))?.valor;
+        if (!valor)
+            continue;
+        const proprio = temZeroAEsquerda(valor) ? formatoDoValor(valor) : valor.trim().split('.').map(() => '{1}').join('.');
+        if (proprio !== formato)
+            fonte.formato = proprio;
+    }
+}
+function proporArquivos(fontes) {
+    return fontes.map((f) => {
+        const arquivo = { caminho: f.caminho, extrator: extratorParaTexto(f.extrator) };
+        if (f.formato !== undefined)
+            arquivo.formato = f.formato;
+        return arquivo;
+    });
+}
+function changelogs(raiz, base, fontes) {
+    const lista = existsSync(join(raiz, base, 'CHANGELOG.md')) ? [juntar(base, 'CHANGELOG.md')] : [];
+    for (const f of fontes)
+        if (f.extrator.tipo === 'versoes-txt' && !lista.includes(f.caminho))
+            lista.push(f.caminho);
+    return lista;
+}
+function detectarSemConfig(raiz, app) {
+    const problemas = [];
+    const comVersao = (fontes) => fontes.filter((f) => f.ocorrencias.length > 0);
+    const raizFontes = comVersao(lerFontes(raiz, varrer(raiz, '', 1), problemas));
+    const fontesPorApp = new Map();
+    for (const nome of appsDoMonorepo(raiz)) {
+        const fontes = comVersao(lerFontes(raiz, varrer(raiz, `apps/${nome}`, 1), problemas));
+        if (fontes.length > 0)
+            fontesPorApp.set(nome, fontes);
+    }
+    if (app !== undefined && !fontesPorApp.has(app)) {
+        const conhecidos = [...fontesPorApp.keys()];
+        throw new Error(`app "${app}" não encontrado em apps/ do monorepo; ${conhecidos.length ? `os apps são ${conhecidos.join(', ')}` : 'nenhum app detectado'}`);
+    }
+    const todas = [...raizFontes, ...[...fontesPorApp.values()].flat()];
+    const formato = inferirFormato(todas);
+    aplicarFormatoPorArquivo(todas, formato);
+    const tag = inferirTag(raiz, fontesPorApp.size > 0 ? '{app}-v{versao}' : 'v{versao}');
+    const apps = {};
+    const appsPropostos = {};
+    for (const [nome, fontes] of fontesPorApp) {
+        apps[nome] = { caminhos: [`apps/${nome}/`], fontes, ...analisar(fontes, formato), tag };
+        const proposto = { caminhos: [`apps/${nome}/`], arquivos: proporArquivos(fontes) };
+        const logs = changelogs(raiz, `apps/${nome}`, fontes);
+        if (logs.length > 0)
+            proposto.changelogs = logs;
+        appsPropostos[nome] = proposto;
+    }
+    const fontes = app === undefined ? raizFontes : [...raizFontes, ...fontesPorApp.get(app)];
+    const { versaoAtual, divergencias } = analisar(fontes, formato);
+    const segmentosPropostos = segmentosUnanimes(todas);
+    const versaoJson = {
+        arquivos: proporArquivos(raizFontes),
+        tag,
+        bump: { padrao: todas.some((f) => f.extrator.tipo === 'dproj') ? 'build' : 'auto' },
+        changelogs: changelogs(raiz, '', raizFontes),
+        naoTocar: [],
+    };
+    if (segmentosPropostos !== null)
+        versaoJson.segmentos = segmentosPropostos;
+    if (formato)
+        versaoJson.formato = formato;
+    if (fontesPorApp.size > 0)
+        versaoJson.apps = appsPropostos;
+    return {
+        origem: 'deteccao',
+        app: app ?? null,
+        fontes,
+        versaoAtual,
+        divergencias,
+        tag,
+        segmentos: versaoAtual !== null ? (numeros(versaoAtual)?.length ?? null) : segmentosPropostos,
+        formato,
+        apps,
+        problemas,
+        versaoJson,
+    };
+}
+function detectarComConfig(raiz, config, app) {
+    const appConfig = app === undefined ? undefined : config.apps[app];
+    if (app !== undefined && !appConfig) {
+        const conhecidos = Object.keys(config.apps);
+        throw new Error(`app "${app}" não existe no versao.json; ${conhecidos.length ? `os apps são ${conhecidos.join(', ')}` : 'não há apps declarados'}`);
+    }
+    const problemas = [];
+    const formato = config.formato ?? null;
+    const tagRaiz = config.tag ?? inferirTag(raiz, Object.keys(config.apps).length > 0 ? '{app}-v{versao}' : 'v{versao}');
+    const raizFontes = lerFontes(raiz, config.arquivos, problemas);
+    const apps = {};
+    for (const [nome, a] of Object.entries(config.apps)) {
+        const fontes = lerFontes(raiz, a.arquivos, problemas);
+        apps[nome] = { caminhos: a.caminhos, fontes, ...analisar(fontes, formato), tag: a.tag ?? tagRaiz };
+    }
+    const fontes = app === undefined ? raizFontes : [...raizFontes, ...apps[app].fontes];
+    const { versaoAtual, divergencias } = analisar(fontes, formato);
+    return {
+        origem: 'config',
+        app: app ?? null,
+        fontes,
+        versaoAtual,
+        divergencias,
+        tag: appConfig?.tag ?? tagRaiz,
+        segmentos: config.segmentos ?? (versaoAtual !== null ? (numeros(versaoAtual)?.length ?? null) : null),
+        formato,
+        apps,
+        problemas: [...new Set(problemas)],
+        versaoJson: null,
+    };
+}
+/**
+ * Descobre as fontes de versão: com `config`, só os arquivos declarados (mais os do `app`); sem ela, varre a
+ * raiz e um nível abaixo, mais os `apps/*` de monorepo pnpm, e propõe um `versaoJson`. Lança erro para app
+ * desconhecido; config sem fonte devolve `fontes` vazias e quem chama decide o erro.
+ */
+export function detectarFontes(raiz, config, app) {
+    return config ? detectarComConfig(raiz, config, app) : detectarSemConfig(raiz, app);
+}