@fontdata/ai-harness 2.6.0 → 3.0.0

package/dist/banco-dados/command.js

@@ -0,0 +1,432 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { EOL } from 'node:os';
+import { join, resolve } from 'node:path';
+import * as p from '@clack/prompts';
+import { comSecaoBanco, CONFIG_PATH, gravarConexaoProjeto, readConfig, REGRA_DSN_ENV, REGRA_NOME_CONEXAO, secaoBanco, validarConfigParaEscrita, writeDefaultConfig, } from '../config/config.js';
+import { suggestFlag } from '../install/flags.js';
+import { caminhoCadastro, lerCadastro, ocultarSenha, removerConexao, resumirConexao, salvarConexao, TIPOS_BANCO, } from './cadastro.js';
+import { gravarVariavelSettingsLocal, lerEnvSettingsLocal, lerVariavel, SETTINGS_LOCAL_PATH, validarSettingsLocal } from './ambiente.js';
+import { interpretarDsn, resolverConexoes } from './conexao.js';
+import { criarDriver as criarDriverPadrao } from './drivers/index.js';
+const AJUDA = [
+    'Uso: ai-harness banco-dados <subcomando>',
+    '',
+    '  adicionar <nome> [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]',
+    '                     cadastra a conexão nesta máquina (sem --dsn, pergunta os dados)',
+    '  adicionar <nome> --projeto [--env <VAR>] [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]',
+    '                     grava o DSN na variável <NOME>_DATABASE_URL (ou --env) do .claude/settings.local.json',
+    '                     e a conexão { nome, dsn_env } em banco_dados.conexoes do .ai-harness/config.json',
+    '  listar             mostra as conexões cadastradas e as do projeto, sem a senha',
+    '  testar [nome]      testa a conexão pedida ou todas as do projeto',
+    '  usar <nome...>     grava banco_dados.conexoes no .ai-harness/config.json (mantém as entradas { nome, dsn_env })',
+    '  remover <nome>     apaga a conexão do cadastro',
+].join(EOL);
+const PORTA_PADRAO = { postgres: '5432', mariadb: '3306' };
+const ESQUEMA = { postgres: 'postgres', mariadb: 'mysql' };
+function mascarar(ctx, texto) {
+    return ctx.sensiveis.reduce((resultado, conexao) => ocultarSenha(resultado, conexao), texto);
+}
+function sensivel(dsn) {
+    return { tipo: 'postgres', dsn };
+}
+function isObject(valor) {
+    return typeof valor === 'object' && valor !== null && !Array.isArray(valor);
+}
+function alvoDe(conexao, cwd) {
+    return conexao.tipo === 'sqlite' ? resolve(cwd, conexao.caminho ?? '') : (conexao.dsn ?? '');
+}
+async function testarConexao(ctx, conexao) {
+    let driver;
+    try {
+        driver = await ctx.criarDriver(conexao.tipo, alvoDe(conexao, ctx.cwd));
+        await driver.testar();
+        return null;
+    }
+    catch (erro) {
+        return erro instanceof Error ? erro.message : String(erro);
+    }
+    finally {
+        await driver?.fechar().catch(() => { });
+    }
+}
+function lerArgumentos(argv, flags, comValor = []) {
+    const posicionais = [];
+    const marcadas = new Set();
+    const valores = {};
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i] ?? '';
+        if (!token.startsWith('-'))
+            posicionais.push(token);
+        else if (comValor.includes(token)) {
+            const valor = argv[++i];
+            if (valor === undefined)
+                throw new Error(`${token} exige um valor.`);
+            valores[token] = valor;
+        }
+        else if (flags.includes(token))
+            marcadas.add(token);
+        else {
+            const sugestao = suggestFlag(token, [...flags, ...comValor]);
+            throw new Error(`Flag desconhecida: ${token}.${sugestao ? ` Você quis dizer ${sugestao}?` : ''}`);
+        }
+    }
+    return { posicionais, marcadas, valores };
+}
+function interrompido(valor) {
+    if (p.isCancel(valor))
+        throw new Error('Operação cancelada.');
+    return valor;
+}
+/** Usuário, senha e banco vão com `encodeURIComponent`; porta vazia vira a padrão do tipo. */
+export function montarDsn(dados) {
+    const usuario = encodeURIComponent(dados.usuario.trim());
+    const credencial = dados.senha ? `${usuario}:${encodeURIComponent(dados.senha)}` : usuario;
+    const porta = dados.porta?.trim() || PORTA_PADRAO[dados.tipo];
+    return `${ESQUEMA[dados.tipo]}://${credencial}@${dados.host.trim()}:${porta}/${encodeURIComponent(dados.banco.trim())}`;
+}
+async function perguntarConexao() {
+    const tipo = interrompido(await p.select({
+        message: 'Tipo do banco',
+        options: TIPOS_BANCO.map((valor) => ({ value: valor, label: valor })),
+    }));
+    const obrigatorio = (valor) => (valor?.trim() ? undefined : 'Obrigatório');
+    if (tipo === 'sqlite') {
+        const caminho = interrompido(await p.text({ message: 'Caminho do arquivo SQLite', validate: obrigatorio }));
+        const producao = interrompido(await p.confirm({ message: 'É banco de produção?', initialValue: false }));
+        return { tipo, caminho: caminho.trim(), ...(producao ? { producao } : {}) };
+    }
+    const host = interrompido(await p.text({ message: 'Host', initialValue: 'localhost', validate: obrigatorio }));
+    const porta = interrompido(await p.text({ message: 'Porta', initialValue: PORTA_PADRAO[tipo] }));
+    const banco = interrompido(await p.text({ message: 'Banco', validate: obrigatorio }));
+    const usuario = interrompido(await p.text({ message: 'Usuário', validate: obrigatorio }));
+    const senha = interrompido(await p.password({ message: 'Senha' }));
+    const producao = interrompido(await p.confirm({ message: 'É banco de produção?', initialValue: false }));
+    const dsn = montarDsn({ tipo, host, porta, banco, usuario, senha });
+    return { tipo, dsn, ...(producao ? { producao } : {}) };
+}
+function conexaoDoDsn(dsn, cwd, producao) {
+    const interpretada = interpretarDsn(dsn, cwd);
+    const conexao = { tipo: interpretada.tipo };
+    if (interpretada.tipo === 'sqlite') {
+        const texto = dsn.trim();
+        conexao.caminho = /^(sqlite|file):/i.test(texto) ? texto.replace(/^(sqlite|file):/i, '').replace(/^\/\/(?=\/)/, '') : texto;
+    }
+    else if (interpretada.dsn)
+        conexao.dsn = interpretada.dsn;
+    if (producao)
+        conexao.producao = true;
+    return conexao;
+}
+async function adicionar(ctx, argv) {
+    const { posicionais, marcadas, valores } = lerArgumentos(argv, ['--producao', '--sem-testar', '--substituir', '--projeto'], ['--dsn', '--env']);
+    const [nome, ...sobra] = posicionais;
+    if (!nome || sobra.length > 0)
+        throw new Error('Uso: ai-harness banco-dados adicionar <nome> [--projeto [--env <VAR>]] [--dsn <dsn>] [--producao] [--sem-testar] [--substituir]');
+    if (marcadas.has('--projeto'))
+        return adicionarNoProjeto(ctx, nome, marcadas, valores);
+    if (valores['--env'] !== undefined)
+        throw new Error('--env só vale com --projeto.');
+    const substituir = marcadas.has('--substituir');
+    if (!substituir && nome in lerCadastro(ctx.cadastro).conexoes) {
+        ctx.erro(`A conexão ${nome} já existe em ${ctx.cadastro}. Use --substituir para trocá-la.`);
+        return 1;
+    }
+    const dsn = valores['--dsn'];
+    const conexao = dsn === undefined ? await perguntarConexao() : conexaoDoDsn(dsn, ctx.cwd, marcadas.has('--producao'));
+    ctx.sensiveis.push(conexao);
+    if (!marcadas.has('--sem-testar')) {
+        const falha = await testarConexao(ctx, conexao);
+        if (falha !== null) {
+            ctx.erro(`Falha ao conectar em ${nome} (${resumirConexao(conexao)}): ${falha}`);
+            ctx.erro('Nada foi gravado. Confira os dados ou use --sem-testar para gravar mesmo assim.');
+            return 1;
+        }
+    }
+    salvarConexao(nome, conexao, { substituir, caminho: ctx.cadastro });
+    ctx.log(`Conexão ${nome} gravada em ${ctx.cadastro}: ${resumirConexao(conexao)}${conexao.producao ? ' (produção)' : ''}.`);
+    ctx.log(`No projeto, rode: npx @fontdata/ai-harness banco-dados usar ${nome}`);
+    return 0;
+}
+/** Procura o nome no JSON bruto de banco_dados.conexoes; recusa lista inválida antes de qualquer gravação. */
+function entradaDeclarada(cwd, nome) {
+    validarConfigParaEscrita(cwd);
+    const arquivo = join(cwd, CONFIG_PATH);
+    if (!existsSync(arquivo))
+        return { forma: 'ausente' };
+    const dados = JSON.parse(readFileSync(arquivo, 'utf8'));
+    const banco = isObject(dados) ? secaoBanco(dados) : {};
+    if (banco.conexoes === undefined)
+        return { forma: 'ausente' };
+    if (!Array.isArray(banco.conexoes))
+        throw new Error(`banco_dados.conexoes em ${CONFIG_PATH} não é uma lista; corrija-o antes de gravar a conexão ${nome}.`);
+    const achada = banco.conexoes.some((entrada) => (isObject(entrada) ? entrada.nome : entrada) === nome);
+    if (!achada)
+        return { forma: 'ausente' };
+    const conexao = readConfig(cwd).config.banco_dados.projeto[nome];
+    return conexao ? { forma: 'objeto', conexao } : { forma: 'outra' };
+}
+function variavelPadrao(nome) {
+    return `${nome.toUpperCase().replace(/-/g, '_')}_DATABASE_URL`;
+}
+async function adicionarNoProjeto(ctx, nome, marcadas, valores) {
+    const substituir = marcadas.has('--substituir');
+    if (!REGRA_NOME_CONEXAO.test(nome)) {
+        ctx.erro(`Nome de conexão inválido: ${JSON.stringify(nome)}; use só minúsculas, dígitos, - e _, começando por minúscula ou dígito.`);
+        return 1;
+    }
+    const pedida = valores['--env'];
+    if (pedida !== undefined && !REGRA_DSN_ENV.test(pedida)) {
+        ctx.erro(`--env inválido: ${JSON.stringify(pedida)}; use letras, dígitos e _, sem começar por dígito.`);
+        return 1;
+    }
+    validarSettingsLocal(ctx.cwd);
+    const declarada = entradaDeclarada(ctx.cwd, nome);
+    let variavel = pedida ?? variavelPadrao(nome);
+    if (declarada.forma === 'outra' && !substituir) {
+        ctx.erro(`A conexão ${nome} já está em banco_dados.conexoes de ${CONFIG_PATH} sem dsn_env. Use --substituir para trocá-la pela conexão do projeto.`);
+        return 1;
+    }
+    if (declarada.forma === 'objeto') {
+        const atual = declarada.conexao;
+        if (pedida !== undefined && pedida !== atual.dsn_env) {
+            ctx.erro(`A conexão ${nome} já está declarada em ${CONFIG_PATH} com dsn_env ${atual.dsn_env}; rode sem --env ou com --env ${atual.dsn_env}.`);
+            return 1;
+        }
+        variavel = atual.dsn_env;
+    }
+    let valor;
+    let tipoEscolhido;
+    let producao = marcadas.has('--producao');
+    if (valores['--dsn'] === undefined) {
+        const perguntada = await perguntarConexao();
+        valor = perguntada.tipo === 'sqlite' ? `sqlite:${perguntada.caminho ?? ''}` : (perguntada.dsn ?? '');
+        tipoEscolhido = perguntada.tipo;
+        producao ||= perguntada.producao === true;
+    }
+    else
+        valor = valores['--dsn'].trim();
+    ctx.sensiveis.push(sensivel(valor));
+    const promover = declarada.forma === 'objeto' && producao && !declarada.conexao.producao;
+    if (promover && !substituir) {
+        ctx.erro(`A conexão ${nome} está declarada em ${CONFIG_PATH} sem produção. Use --substituir junto com --producao para marcá-la como produção.`);
+        return 1;
+    }
+    const alvo = interpretarDsn(valor, ctx.cwd);
+    if (declarada.forma === 'objeto' && declarada.conexao.tipo !== undefined && declarada.conexao.tipo !== alvo.tipo) {
+        ctx.erro(`O DSN informado é do tipo ${alvo.tipo}, mas a conexão ${nome} declara tipo ${declarada.conexao.tipo} em ${CONFIG_PATH}. Nada foi gravado.`);
+        return 1;
+    }
+    const anterior = lerEnvSettingsLocal(ctx.cwd)[variavel];
+    if (anterior !== undefined)
+        ctx.sensiveis.push(sensivel(anterior));
+    if (anterior !== undefined && anterior !== valor && !substituir) {
+        ctx.erro(`A variável ${variavel} já está definida em ${SETTINGS_LOCAL_PATH} com outro valor. Use --substituir para trocá-la.`);
+        return 1;
+    }
+    if (!marcadas.has('--sem-testar')) {
+        const falha = await testarConexao(ctx, alvo);
+        if (falha !== null) {
+            ctx.erro(`Falha ao conectar em ${nome} (${resumirConexao(conexaoDoDsn(valor, ctx.cwd, false))}): ${falha}`);
+            ctx.erro('Nada foi gravado. Confira os dados ou use --sem-testar para gravar mesmo assim.');
+            return 1;
+        }
+    }
+    const { changed } = gravarVariavelSettingsLocal(ctx.cwd, variavel, valor);
+    ctx.log(changed ? `Variável ${variavel} gravada em ${SETTINGS_LOCAL_PATH}.` : `Variável ${variavel} já estava com esse valor em ${SETTINGS_LOCAL_PATH}.`);
+    if (declarada.forma === 'objeto' && !promover) {
+        ctx.log(`Conexão ${nome} já declarada em banco_dados.conexoes de ${CONFIG_PATH}; a entrada não foi alterada.`);
+        return 0;
+    }
+    const entrada = declarada.forma === 'objeto'
+        ? { ...declarada.conexao, producao: true }
+        : {
+            nome,
+            dsn_env: variavel,
+            ...(tipoEscolhido === undefined ? {} : { tipo: tipoEscolhido }),
+            ...(producao ? { producao: true } : {}),
+        };
+    gravarConexaoProjeto(ctx.cwd, entrada, { substituir: declarada.forma !== 'ausente' });
+    ctx.log(`Conexão ${nome} gravada em banco_dados.conexoes de ${CONFIG_PATH} (dsn_env ${variavel})${entrada.producao ? ', produção' : ''}.`);
+    if (declarada.forma === 'ausente')
+        ctx.log(`Versione o ${CONFIG_PATH}; cada colega define ${variavel} no próprio ambiente.`);
+    return 0;
+}
+function listar(ctx, argv) {
+    lerArgumentos(argv, []);
+    const { conexoes, problemas } = lerCadastro(ctx.cadastro);
+    for (const problema of problemas)
+        ctx.erro(problema);
+    const { config } = readConfig(ctx.cwd);
+    const doProjeto = config.banco_dados.conexoes.flatMap((nome) => config.banco_dados.projeto[nome] ?? []);
+    const nomes = Object.keys(conexoes).sort();
+    if (nomes.length === 0 && doProjeto.length === 0) {
+        ctx.log(`Nenhuma conexão cadastrada em ${ctx.cadastro}. Cadastre com: npx @fontdata/ai-harness banco-dados adicionar <nome>`);
+        return 0;
+    }
+    for (const nome of nomes) {
+        const conexao = conexoes[nome];
+        ctx.log(`${nome}  ${conexao.tipo}  ${resumirConexao(conexao)}  ${conexao.producao ? 'produção' : 'não produção'}`);
+    }
+    if (doProjeto.length > 0)
+        ctx.log(`Conexões do projeto em ${CONFIG_PATH}:`);
+    for (const declarada of doProjeto) {
+        const lida = lerVariavel(declarada.dsn_env, ctx.cwd);
+        let tipo = declarada.tipo ?? '?';
+        if (lida) {
+            ctx.sensiveis.push(sensivel(lida.valor));
+            if (declarada.tipo === undefined) {
+                try {
+                    tipo = interpretarDsn(lida.valor, ctx.cwd).tipo;
+                }
+                catch {
+                    tipo = 'DSN inválido';
+                }
+            }
+        }
+        const fonte = lida ? `(${lida.fonte})` : 'ausente';
+        ctx.log(`${declarada.nome}  ${tipo}  ${declarada.dsn_env} ${fonte}  ${declarada.producao ? 'produção' : 'não produção'}`);
+    }
+    return 0;
+}
+async function testar(ctx, argv) {
+    const { posicionais } = lerArgumentos(argv, []);
+    if (posicionais.length > 1)
+        throw new Error('Uso: ai-harness banco-dados testar [nome]');
+    const [nome] = posicionais;
+    const cadastro = lerCadastro(ctx.cadastro);
+    const doProjeto = nome !== undefined && nome in readConfig(ctx.cwd).config.banco_dados.projeto;
+    let alvos;
+    let ok = true;
+    if (nome !== undefined && !doProjeto) {
+        const conexao = cadastro.conexoes[nome];
+        if (!conexao) {
+            ctx.erro(`Conexão ${nome} não encontrada em ${ctx.cadastro}; rode banco-dados adicionar ${nome}.`);
+            return 1;
+        }
+        alvos = [{ nome, ...conexao }];
+    }
+    else {
+        const resolvidas = resolverConexoes(ctx.cwd, { cadastro });
+        const pedida = (item) => nome === undefined || item.nome === nome;
+        ctx.sensiveis.push(...resolvidas.segredos.map(sensivel));
+        if (nome === undefined)
+            for (const problema of resolvidas.problemas)
+                ctx.erro(problema);
+        for (const faltando of resolvidas.faltando.filter((item) => nome === undefined || item === nome)) {
+            ctx.erro(`Conexão ${faltando} não encontrada nesta máquina; rode banco-dados adicionar ${faltando}.`);
+            ok = false;
+        }
+        for (const ausente of resolvidas.variaveisAusentes.filter(pedida)) {
+            ctx.erro(`A variável ${ausente.variavel} da conexão ${ausente.nome} não está definida; defina-a no ${SETTINGS_LOCAL_PATH}, no .env ou no ambiente.`);
+            ok = false;
+        }
+        for (const descartada of resolvidas.descartadas.filter(pedida)) {
+            if (nome !== undefined)
+                ctx.erro(`Conexão ${descartada.nome} descartada: ${descartada.motivo}.`);
+            ok = false;
+        }
+        alvos = resolvidas.conexoes.filter(pedida);
+        if (alvos.length === 0 && ok) {
+            ctx.erro('Nenhuma conexão de banco configurada neste projeto; rode npx @fontdata/ai-harness banco-dados usar <nome>.');
+            return 1;
+        }
+    }
+    for (const alvo of alvos) {
+        ctx.sensiveis.push(alvo);
+        const falha = await testarConexao(ctx, alvo);
+        if (falha === null)
+            ctx.log(`ok     ${alvo.nome}  ${resumirConexao(alvo)}`);
+        else {
+            ok = false;
+            ctx.erro(`falhou ${alvo.nome}  ${resumirConexao(alvo)}: ${falha}`);
+        }
+    }
+    return ok ? 0 : 1;
+}
+function usar(ctx, argv) {
+    const { posicionais: nomes } = lerArgumentos(argv, []);
+    if (nomes.length === 0)
+        throw new Error('Uso: ai-harness banco-dados usar <nome...>');
+    writeDefaultConfig(ctx.cwd);
+    const arquivo = join(ctx.cwd, CONFIG_PATH);
+    let dados;
+    try {
+        dados = JSON.parse(readFileSync(arquivo, 'utf8'));
+    }
+    catch (erro) {
+        throw new Error(`${CONFIG_PATH} está com JSON inválido (${erro.message}); corrija antes de rodar banco-dados usar.`);
+    }
+    if (!isObject(dados))
+        throw new Error(`${CONFIG_PATH} precisa ser um objeto JSON; corrija antes de rodar banco-dados usar.`);
+    const banco = secaoBanco(dados);
+    const objetos = new Map();
+    for (const entrada of Array.isArray(banco.conexoes) ? banco.conexoes : []) {
+        if (isObject(entrada) && typeof entrada.nome === 'string' && !objetos.has(entrada.nome))
+            objetos.set(entrada.nome, entrada);
+    }
+    const unicos = [...new Set(nomes)];
+    const proximas = unicos.map((nome) => objetos.get(nome) ?? nome);
+    writeFileSync(arquivo, `${JSON.stringify(comSecaoBanco(dados, { ...banco, conexoes: proximas }), null, 2)}\n`);
+    ctx.log(`banco_dados.conexoes em ${CONFIG_PATH}: ${unicos.join(', ')}.`);
+    const { conexoes } = lerCadastro(ctx.cadastro);
+    const ausentes = unicos.filter((nome) => !(nome in conexoes) && !objetos.has(nome));
+    if (ausentes.length > 0) {
+        ctx.erro(`Aviso: sem cadastro nesta máquina para ${ausentes.join(', ')}; rode banco-dados adicionar <nome> para cada uma.`);
+    }
+    return 0;
+}
+function remover(ctx, argv) {
+    const { posicionais } = lerArgumentos(argv, []);
+    const [nome, ...sobra] = posicionais;
+    if (!nome || sobra.length > 0)
+        throw new Error('Uso: ai-harness banco-dados remover <nome>');
+    if (!removerConexao(nome, ctx.cadastro)) {
+        ctx.erro(`Conexão ${nome} não existe em ${ctx.cadastro}.`);
+        return 1;
+    }
+    ctx.log(`Conexão ${nome} removida de ${ctx.cadastro}.`);
+    return 0;
+}
+/** `ai-harness banco-dados <subcomando>`: cadastro de conexões da máquina e escolha das conexões do projeto. */
+export async function runBancoCommand(argv, opcoes = {}) {
+    const saida = opcoes.saida ?? { log: (texto) => console.log(texto), erro: (texto) => console.error(texto) };
+    const cadastro = opcoes.caminhoCadastro ?? caminhoCadastro();
+    const cwd = opcoes.cwd ?? process.cwd();
+    const lido = lerCadastro(cadastro);
+    const ctx = {
+        cwd,
+        cadastro,
+        criarDriver: opcoes.criarDriver ?? criarDriverPadrao,
+        log: (texto) => saida.log(mascarar(ctx, texto)),
+        erro: (texto) => saida.erro(mascarar(ctx, texto)),
+        sensiveis: [...Object.values(lido.conexoes), ...resolverConexoes(cwd, { cadastro: lido }).segredos.map(sensivel)],
+    };
+    const [subcomando, ...resto] = argv;
+    try {
+        switch (subcomando) {
+            case 'adicionar':
+                return await adicionar(ctx, resto);
+            case 'listar':
+                return listar(ctx, resto);
+            case 'testar':
+                return await testar(ctx, resto);
+            case 'usar':
+                return usar(ctx, resto);
+            case 'remover':
+                return remover(ctx, resto);
+            case '--help':
+            case '-h':
+                ctx.log(AJUDA);
+                return 0;
+            default:
+                if (subcomando !== undefined)
+                    ctx.erro(`Subcomando desconhecido: banco-dados ${subcomando}`);
+                ctx.erro(AJUDA);
+                return 1;
+        }
+    }
+    catch (erro) {
+        ctx.erro(erro instanceof Error ? erro.message : String(erro));
+        return 1;
+    }
+}

package/dist/banco-dados/conexao.js

@@ -0,0 +1,127 @@
+import { resolve } from 'node:path';
+import { readConfig } from '../config/config.js';
+import { lerVariavel, lerVariavelDotEnv } from './ambiente.js';
+import { lerCadastro } from './cadastro.js';
+const EXTENSAO_SQLITE = /\.(db|sqlite|sqlite3)$/i;
+export function raizDoProjeto(env = process.env, cwd = process.cwd()) {
+    return env.CLAUDE_PROJECT_DIR || cwd;
+}
+/** Descobre o tipo pelo esquema do DSN; o erro cita só o esquema, nunca o DSN inteiro. */
+export function interpretarDsn(dsn, raiz) {
+    const texto = dsn.trim();
+    if (/^postgres(ql)?:\/\//i.test(texto))
+        return { tipo: 'postgres', dsn: texto };
+    if (/^(mysql|mariadb):\/\//i.test(texto))
+        return { tipo: 'mariadb', dsn: texto };
+    const semEsquema = /^(sqlite|file):/i.test(texto) ? texto.replace(/^(sqlite|file):/i, '').replace(/^\/\/(?=\/)/, '') : undefined;
+    if (semEsquema !== undefined || EXTENSAO_SQLITE.test(texto)) {
+        const caminho = semEsquema ?? texto;
+        if (!caminho)
+            throw new Error('DSN sqlite sem caminho do arquivo');
+        return { tipo: 'sqlite', caminho: resolve(raiz, caminho) };
+    }
+    const esquema = /^([a-z][a-z0-9+.-]*):/i.exec(texto)?.[1];
+    const descricao = esquema ? `esquema "${esquema}:" não reconhecido` : 'DSN não reconhecido';
+    throw new Error(`${descricao}; use postgres://, postgresql://, mysql://, mariadb://, sqlite: ou um arquivo .db/.sqlite/.sqlite3`);
+}
+export function lerDatabaseUrl(raiz) {
+    return lerVariavelDotEnv(raiz, 'DATABASE_URL');
+}
+function daConexaoCadastrada(nome, conexao, raiz) {
+    const resolvida = {
+        nome,
+        tipo: conexao.tipo,
+        producao: conexao.producao === true,
+        mascaramento: conexao.mascaramento !== false,
+        origem: 'cadastro',
+    };
+    if (conexao.tipo === 'sqlite')
+        resolvida.caminho = resolve(raiz, conexao.caminho ?? '');
+    else if (conexao.dsn)
+        resolvida.dsn = conexao.dsn;
+    return resolvida;
+}
+function resolverDoProjeto(declarada, raiz, env, saida) {
+    const { nome, dsn_env: variavel } = declarada;
+    const lida = lerVariavel(variavel, raiz, env);
+    if (!lida) {
+        saida.variaveisAusentes.push({ nome, variavel });
+        return;
+    }
+    saida.segredos.push(lida.valor);
+    let motivo;
+    try {
+        const interpretado = interpretarDsn(lida.valor, raiz);
+        if (declarada.tipo === undefined || declarada.tipo === interpretado.tipo) {
+            saida.conexoes.push({
+                nome,
+                producao: declarada.producao,
+                mascaramento: true,
+                ...interpretado,
+                origem: 'projeto',
+                variavel,
+                fonte: lida.fonte,
+            });
+            return;
+        }
+        motivo = `o DSN da variável ${variavel} é do tipo ${interpretado.tipo}, mas a conexão declara tipo ${declarada.tipo}`;
+    }
+    catch (erro) {
+        motivo = `o DSN da variável ${variavel} é inválido: ${erro.message}`;
+    }
+    saida.descartadas.push({ nome, motivo });
+    saida.problemas.push(`Conexão ${nome} descartada: ${motivo}.`);
+}
+/** Percorre banco_dados.conexoes na ordem; sem a lista declarada no projeto, vale o DATABASE_URL do .env como a conexão `env`. */
+export function resolverConexoes(raiz, opcoes = {}) {
+    const { config, problems } = readConfig(raiz);
+    const saida = {
+        conexoes: [],
+        faltando: [],
+        variaveisAusentes: [],
+        descartadas: [],
+        problemas: [...problems],
+        segredos: [],
+    };
+    const { conexoes: nomes, projeto, declarado } = config.banco_dados;
+    if (!declarado) {
+        const url = lerDatabaseUrl(raiz);
+        if (url) {
+            saida.segredos.push(url);
+            try {
+                saida.conexoes.push({ nome: 'env', producao: false, mascaramento: true, ...interpretarDsn(url, raiz), origem: 'env' });
+            }
+            catch (erro) {
+                saida.problemas.push(`DATABASE_URL do .env ignorado: ${erro.message}`);
+            }
+        }
+        return saida;
+    }
+    let cadastro;
+    for (const nome of nomes) {
+        const declarada = projeto[nome];
+        if (declarada) {
+            resolverDoProjeto(declarada, raiz, opcoes.env ?? process.env, saida);
+            continue;
+        }
+        if (!cadastro) {
+            cadastro = opcoes.cadastro ?? lerCadastro();
+            saida.problemas.push(...cadastro.problemas);
+        }
+        const conexao = cadastro.conexoes[nome];
+        if (conexao)
+            saida.conexoes.push(daConexaoCadastrada(nome, conexao, raiz));
+        else
+            saida.faltando.push(nome);
+    }
+    return saida;
+}
+export function escolherConexao(resolvidas, nome) {
+    if (resolvidas.length === 0) {
+        throw new Error('Nenhuma conexão de banco configurada neste projeto; rode npx @fontdata/ai-harness banco-dados usar <nome>');
+    }
+    const escolhida = nome === undefined ? resolvidas[0] : resolvidas.find((conexao) => conexao.nome === nome);
+    if (!escolhida)
+        throw new Error(`Conexão ${nome} não está em banco_dados.conexoes deste projeto`);
+    return escolhida;
+}

package/dist/banco-dados/drivers/index.js

@@ -0,0 +1,13 @@
+/** `alvo` é o DSN no Postgres e no MariaDB e o caminho do arquivo no SQLite. */
+export async function criarDriver(tipo, alvo) {
+    switch (tipo) {
+        case 'postgres':
+            return (await import('./postgres.js')).criarDriverPostgres(alvo);
+        case 'mariadb':
+            return (await import('./mariadb.js')).criarDriverMariadb(alvo);
+        case 'sqlite':
+            return (await import('./sqlite.js')).criarDriverSqlite(alvo);
+        default:
+            throw new Error(`Tipo de banco desconhecido: ${String(tipo)}`);
+    }
+}