@fontdata/ai-harness 2.5.1 → 2.7.0

package/dist/init.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { EOL } from 'node:os';
+import { EOL, homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import * as p from '@clack/prompts';
 import { allCommands, loadCatalog, recommendedCommands } from './catalog.js';
@@ -11,6 +11,17 @@ import { describePlan, executePlan, packageInfo, planInstall, resolveInstallOpti
 import { detectProjectKind } from './install/selection.js';
 export { detectProjectKind, neededSkillsFor, resolveSelection } from './install/selection.js';
 const PLUGIN_HOOKS_NOTE = 'O plugin fontdata@ai-harness está habilitado: os hooks já rodam por ele e não foram instalados no projeto, para não rodarem duas vezes.';
+const PLUGIN_MCP_NOTE = 'O plugin fontdata@ai-harness está habilitado: o servidor MCP de banco já roda por ele e não foi registrado no .mcp.json, para não duplicar.';
+/** Registra o MCP de banco no .mcp.json quando não foi recusado (flag, wizard ou config) e o plugin não o fornece. */
+export function decidirRegistroMcp(options, root, home = homedir()) {
+    return options.mcpBanco && readConfig(root).config.banco.registrar_mcp && !isHarnessPluginEnabled(root, home);
+}
+function applyMcpDecision(plan, options, root) {
+    plan.registerMcp = decidirRegistroMcp(options, root);
+    plan.mcpRecusado = !options.mcpBanco;
+    if (!plan.registerMcp && options.mcpBanco)
+        plan.mcpSkipReason = isHarnessPluginEnabled(root) ? 'plugin' : 'config';
+}
 /** Encerra o fluxo com mensagem amigável quando o usuário cancela (Ctrl+C). */
 function bail(value) {
     if (p.isCancel(value)) {
@@ -97,6 +108,7 @@ function runNonInteractive(args) {
     if (skippedForPlugin)
         options.hooks = false;
     const plan = planInstall(catalog, repoPath, options);
+    applyMcpDecision(plan, options, repoPath);
     const summary = [describePlan(plan), ...(skippedForPlugin ? [PLUGIN_HOOKS_NOTE] : [])].join(EOL + EOL);
     if (!args.yes) {
         console.log(`Simulação — nada foi gravado em ${repoPath}.\n\n${summary}\n\nRode de novo com --yes para aplicar.`);
@@ -184,6 +196,16 @@ async function runWizard(args) {
             initialValue: true,
         }));
     }
+    let mcpBanco = true;
+    if (isHarnessPluginEnabled(repoPath)) {
+        p.note(PLUGIN_MCP_NOTE, 'Banco');
+    }
+    else {
+        mcpBanco = bail(await p.confirm({
+            message: 'Registrar o servidor MCP de banco (somente leitura) no .mcp.json?',
+            initialValue: true,
+        }));
+    }
     const agents = bail(await p.confirm({
         message: 'Instalar os agents somente leitura do harness (revisor-testes, qa, investigador, auditor-plano)?',
         initialValue: true,
@@ -201,6 +223,7 @@ async function runWizard(args) {
         hooks,
         agents,
         comments,
+        mcpBanco,
     };
     let plan = planInstall(catalog, repoPath, options);
     // 6. Confirmação final
@@ -221,6 +244,7 @@ async function runWizard(args) {
         if (conflict === 'skip')
             plan = planInstall(catalog, repoPath, { ...options, conflict });
     }
+    applyMcpDecision(plan, options, repoPath);
     // Execução
     const s = p.spinner();
     s.start('Instalando...');

package/dist/install/flags.js

@@ -7,7 +7,7 @@ const CLAUDE_MD = {
 };
 const CONFLICTS = { sobrescrever: 'overwrite', pular: 'skip' };
 const VALUE_FLAGS = ['--escopo', '--comandos', '--claude-md', '--conflito'];
-const BOOLEAN_FLAGS = ['--sem-harness', '--sem-hooks', '--sem-agents', '--sem-comentarios', '--yes', '-y', '--sim'];
+const BOOLEAN_FLAGS = ['--sem-harness', '--sem-hooks', '--sem-agents', '--sem-comentarios', '--sem-banco', '--yes', '-y', '--sim'];
 function pick(flag, value, options) {
     const chosen = options[value];
     if (chosen === undefined) {
@@ -48,6 +48,7 @@ export function parseInitArgs(argv) {
         hooks: undefined,
         agents: undefined,
         comments: undefined,
+        mcpBanco: undefined,
         yes: false,
         hasSelectionFlags: false,
     };
@@ -68,6 +69,8 @@ export function parseInitArgs(argv) {
                 args.agents = false;
             else if (token === '--sem-comentarios')
                 args.comments = false;
+            else if (token === '--sem-banco')
+                args.mcpBanco = false;
             else
                 args.yes = true;
             continue;

package/dist/install/mcp.js

@@ -0,0 +1,66 @@
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { timestamp } from './settings.js';
+export const MCP_PATH = '.mcp.json';
+const PIN_PREFIX = '@fontdata/ai-harness@';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Servidor MCP de banco com a versão do pacote fixada no npx, no mesmo formato do plugin. */
+export function bancoMcpServer(versao) {
+    return { command: 'npx', args: ['-y', `${PIN_PREFIX}${versao}`, 'banco-mcp'] };
+}
+function pinOf(entrada) {
+    if (!isPlainObject(entrada) || !Array.isArray(entrada.args))
+        return undefined;
+    return entrada.args.find((arg) => typeof arg === 'string' && arg.includes(PIN_PREFIX));
+}
+/** Entrada gravada pelo harness: os args fixam `@fontdata/ai-harness@<versão>`. */
+export function ehEntradaGerenciada(entrada) {
+    return pinOf(entrada) !== undefined;
+}
+/**
+ * Acrescenta os servidores ausentes em `mcpServers` do `.mcp.json`, preservando o resto. Com
+ * `atualizarGerenciada`, regrava também a entrada gerenciada que fixa outra versão; entrada
+ * personalizada nunca é tocada. Backup datado só quando muda; JSON inválido é recusado sem tocar.
+ */
+export function mergeMcpServers(root, servidores, now = new Date(), { atualizarGerenciada = false } = {}) {
+    const file = join(root, MCP_PATH);
+    const original = existsSync(file) ? readFileSync(file, 'utf8') : null;
+    let config = {};
+    if (original !== null) {
+        let parsed;
+        try {
+            parsed = JSON.parse(original);
+        }
+        catch {
+            parsed = undefined;
+        }
+        if (!isPlainObject(parsed) || (parsed.mcpServers !== undefined && !isPlainObject(parsed.mcpServers))) {
+            throw new Error(`O ${MCP_PATH} está com JSON inválido; corrija-o antes de registrar o servidor MCP de banco.`);
+        }
+        config = parsed;
+    }
+    const mcpServers = { ...(config.mcpServers ?? {}) };
+    let changed = false;
+    for (const [nome, servidor] of Object.entries(servidores)) {
+        const atual = mcpServers[nome];
+        if (atual === undefined) {
+            mcpServers[nome] = servidor;
+            changed = true;
+        }
+        else if (atualizarGerenciada && ehEntradaGerenciada(atual) && pinOf(atual) !== pinOf(servidor)) {
+            mcpServers[nome] = { ...atual, command: servidor.command, args: servidor.args };
+            changed = true;
+        }
+    }
+    if (!changed)
+        return { changed: false, backup: null };
+    let backup = null;
+    if (original !== null) {
+        backup = `${MCP_PATH}.bak-${timestamp(now)}`;
+        copyFileSync(file, join(root, backup));
+    }
+    writeFileSync(file, `${JSON.stringify({ ...config, mcpServers }, null, 2)}\n`);
+    return { changed: true, backup };
+}

package/dist/install/plan.js

@@ -6,6 +6,8 @@ import { applyAtomically } from './atomic.js';
 import { buildLockItem, LOCK_VERSION, readLock, writeLock } from './lock.js';
 import { HOOKS_ITEM_ID, PROJECT_HOOKS_DIR, projectHooksConfig } from './hooks.js';
 import { neededSkillsFor, resolveSelection } from './selection.js';
+import { bancoMcpServer, MCP_PATH, mergeMcpServers } from './mcp.js';
+import { gravarRegistrarMcp } from '../config/config.js';
 import { COMMENTS_RULE_PATH, commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
 import { combineHooks, HARNESS_DENY, HARNESS_PERMISSIONS, mergeSettings } from './settings.js';
 /** Rule de convenção com o que é específico do projeto (D-38): é do projeto, então fica fora do lock. */
@@ -27,6 +29,7 @@ export function resolveInstallOptions(args) {
         hooks: args.hooks ?? true,
         agents: args.agents ?? true,
         comments: args.comments ?? true,
+        mcpBanco: args.mcpBanco ?? true,
     };
 }
 export function packageInfo() {
@@ -166,6 +169,10 @@ export function executePlan(root, plan, pkg, now = new Date()) {
     }
     if (plan.registerComments)
         ensureCommentsBaseline(root);
+    if (plan.registerMcp)
+        mergeMcpServers(root, { banco: bancoMcpServer(pkg.versao) }, now);
+    if (plan.mcpRecusado)
+        gravarRegistrarMcp(root, false);
     const items = new Map();
     for (const item of previous?.itens ?? [])
         items.set(`${item.tipo}:${item.id}`, item);
@@ -206,6 +213,18 @@ export function describePlan(plan) {
             'o /git-commit-push, os sub-agents e as consultas de leitura não pedirem aprovação (inclusive no modo auto); ' +
             'o push forçado fica bloqueado em permissions.deny.');
     }
+    if (plan.registerMcp) {
+        lines.push(`Servidor MCP de banco (somente leitura) registrado em ${MCP_PATH}, sem duplicar os servidores existentes.`);
+    }
+    else if (plan.mcpRecusado) {
+        lines.push(`Servidor MCP de banco não registrado (recusado); a escolha fica em banco.registrar_mcp: false no .ai-harness/config.json.`);
+    }
+    else if (plan.mcpSkipReason === 'plugin') {
+        lines.push(`Servidor MCP de banco não registrado em ${MCP_PATH}: o plugin fontdata@ai-harness já o fornece.`);
+    }
+    else if (plan.mcpSkipReason === 'config') {
+        lines.push(`Servidor MCP de banco não registrado em ${MCP_PATH}: banco.registrar_mcp está false no .ai-harness/config.json.`);
+    }
     if (plan.registerComments) {
         lines.push('Padrão de comentários: rule carregada em toda sessão, hook que bloqueia a violação e catraca do legado (gerada só na primeira instalação).');
     }

package/dist/install/settings.js

@@ -9,6 +9,8 @@ export const CONFLICTS_PERMISSION = 'Bash(npx @fontdata/ai-harness conflitos:*)'
 export const GIT_PERMISSIONS = ['Bash(git add:*)', 'Bash(git commit:*)', 'Bash(git push:*)'];
 /** O /executar-plan e as skills de fluxo delegam a sub-agents a cada task e gate. */
 export const AGENT_PERMISSION = 'Agent';
+/** Leitura e busca de arquivos e a invocação das skills, que todos os fluxos usam o tempo todo. */
+export const TOOL_PERMISSIONS = ['Read', 'Grep', 'Glob', 'Skill'];
 /**
  * Comandos só de leitura que as skills, os comandos e os agents rodam. Ficam de fora os que regravam a instalação
  * (`init`, `update`, `migrar`), os de teste e build, que variam por projeto, e o `npm audit`, cujo prefixo
@@ -31,8 +33,21 @@ export const READ_PERMISSIONS = [
     'Bash(gh pr diff:*)',
     'Bash(npm outdated:*)',
 ];
+/**
+ * Ferramentas de esquema do servidor MCP de banco, registrado pelo `.mcp.json` ou pelo plugin. A `consultar`
+ * fica de fora: lê linhas das tabelas e continua pedindo aprovação.
+ */
+export const BANCO_PERMISSIONS = ['mcp__banco__', 'mcp__plugin_fontdata_banco__'].flatMap((prefixo) => ['listar_conexoes', 'listar_tabelas', 'descrever_tabela', 'consultar'].map((ferramenta) => `${prefixo}${ferramenta}`));
 /** Regras de `permissions.allow` que o init e o update gravam para as skills e os agents do harness. */
-export const HARNESS_PERMISSIONS = [EVENT_PERMISSION, CONFLICTS_PERMISSION, ...GIT_PERMISSIONS, AGENT_PERMISSION, ...READ_PERMISSIONS];
+export const HARNESS_PERMISSIONS = [
+    EVENT_PERMISSION,
+    CONFLICTS_PERMISSION,
+    ...GIT_PERMISSIONS,
+    AGENT_PERMISSION,
+    ...TOOL_PERMISSIONS,
+    ...READ_PERMISSIONS,
+    ...BANCO_PERMISSIONS,
+];
 /** O push liberado não vale para reescrever o histórico remoto: `deny` vence o `allow`. */
 export const HARNESS_DENY = [
     'Bash(git push --force:*)',
@@ -45,7 +60,7 @@ export const HARNESS_DENY = [
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function timestamp(date) {
+export function timestamp(date) {
     const pad = (n) => String(n).padStart(2, '0');
     return (`${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-` +
         `${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`);

package/dist/update/update.js

@@ -2,15 +2,43 @@ import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync
 import { dirname, join, resolve } from 'node:path';
 import { allCommands, loadCatalog } from '../catalog.js';
 import { commentsHooksConfig, ensureCommentsBaseline } from '../comentarios/instalar.js';
-import { readConfig, syncGitignore, writeDefaultConfig } from '../config/config.js';
+import { CONFIG_PATH, gravarRegistrarMcp, readConfig, syncGitignore, writeDefaultConfig } from '../config/config.js';
 import { applyAtomically } from '../install/atomic.js';
 import { suggestFlag } from '../install/flags.js';
 import { HOOKS_ITEM_ID, isHarnessPluginEnabled, projectHooksConfig } from '../install/hooks.js';
+import { bancoMcpServer, ehEntradaGerenciada, MCP_PATH, mergeMcpServers } from '../install/mcp.js';
 import { hashContent, LOCK_PATH, LOCK_VERSION, readLock, writeLock } from '../install/lock.js';
 import { itemSources, packageInfo, PROJECT_RULE_PATH, projectRuleContent } from '../install/plan.js';
 import { neededSkillsFor } from '../install/selection.js';
 import { combineHooks, HARNESS_DENY, HARNESS_PERMISSIONS, hasAllowRule, mergeSettings } from '../install/settings.js';
 import { adoptLegacyInstall } from './legado.js';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Espelha o `mergeMcpServers` com `atualizarGerenciada`; JSON inválido vira `invalido`, e o apply pula o registro. */
+function mcpChange(root, versao) {
+    const file = join(root, MCP_PATH);
+    if (!existsSync(file))
+        return 'ausente';
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return 'invalido';
+    }
+    if (!isPlainObject(parsed))
+        return 'invalido';
+    const servers = parsed.mcpServers === undefined ? {} : parsed.mcpServers;
+    if (!isPlainObject(servers))
+        return 'invalido';
+    const atual = servers.banco;
+    if (atual === undefined)
+        return 'faltando';
+    const pin = bancoMcpServer(versao).args.find((arg) => arg.startsWith('@fontdata/'));
+    const args = isPlainObject(atual) && Array.isArray(atual.args) ? atual.args : [];
+    return ehEntradaGerenciada(atual) && !args.includes(pin) ? 'versao' : null;
+}
 /** `<id>-legado.md`, com sufixo numérico quando o nome já está em uso. */
 function legacyPath(root, path) {
     const base = path.replace(/\.md$/, '');
@@ -20,7 +48,7 @@ function legacyPath(root, path) {
             return candidate;
     }
 }
-export function checkUpdate(root, catalog = loadCatalog(), legacy, home) {
+export function checkUpdate(root, catalog = loadCatalog(), legacy, home, { semBanco = false } = {}) {
     const recorded = readLock(root);
     const lock = recorded ?? adoptLegacyInstall(root, legacy);
     if (!lock) {
@@ -112,6 +140,8 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home) {
         ...HARNESS_PERMISSIONS.filter((rule) => !hasAllowRule(root, rule)),
         ...HARNESS_DENY.filter((rule) => !hasAllowRule(root, rule, 'deny')).map((rule) => `deny ${rule}`),
     ];
+    const registrarMcpConfig = readConfig(root).config.banco.registrar_mcp;
+    const registrarMcp = !semBanco && registrarMcpConfig && !isHarnessPluginEnabled(root, home);
     return {
         changes,
         lock,
@@ -121,6 +151,9 @@ export function checkUpdate(root, catalog = loadCatalog(), legacy, home) {
         registrarComentarios: adotada,
         permissaoAusente: permissoesFaltando.length > 0,
         permissoesFaltando,
+        registrarMcp,
+        mudancaMcp: registrarMcp ? mcpChange(root, packageInfo().versao) : null,
+        recusarMcp: semBanco && registrarMcpConfig,
     };
 }
 /**
@@ -172,6 +205,20 @@ export function applyUpdate(root, report, options, pkg, now = new Date()) {
             writeFileSync(projectRule, projectRuleContent(renamed.map(({ para }) => para)));
         }
     }
+    const avisos = [];
+    if (report.registrarMcp && report.mudancaMcp === 'invalido')
+        avisos.push(MCP_INVALIDO);
+    else if (report.registrarMcp) {
+        // Uma falha no .mcp.json nunca deixa o update pela metade, sem lock.
+        try {
+            mergeMcpServers(root, { banco: bancoMcpServer(pkg.versao) }, now, { atualizarGerenciada: true });
+        }
+        catch (error) {
+            avisos.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (report.recusarMcp)
+        gravarRegistrarMcp(root, false);
     const itemOf = new Map(report.changes.map((change) => [change.caminho, change.item]));
     const writtenHash = new Map(write.map((file) => [file.path, hashContent(file.content)]));
     const dropped = new Set([...remove, ...report.stale, ...legacy]);
@@ -205,8 +252,14 @@ export function applyUpdate(root, report, options, pkg, now = new Date()) {
         itens.push({ ...added, arquivos: added.arquivos.sort((a, b) => a.caminho.localeCompare(b.caminho)) });
     }
     writeLock(root, { lock_versao: LOCK_VERSION, pacote: pkg, gerado_em: now.toISOString(), itens });
-    return { written: write.map((file) => file.path), removed: remove, kept, renamed };
+    return { written: write.map((file) => file.path), removed: remove, kept, renamed, avisos };
 }
+const MCP_INVALIDO = `O ${MCP_PATH} está com JSON inválido: o registro do MCP de banco foi pulado e o arquivo não foi tocado. Corrija-o e rode o update de novo.`;
+const MCP_DESCRIPTIONS = {
+    ausente: 'não existe',
+    faltando: 'não tem a entrada banco',
+    versao: 'fixa outra versão do servidor banco',
+};
 const DESCRIPTIONS = {
     novo: 'novo no pacote, será gravado',
     alterado: 'mudou no pacote, será atualizado',
@@ -230,20 +283,29 @@ export function describeUpdate(report) {
             `Faltam permissões do harness em .claude/settings.json (${report.permissoesFaltando.join(', ')}); o --yes as acrescenta.`,
         ]
         : [];
+    const mcp = [
+        ...(report.mudancaMcp === 'invalido'
+            ? [`O ${MCP_PATH} está com JSON inválido; o --yes pula o registro do MCP de banco e não toca no arquivo.`]
+            : report.mudancaMcp
+                ? [`O ${MCP_PATH} ${MCP_DESCRIPTIONS[report.mudancaMcp]}; o --yes grava mcpServers.banco na versão ${packageInfo().versao}.`]
+                : []),
+        ...(report.recusarMcp ? [`--sem-banco: o --yes grava banco.registrar_mcp: false em ${CONFIG_PATH} e não registra o MCP.`] : []),
+    ];
     if (!report.changes.length) {
-        const status = adopted.length || permission.length ? 'Nenhum arquivo a atualizar.' : 'A instalação está em dia: nenhum arquivo a atualizar.';
-        return [...adopted, ...permission, status].join('\n');
+        const status = adopted.length || permission.length || mcp.length ? 'Nenhum arquivo a atualizar.' : 'A instalação está em dia: nenhum arquivo a atualizar.';
+        return [...adopted, ...permission, ...mcp, status].join('\n');
     }
     return [
         ...adopted,
         ...permission,
+        ...mcp,
         `Mudanças em relação ao pacote ${packageInfo().versao} (instalado: ${report.lock.pacote.versao}):`,
         ...report.changes.map((change) => `  ${change.tipo.padEnd(16)} ${change.caminho}${change.destino ? ` → ${change.destino}` : ''}  (${DESCRIPTIONS[change.tipo]})`),
     ].join('\n');
 }
-const UPDATE_FLAGS = ['--check', '--yes', '-y', '--sim', '--forcar'];
+const UPDATE_FLAGS = ['--check', '--yes', '-y', '--sim', '--forcar', '--sem-banco'];
 export function parseUpdateArgs(argv) {
-    const args = { path: undefined, check: false, yes: false, force: false };
+    const args = { path: undefined, check: false, yes: false, force: false, semBanco: false };
     for (const token of argv) {
         if (!token.startsWith('-')) {
             if (args.path !== undefined)
@@ -254,6 +316,8 @@ export function parseUpdateArgs(argv) {
             args.check = true;
         else if (token === '--forcar')
             args.force = true;
+        else if (token === '--sem-banco')
+            args.semBanco = true;
         else if (token === '--yes' || token === '-y' || token === '--sim')
             args.yes = true;
         else {
@@ -263,16 +327,17 @@ export function parseUpdateArgs(argv) {
     }
     return args;
 }
-/** `ai-harness update [caminho] [--check] [--yes] [--forcar]`; sem `--yes` só simula. */
+/** `ai-harness update [caminho] [--check] [--yes] [--forcar] [--sem-banco]`; sem `--yes` só simula. */
 export function runUpdateCommand(argv) {
     const args = parseUpdateArgs(argv);
     const root = resolve(process.cwd(), args.path ?? '.');
     if (!existsSync(root))
         throw new Error(`Pasta não encontrada: ${root}`);
-    const report = checkUpdate(root);
+    const report = checkUpdate(root, undefined, undefined, undefined, { semBanco: args.semBanco });
     console.log(describeUpdate(report));
-    // Sem arquivo a atualizar, a adoção ainda grava o lock, e a permissão ausente ainda é acrescentada.
-    if (args.check || (!report.changes.length && !report.adotada && !report.permissaoAusente))
+    // Sem arquivo a atualizar, a adoção ainda grava o lock, e a permissão e o MCP ainda são acrescentados.
+    const pendente = report.adotada || report.permissaoAusente || report.mudancaMcp !== null || report.recusarMcp;
+    if (args.check || (!report.changes.length && !pendente))
         return 0;
     if (!args.yes) {
         const conflicts = report.changes.some((change) => change.tipo === 'conflito');
@@ -282,6 +347,8 @@ export function runUpdateCommand(argv) {
     const result = applyUpdate(root, report, { force: args.force }, packageInfo());
     console.log(`\nAtualização aplicada: ${result.written.length} gravado(s), ${result.removed.length} apagado(s), ` +
         `${result.renamed.length} renomeado(s), ${result.kept.length} preservado(s).`);
+    for (const aviso of result.avisos)
+        console.log(`Aviso: ${aviso}`);
     if (result.renamed.length) {
         console.log('Comandos personalizados renomeados (leve o que for do projeto para uma rule e apague o arquivo):\n' +
             result.renamed.map(({ de, para }) => `  ${de} → ${para}`).join('\n'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fontdata/ai-harness",
-  "version": "2.5.1",
+  "version": "2.7.0",
   "description": "Harness de engenharia com IA da Fontdata para Claude Code: roda os slash commands direto na pasta do projeto via npx, sem instalar nada — ou instala-os em .claude/commands.",
   "type": "module",
   "bin": {
@@ -43,10 +43,13 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
+    "mysql2": "^3.24.5",
+    "pg": "^8.23.1",
     "yaml": "^2.9.1"
   },
   "devDependencies": {
     "@types/node": "^22.20.2",
+    "@types/pg": "^8.23.1",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"
   }