pokt-cli 1.0.7 → 1.0.9

package/dist/chat/mcp-from-text.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Remove blocos ```bash``` que são só invocações MCP (às vezes `mcp_*` numa linha e JSON na seguinte).
+ */
+export declare function stripExecutedStyleMcpBashBlocks(content: string): string;
+/** Uma linha tipo: mcp_Neon_run_sql "SELECT 1" ou mcp_Neon_list_projects */
+export declare function parseMcpShellLine(line: string): {
+    tool: string;
+    args: string;
+} | null;
+export declare function runMcpFromBashMarkdown(content: string, options?: {
+    skipDuplicateAppendix?: boolean;
+}): Promise<{
+    invocationCount: number;
+    executedCount: number;
+    augmentedAssistantText: string;
+}>;
+/**
+ * Quando o modelo devolve vazio e o pedido parece “listar bancos”, executa mcp_*_run_sql uma vez.
+ */
+export declare function tryAutoMcpForListDatabases(messages: Array<{
+    role: string;
+    content?: unknown;
+}>): Promise<string | null>;

package/dist/chat/mcp-from-text.js

@@ -0,0 +1,364 @@
+/**
+ * Fallback: alguns modelos emitem invocações MCP em blocos ```bash``` em vez de tool_calls.
+ * Extraímos linhas `mcp_* ...` e executamos contra os servidores MCP conectados.
+ */
+import { ui } from '../ui.js';
+import { callMcpTool, getMcpExposedToolNames, getMcpToolParameterKeys } from '../mcp/client.js';
+const BASH_BLOCK_RE = /```(?:bash|sh|shell|zsh|powershell|ps1|cmd)\s*\n([\s\S]*?)```/gi;
+function mcpBashFallbackVerbose() {
+    return process.env.POKT_VERBOSE_MCP === '1' || process.env.POKT_VERBOSE === '1';
+}
+/**
+ * Remove blocos ```bash``` que são só invocações MCP (às vezes `mcp_*` numa linha e JSON na seguinte).
+ */
+export function stripExecutedStyleMcpBashBlocks(content) {
+    const re = new RegExp(BASH_BLOCK_RE.source, BASH_BLOCK_RE.flags);
+    return content.replace(re, (full, body) => {
+        if (!/mcp_[A-Za-z0-9_-]+/i.test(body))
+            return full;
+        const lower = body.toLowerCase();
+        const shellish = /\b(if |then|\bfi\b|\bfor\b|\bdo\b|\bdone\b|\bwhile\b|curl |wget |\bgit\b|\bnpm\b|\bpnpm\b|\bcd |\bexport |\$\{)/.test(lower);
+        if (shellish)
+            return full;
+        const lines = body
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean);
+        if (lines.length === 0)
+            return full;
+        const mcpOrJsonLine = (l) => {
+            if (parseMcpShellLine(l) !== null)
+                return true;
+            const t = l.trim();
+            if (t.startsWith('{') && t.endsWith('}'))
+                return true;
+            if (t.startsWith('[') && t.endsWith(']'))
+                return true;
+            return false;
+        };
+        if (lines.every(mcpOrJsonLine))
+            return '\n';
+        return full;
+    });
+}
+function trunc(s, max) {
+    if (s.length <= max)
+        return s;
+    return `${s.slice(0, max)}\n\n… (${s.length - max} caracteres omitidos)`;
+}
+/** Uma linha tipo: mcp_Neon_run_sql "SELECT 1" ou mcp_Neon_list_projects */
+export function parseMcpShellLine(line) {
+    const m = line.trim().match(/^(mcp_[A-Za-z0-9_-]+)(?:\s+(.*))?$/);
+    if (!m)
+        return null;
+    return { tool: m[1], args: m[2] ?? '' };
+}
+function extractStringArg(raw) {
+    const t = raw.trim();
+    if (!t)
+        return null;
+    if (t.startsWith('"') && t.endsWith('"') && t.length >= 2) {
+        return t.slice(1, -1).replace(/\\"/g, '"');
+    }
+    if (t.startsWith("'") && t.endsWith("'") && t.length >= 2) {
+        return t.slice(1, -1).replace(/\\'/g, "'");
+    }
+    if (/^\s*(SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRUNCATE|SHOW)\b/i.test(t)) {
+        return t;
+    }
+    if (/^[a-zA-Z0-9_.-]+$/.test(t))
+        return t;
+    return t;
+}
+/** neonctl / modelo: --project-id "x" --branch-id "y" --sql "SELECT 1" */
+function neonFlagNameToJsonKey(flagRaw) {
+    const f = flagRaw.toLowerCase();
+    if (f === 'project-id')
+        return 'projectId';
+    if (f === 'branch-id')
+        return 'branchId';
+    if (f === 'database-name' || f === 'database')
+        return 'databaseName';
+    return flagRaw.replace(/-([a-z])/gi, (_, c) => c.toUpperCase());
+}
+function readQuotedSegment(s, pos) {
+    const q = s[pos];
+    if (q !== '"' && q !== "'")
+        return null;
+    let j = pos + 1;
+    let buf = '';
+    while (j < s.length) {
+        if (s[j] === '\\' && j + 1 < s.length) {
+            buf += s[j + 1];
+            j += 2;
+            continue;
+        }
+        if (s[j] === q)
+            return { value: buf, next: j + 1 };
+        buf += s[j];
+        j++;
+    }
+    return { value: buf, next: j };
+}
+/**
+ * Extrai flags estilo CLI a partir de uma string (linha bash ou valor errado em `sql`).
+ */
+function parseNeonCtlStyleFlags(argsRaw) {
+    const s = argsRaw.trim();
+    if (!s || !/--[a-zA-Z]/.test(s))
+        return null;
+    const out = {};
+    let i = 0;
+    while (i < s.length) {
+        while (i < s.length && /\s/.test(s[i]))
+            i++;
+        if (i >= s.length)
+            break;
+        if (!s.startsWith('--', i))
+            break;
+        i += 2;
+        const nameStart = i;
+        while (i < s.length && /[a-zA-Z0-9-]/.test(s[i]))
+            i++;
+        const flagRaw = s.slice(nameStart, i);
+        if (!flagRaw)
+            break;
+        while (i < s.length && /\s/.test(s[i]))
+            i++;
+        let value = '';
+        if (i < s.length && s[i] === '=') {
+            i++;
+            while (i < s.length && /\s/.test(s[i]))
+                i++;
+        }
+        if (i >= s.length) {
+            out[neonFlagNameToJsonKey(flagRaw)] = value;
+            break;
+        }
+        const quoted = readQuotedSegment(s, i);
+        if (quoted) {
+            value = quoted.value;
+            i = quoted.next;
+        }
+        else {
+            const us = i;
+            while (i < s.length) {
+                if (/\s/.test(s[i]))
+                    break;
+                if (s.startsWith('--', i))
+                    break;
+                i++;
+            }
+            value = s.slice(us, i);
+        }
+        out[neonFlagNameToJsonKey(flagRaw)] = value;
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
+function alignNeonRunSqlArgsToSchema(parsed, schemaKeys) {
+    const keys = new Set(schemaKeys);
+    const out = {};
+    const trySet = (schemaKey, val) => {
+        if (!val || val.trim() === '')
+            return;
+        if (keys.has(schemaKey))
+            out[schemaKey] = val;
+    };
+    trySet('projectId', parsed.projectId);
+    trySet('project_id', parsed.projectId);
+    trySet('branchId', parsed.branchId);
+    trySet('branch_id', parsed.branchId);
+    trySet('sql', parsed.sql);
+    trySet('query', parsed.query);
+    trySet('databaseName', parsed.databaseName);
+    trySet('database', parsed.databaseName);
+    return out;
+}
+function fixRunSqlJsonObject(resolvedTool, jo) {
+    if (!/_run_sql$/i.test(resolvedTool))
+        return null;
+    const sqlField = jo.sql;
+    if (typeof sqlField !== 'string' || !/--(project-id|branch-id)\b/.test(sqlField))
+        return null;
+    const merged = parseNeonCtlStyleFlags(sqlField.trim());
+    if (!merged || !merged.sql?.trim())
+        return null;
+    const schemaKeys = getMcpToolParameterKeys(resolvedTool);
+    const keySet = new Set(schemaKeys);
+    let aligned = alignNeonRunSqlArgsToSchema(merged, schemaKeys);
+    for (const [k, v] of Object.entries(jo)) {
+        if (k === 'sql')
+            continue;
+        if (typeof v === 'string' && v.trim() && keySet.has(k)) {
+            aligned = { ...aligned, [k]: v };
+        }
+    }
+    return Object.keys(aligned).length > 0 ? aligned : null;
+}
+function buildJsonArgsString(resolvedTool, argsRaw) {
+    const t = argsRaw.trim();
+    if (!t)
+        return '{}';
+    try {
+        const j = JSON.parse(t);
+        if (j !== null && typeof j === 'object' && !Array.isArray(j)) {
+            const jo = j;
+            const fixedObj = fixRunSqlJsonObject(resolvedTool, jo);
+            if (fixedObj)
+                return JSON.stringify(fixedObj);
+            return JSON.stringify(j);
+        }
+    }
+    catch {
+        // continua
+    }
+    if (/_run_sql$/i.test(resolvedTool)) {
+        const merged = parseNeonCtlStyleFlags(t);
+        if (merged) {
+            const keys = getMcpToolParameterKeys(resolvedTool);
+            const aligned = alignNeonRunSqlArgsToSchema(merged, keys);
+            if (Object.keys(aligned).length > 0)
+                return JSON.stringify(aligned);
+        }
+    }
+    const keys = getMcpToolParameterKeys(resolvedTool);
+    const unq = extractStringArg(t);
+    if (unq !== null) {
+        if (keys.includes('sql'))
+            return JSON.stringify({ sql: unq });
+        if (keys.includes('query'))
+            return JSON.stringify({ query: unq });
+        if (keys.includes('project_id'))
+            return JSON.stringify({ project_id: unq });
+        if (keys.includes('projectId'))
+            return JSON.stringify({ projectId: unq });
+        if (keys.length === 1)
+            return JSON.stringify({ [keys[0]]: unq });
+    }
+    return '{}';
+}
+function resolveToolName(requested, argsRaw, registered) {
+    if (registered.has(requested))
+        return requested;
+    const underscored = requested.replace(/-/g, '_');
+    if (registered.has(underscored))
+        return underscored;
+    const rl = requested.toLowerCase();
+    for (const n of registered) {
+        if (n.toLowerCase() === rl)
+            return n;
+        if (n.replace(/-/g, '_').toLowerCase() === underscored.toLowerCase())
+            return n;
+    }
+    const arg = extractStringArg(argsRaw);
+    const looksSql = arg !== null && /^\s*(SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRUNCATE|SHOW)\b/i.test(arg);
+    if (looksSql || /neon.*postgres.*execute|postgres.*execute/i.test(requested)) {
+        const runSqls = [...registered].filter((n) => /_run_sql$/i.test(n));
+        if (runSqls.length === 1)
+            return runSqls[0];
+        if (runSqls.length > 1) {
+            const neon = runSqls.find((n) => /neon/i.test(n));
+            return neon ?? runSqls[0];
+        }
+    }
+    return null;
+}
+function collectInvocationsFromMarkdown(content) {
+    if (getMcpExposedToolNames().length === 0)
+        return [];
+    const out = [];
+    const seen = new Set();
+    let m;
+    const re = new RegExp(BASH_BLOCK_RE.source, BASH_BLOCK_RE.flags);
+    while ((m = re.exec(content)) !== null) {
+        const body = m[1] ?? '';
+        for (const line of body.split('\n')) {
+            const parsed = parseMcpShellLine(line);
+            if (!parsed)
+                continue;
+            const key = `${parsed.tool}|${parsed.args}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(parsed);
+        }
+    }
+    return out;
+}
+export async function runMcpFromBashMarkdown(content, options) {
+    const invocations = collectInvocationsFromMarkdown(content);
+    if (invocations.length === 0) {
+        return { invocationCount: 0, executedCount: 0, augmentedAssistantText: content };
+    }
+    const registered = new Set(getMcpExposedToolNames());
+    const sections = [];
+    let executedCount = 0;
+    const verbose = mcpBashFallbackVerbose();
+    for (const inv of invocations) {
+        const resolved = resolveToolName(inv.tool, inv.args, registered);
+        if (!resolved) {
+            sections.push(`\n### ${inv.tool}\n_Ferramenta não encontrada nos MCPs conectados._`);
+            continue;
+        }
+        const jsonArgs = buildJsonArgsString(resolved, inv.args);
+        if (verbose) {
+            console.log(ui.warn(`\n[MCP · texto/bash] ${resolved}`));
+            console.log(ui.dim(jsonArgs.length > 220 ? `${jsonArgs.slice(0, 220)}…` : jsonArgs));
+        }
+        else {
+            console.log(ui.dim(`[MCP] ${resolved} (fallback bash)`));
+        }
+        const result = await callMcpTool(resolved, jsonArgs);
+        executedCount++;
+        sections.push(`\n### ${resolved}\n\`\`\`text\n${trunc(result, 12000)}\n\`\`\``);
+    }
+    const appendixBody = sections.join('\n');
+    const alreadyHasMcpSection = options?.skipDuplicateAppendix === true &&
+        /\n##\s+Resultados\s+MCP\b/i.test(content);
+    const appendix = alreadyHasMcpSection
+        ? ''
+        : '\n\n---\n## Resultados MCP (fallback bash — Pokt CLI)\n' + appendixBody;
+    return {
+        invocationCount: invocations.length,
+        executedCount,
+        augmentedAssistantText: content + appendix,
+    };
+}
+function lastUserPlainText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== 'user')
+            continue;
+        const c = m.content;
+        if (typeof c === 'string')
+            return c;
+        if (Array.isArray(c)) {
+            return c
+                .map((part) => typeof part === 'object' && part != null && 'text' in part ? part.text : String(part))
+                .join('');
+        }
+    }
+    return '';
+}
+/**
+ * Quando o modelo devolve vazio e o pedido parece “listar bancos”, executa mcp_*_run_sql uma vez.
+ */
+export async function tryAutoMcpForListDatabases(messages) {
+    const text = lastUserPlainText(messages);
+    if (!/\b(bancos?\s+de\s+dados|banco\s+de\s+dados|listar.*bancos?|quais\s+bancos|databases?\b|postgresql|postgres|neon|\bmcp\b)\b/i.test(text)) {
+        return null;
+    }
+    const runSqls = getMcpExposedToolNames().filter((n) => /_run_sql$/i.test(n));
+    if (runSqls.length === 0)
+        return null;
+    const tool = runSqls.find((n) => /neon/i.test(n)) ?? runSqls[0];
+    const sql = 'SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY 1;';
+    if (mcpBashFallbackVerbose()) {
+        console.log(ui.warn(`\n[MCP · automático] ${tool} — listando bancos (modelo sem resposta útil)`));
+    }
+    else {
+        console.log(ui.dim(`[MCP] ${tool} (automático — listar bancos)`));
+    }
+    const out = await callMcpTool(tool, JSON.stringify({ sql }));
+    return `## Bancos de dados (Postgres)\n\n**Ferramenta:** \`${tool}\`\n\n\`\`\`text\n${trunc(out, 12000)}\n\`\`\`\n\n_A automação do Pokt executou esta consulta porque o pedido parecia listar bancos e o modelo não retornou conteúdo._`;
+}

package/dist/chat/sessions.d.ts

@@ -0,0 +1,18 @@
+import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions/completions.js';
+type PersistedMessage = {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+};
+export declare function getProjectHash(cwd?: string): string;
+export declare function getSessionsDir(): string;
+export declare function saveAuto(messages: ChatCompletionMessageParam[]): void;
+export declare function loadAuto(): PersistedMessage[] | null;
+export declare function listCheckpoints(): Array<{
+    tag: string;
+    updatedAt?: string;
+}>;
+export declare function saveCheckpoint(tag: string, messages: ChatCompletionMessageParam[]): void;
+export declare function loadCheckpoint(tag: string): PersistedMessage[];
+export declare function deleteCheckpoint(tag: string): void;
+export declare function exportConversation(filename: string, messages: ChatCompletionMessageParam[]): string;
+export {};

package/dist/chat/sessions.js

@@ -0,0 +1,120 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+function toPersisted(messages) {
+    return messages
+        .filter((m) => !!m && typeof m === 'object' && 'role' in m)
+        .map((m) => {
+        const role = m.role;
+        const content = m.content;
+        if (typeof content === 'string')
+            return { role, content };
+        if (Array.isArray(content)) {
+            const text = content
+                .map((part) => (part && typeof part === 'object' && 'text' in part ? String(part.text) : String(part)))
+                .join('');
+            return { role, content: text };
+        }
+        return { role, content: content != null ? String(content) : '' };
+    });
+}
+function ensureDir(p) {
+    fs.mkdirSync(p, { recursive: true });
+}
+function safeTag(tag) {
+    return tag.trim().replace(/[<>:"/\\|?*\x00-\x1F]/g, '_').slice(0, 80);
+}
+export function getProjectHash(cwd = process.cwd()) {
+    const h = crypto.createHash('sha1');
+    h.update(path.resolve(cwd));
+    return h.digest('hex').slice(0, 12);
+}
+export function getSessionsDir() {
+    // compatível Windows/mac/linux
+    const base = path.join(os.homedir(), '.pokt', 'tmp');
+    const proj = getProjectHash();
+    const dir = path.join(base, proj);
+    ensureDir(dir);
+    return dir;
+}
+function getAutoPath() {
+    return path.join(getSessionsDir(), 'auto.json');
+}
+export function saveAuto(messages) {
+    const payload = {
+        updatedAt: new Date().toISOString(),
+        cwd: process.cwd(),
+        messages: toPersisted(messages),
+    };
+    fs.writeFileSync(getAutoPath(), JSON.stringify(payload, null, 2), 'utf8');
+}
+export function loadAuto() {
+    try {
+        const raw = fs.readFileSync(getAutoPath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed?.messages) ? parsed.messages : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tagPath(tag) {
+    return path.join(getSessionsDir(), `checkpoint.${safeTag(tag)}.json`);
+}
+export function listCheckpoints() {
+    const dir = getSessionsDir();
+    const files = fs.readdirSync(dir).filter((f) => f.startsWith('checkpoint.') && f.endsWith('.json'));
+    return files
+        .map((f) => {
+        const tag = f.replace(/^checkpoint\./, '').replace(/\.json$/, '');
+        try {
+            const raw = fs.readFileSync(path.join(dir, f), 'utf8');
+            const parsed = JSON.parse(raw);
+            return { tag, updatedAt: parsed.updatedAt };
+        }
+        catch {
+            return { tag };
+        }
+    })
+        .sort((a, b) => String(b.updatedAt ?? '').localeCompare(String(a.updatedAt ?? '')));
+}
+export function saveCheckpoint(tag, messages) {
+    const t = safeTag(tag);
+    if (!t)
+        throw new Error('Tag inválida.');
+    const payload = {
+        tag: t,
+        updatedAt: new Date().toISOString(),
+        cwd: process.cwd(),
+        messages: toPersisted(messages),
+    };
+    fs.writeFileSync(tagPath(t), JSON.stringify(payload, null, 2), 'utf8');
+}
+export function loadCheckpoint(tag) {
+    const t = safeTag(tag);
+    const raw = fs.readFileSync(tagPath(t), 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed?.messages))
+        throw new Error('Checkpoint inválido.');
+    return parsed.messages;
+}
+export function deleteCheckpoint(tag) {
+    const t = safeTag(tag);
+    fs.unlinkSync(tagPath(t));
+}
+export function exportConversation(filename, messages) {
+    const out = path.isAbsolute(filename) ? filename : path.join(process.cwd(), filename);
+    const ext = path.extname(out).toLowerCase();
+    if (ext === '.json') {
+        fs.writeFileSync(out, JSON.stringify({ exportedAt: new Date().toISOString(), messages: toPersisted(messages) }, null, 2), 'utf8');
+        return out;
+    }
+    // markdown
+    const md = toPersisted(messages)
+        .filter((m) => m.role !== 'system')
+        .map((m) => `## ${m.role}\n\n${m.content}\n`)
+        .join('\n');
+    fs.writeFileSync(out, `# Pokt CLI chat export\n\nExportado em: ${new Date().toISOString()}\n\n${md}`, 'utf8');
+    return out;
+}

package/dist/chat/slim-tools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reduz o tamanho do array `tools` enviado à API (ex.: Pokt Controller com body limit baixo).
+ * Schemas MCP (Neon etc.) podem ter dezenas de KB por tool.
+ */
+import type { ChatCompletionTool } from 'openai/resources/chat/completions/completions.js';
+export declare function slimToolsForUpstreamPayload(tools: ChatCompletionTool[]): ChatCompletionTool[];

package/dist/chat/slim-tools.js

@@ -0,0 +1,65 @@
+const MAX_FUNCTION_DESCRIPTION_CHARS = 520;
+const MAX_SCHEMA_STRING_CHARS = 480;
+const MAX_TOOL_PARAMETERS_JSON_CHARS = 22_000;
+function deepTruncateStrings(obj, maxLen, depth = 0) {
+    if (depth > 14)
+        return obj;
+    if (typeof obj === 'string') {
+        if (obj.length <= maxLen)
+            return obj;
+        return `${obj.slice(0, Math.max(0, maxLen - 1))}…`;
+    }
+    if (Array.isArray(obj)) {
+        const cap = 80;
+        const arr = obj.length > cap ? obj.slice(0, cap) : obj;
+        return arr.map((x) => deepTruncateStrings(x, maxLen, depth + 1));
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const o = obj;
+        const out = {};
+        for (const k of Object.keys(o)) {
+            out[k] = deepTruncateStrings(o[k], maxLen, depth + 1);
+        }
+        return out;
+    }
+    return obj;
+}
+/** Último recurso: schema aberto (o modelo já vê nomes exatos no system prompt). */
+function fallbackOpenEndedParameters() {
+    return {
+        type: 'object',
+        additionalProperties: true,
+        description: 'JSON com os argumentos da tool MCP (ex.: projectId, branchId, sql).',
+    };
+}
+export function slimToolsForUpstreamPayload(tools) {
+    return tools.map((t) => {
+        if (t.type !== 'function' || !t.function)
+            return t;
+        const fn = t.function;
+        const rawDesc = fn.description ?? '';
+        const description = rawDesc.length <= MAX_FUNCTION_DESCRIPTION_CHARS
+            ? rawDesc
+            : `${rawDesc.slice(0, MAX_FUNCTION_DESCRIPTION_CHARS - 1)}…`;
+        let parameters = fn.parameters;
+        if (parameters && typeof parameters === 'object') {
+            parameters = deepTruncateStrings(parameters, MAX_SCHEMA_STRING_CHARS);
+        }
+        let jsonLen = JSON.stringify(parameters ?? {}).length;
+        if (jsonLen > MAX_TOOL_PARAMETERS_JSON_CHARS) {
+            parameters = deepTruncateStrings(parameters, 220);
+            jsonLen = JSON.stringify(parameters ?? {}).length;
+        }
+        if (jsonLen > MAX_TOOL_PARAMETERS_JSON_CHARS) {
+            parameters = fallbackOpenEndedParameters();
+        }
+        return {
+            type: 'function',
+            function: {
+                name: fn.name,
+                description,
+                parameters,
+            },
+        };
+    });
+}

package/dist/chat/tools.js

@@ -7,6 +7,29 @@ import * as diff from 'diff';
 const execAsync = promisify(exec);
 /** Máximo de linhas de diff exibidas; além disso mostra resumo para não imprimir arquivo inteiro */
 const MAX_DIFF_LINES = 45;
+function isGeneratedNoisePath(relPath) {
+    const base = path.basename(relPath);
+    return /^generated\.(text|json)$/i.test(base);
+}
+function looksLikeMcpJsonDump(s) {
+    const t = s.trim();
+    if (!t)
+        return false;
+    try {
+        const j = JSON.parse(t);
+        if (j !== null && typeof j === 'object' && !Array.isArray(j)) {
+            const o = j;
+            return 'success' in o && 'result' in o;
+        }
+        if (Array.isArray(j) && j.length > 0 && j.every((x) => x && typeof x === 'object')) {
+            return true;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return false;
+}
 function showDiff(filePath, oldContent, newContent) {
     const relativePath = path.relative(process.cwd(), filePath);
     console.log(chalk.blue.bold(`\n📝 Edit ${relativePath}:`));
@@ -170,7 +193,13 @@ export async function executeTool(name, argsStr) {
             const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, args.content, 'utf8');
-            showDiff(filePath, oldContent, args.content);
+            const rel = path.relative(process.cwd(), filePath);
+            if (isGeneratedNoisePath(rel) && looksLikeMcpJsonDump(args.content)) {
+                console.log(chalk.dim(`\n📝 ${rel} (omitido diff — parece resposta MCP/JSON; use tabela no texto do assistente)\n`));
+            }
+            else {
+                showDiff(filePath, oldContent, args.content);
+            }
             return `Successfully wrote to ${args.path}`;
         }
         if (name === 'run_command') {

package/dist/commands/chat.js

@@ -1,4 +1,4 @@
-import { config, getEffectiveActiveModel } from '../config.js';
+import { getEffectiveActiveModel, getOpenAIApiKey, getGrokApiKey, getOpenRouterToken, getGeminiApiKey, getPoktToken } from '../config.js';
 import { startChatLoop } from '../chat/loop.js';
 import { ui } from '../ui.js';
 export const chatCommand = {
@@ -11,23 +11,31 @@ export const chatCommand = {
             console.log(ui.error('No active model selected. Run: pokt models list then pokt models use -p <provider> -i <id>'));
             return;
         }
-        if (activeModel.provider === 'openrouter' && !config.get('openrouterToken')) {
+        if (activeModel.provider === 'openrouter' && !getOpenRouterToken()) {
             console.log(ui.error('OpenRouter token not set. Use: pokt config set-openrouter -v <token>'));
             return;
         }
-        if (activeModel.provider === 'gemini' && !config.get('geminiApiKey')) {
+        if (activeModel.provider === 'openai' && !getOpenAIApiKey()) {
+            console.log(ui.error('OpenAI API key not set. Use: pokt config set-openai -v <key>'));
+            return;
+        }
+        if (activeModel.provider === 'grok' && !getGrokApiKey()) {
+            console.log(ui.error('Grok (xAI) API key not set. Use: pokt config set-grok -v <key>'));
+            return;
+        }
+        if (activeModel.provider === 'gemini' && !getGeminiApiKey()) {
             console.log(ui.error('Gemini API key not set. Use: pokt config set-gemini -v <key>'));
             return;
         }
         if (activeModel.provider === 'controller') {
-            if (!config.get('poktToken')) {
+            if (!getPoktToken()) {
                 console.log(ui.error('Pokt token not set. Generate one at the panel and: pokt config set-pokt-token -v <token>'));
                 return;
             }
         }
         // Se veio do menu interativo, não repetir banner/tips (já foram exibidos)
         if (!fromMenu) {
-            console.log(ui.banner());
+            await ui.printBanner({ animate: true });
             console.log(ui.statusLine(`[${activeModel.provider}] ${activeModel.id}`));
             console.log('');
             console.log(ui.tips());