pokt-cli 1.0.0

package/dist/commands/models.d.ts

@@ -0,0 +1,8 @@
+import type * as Yargs from 'yargs';
+interface ModelsArgs {
+    action?: string;
+    id?: string;
+    provider?: string;
+}
+export declare const modelsCommand: Yargs.CommandModule<{}, ModelsArgs>;
+export {};

package/dist/commands/models.js

@@ -0,0 +1,195 @@
+import { config, getEffectiveActiveModel, PROVIDER_LABELS } from '../config.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ui } from '../ui.js';
+export const modelsCommand = {
+    command: 'models <action>',
+    describe: 'Manage AI models',
+    builder: (yargs) => yargs
+        .positional('action', {
+        describe: 'Action to perform',
+        type: 'string',
+        choices: ['add', 'add-ollama', 'add-ollama-cloud', 'add-openrouter', 'use', 'list', 'fetch-openrouter', 'fetch-ollama', 'fetch-ollama-cloud']
+    })
+        .option('id', {
+        describe: 'Model ID (e.g., llama3, google/gemini-2.5-flash)',
+        type: 'string',
+        alias: 'i'
+    })
+        .option('provider', {
+        describe: 'Provider (for "add" or "use": openrouter, ollama, ollama-cloud, gemini, controller)',
+        type: 'string',
+        choices: ['openrouter', 'ollama', 'ollama-cloud', 'gemini', 'controller'],
+        alias: 'p'
+    }),
+    handler: async (argv) => {
+        const { action, id, provider } = argv;
+        if (action === 'list') {
+            const models = config.get('registeredModels');
+            const active = getEffectiveActiveModel();
+            console.log(chalk.blue('\nRegistered Models:'));
+            models.forEach((m) => {
+                const isActive = active?.id === m.id && active?.provider === m.provider;
+                const label = PROVIDER_LABELS[m.provider] ?? m.provider;
+                console.log(`${isActive ? chalk.green('★') : ' '} [${label}] ${m.id}`);
+            });
+            console.log('');
+            return;
+        }
+        if (action === 'fetch-openrouter') {
+            const spinner = ora('Fetching OpenRouter models...').start();
+            try {
+                const response = await fetch('https://openrouter.ai/api/v1/models');
+                if (!response.ok) {
+                    spinner.fail(ui.error(`Failed to fetch OpenRouter models: HTTP ${response.status}`));
+                    const body = await response.text();
+                    if (body)
+                        console.log(ui.dim(body.slice(0, 200)));
+                    console.log(ui.warn('Check your network and OpenRouter token. Run: pokt config show'));
+                    return;
+                }
+                const data = await response.json();
+                const openrouterModels = (data.data || []).map((m) => ({ provider: 'openrouter', id: m.id }));
+                const currentModels = config.get('registeredModels');
+                const otherModels = currentModels.filter((m) => m.provider !== 'openrouter');
+                config.set('registeredModels', [...otherModels, ...openrouterModels]);
+                spinner.succeed(ui.success(`Synchronized ${openrouterModels.length} OpenRouter models.`));
+            }
+            catch (error) {
+                spinner.fail(ui.error(`Failed to fetch OpenRouter models: ${error.message}`));
+                console.log(ui.warn('Check your network. Run: pokt config show'));
+            }
+            return;
+        }
+        if (action === 'fetch-ollama') {
+            const baseUrl = (config.get('ollamaBaseUrl') || 'http://localhost:11434').replace(/\/$/, '');
+            const url = `${baseUrl}/api/tags`;
+            const spinner = ora(`Fetching Ollama models (${url})...`).start();
+            try {
+                const response = await fetch(url);
+                if (!response.ok) {
+                    spinner.fail(ui.error(`Failed to fetch Ollama models: HTTP ${response.status}`));
+                    console.log(ui.warn('Check Ollama is running and ollamaBaseUrl. Run: pokt config show'));
+                    return;
+                }
+                const data = await response.json();
+                const names = (data.models || []).map((m) => m.name);
+                const ollamaModels = names.map((name) => ({ provider: 'ollama', id: name }));
+                const currentModels = config.get('registeredModels');
+                const otherModels = currentModels.filter((m) => m.provider !== 'ollama');
+                config.set('registeredModels', [...otherModels, ...ollamaModels]);
+                spinner.succeed(ui.success(`Synchronized ${ollamaModels.length} Ollama (local) models.`));
+            }
+            catch (error) {
+                spinner.fail(ui.error(`Failed to fetch Ollama models: ${error.message}`));
+                console.log(ui.warn('Check Ollama is running. Run: pokt config show'));
+            }
+            return;
+        }
+        if (action === 'fetch-ollama-cloud') {
+            const apiKey = config.get('ollamaCloudApiKey');
+            if (!apiKey) {
+                console.log(ui.error('Ollama Cloud API key not set. Run: pokt config set-ollama-cloud -v <key>'));
+                console.log(ui.dim('Create keys at: https://ollama.com/settings/keys'));
+                return;
+            }
+            const spinner = ora('Fetching Ollama Cloud models (https://ollama.com/api/tags)...').start();
+            try {
+                const response = await fetch('https://ollama.com/api/tags', {
+                    headers: { Authorization: `Bearer ${apiKey}` }
+                });
+                if (!response.ok) {
+                    spinner.fail(ui.error(`Failed to fetch Ollama Cloud models: HTTP ${response.status}`));
+                    const body = await response.text();
+                    if (body)
+                        console.log(ui.dim(body.slice(0, 200)));
+                    console.log(ui.warn('Check your API key. Run: pokt config show'));
+                    return;
+                }
+                const data = await response.json();
+                const names = (data.models || []).map((m) => m.name);
+                const ollamaCloudModels = names.map((name) => ({ provider: 'ollama-cloud', id: name }));
+                const currentModels = config.get('registeredModels');
+                const otherModels = currentModels.filter((m) => m.provider !== 'ollama-cloud');
+                config.set('registeredModels', [...otherModels, ...ollamaCloudModels]);
+                spinner.succeed(ui.success(`Synchronized ${ollamaCloudModels.length} Ollama Cloud models.`));
+            }
+            catch (error) {
+                spinner.fail(ui.error(`Failed to fetch Ollama Cloud models: ${error.message}`));
+                console.log(ui.warn('Check your network and API key. Run: pokt config show'));
+            }
+            return;
+        }
+        if (action === 'add') {
+            const allowed = ['openrouter', 'ollama', 'ollama-cloud'];
+            if (!id)
+                return console.log(ui.error('Error: --id is required for add. Example: pokt models add -p openrouter -i google/gemini-2.5-flash'));
+            if (!provider || !allowed.includes(provider)) {
+                return console.log(ui.error(`Error: --provider is required and must be one of: ${allowed.join(', ')}. Example: pokt models add -p openrouter -i <model-id>`));
+            }
+            const p = provider;
+            const models = config.get('registeredModels');
+            if (!models.find((m) => m.id === id && m.provider === p)) {
+                models.push({ provider: p, id: id });
+                config.set('registeredModels', models);
+                const label = PROVIDER_LABELS[p];
+                console.log(ui.success(`Added ${label} model: ${id}`));
+            }
+            else {
+                console.log(ui.warn(`Model ${id} already exists for ${PROVIDER_LABELS[p]}.`));
+            }
+        }
+        else if (action === 'add-ollama') {
+            if (!id)
+                return console.log(ui.error('Error: --id is required for add-ollama'));
+            const models = config.get('registeredModels');
+            if (!models.find((m) => m.id === id && m.provider === 'ollama')) {
+                models.push({ provider: 'ollama', id: id });
+                config.set('registeredModels', models);
+                console.log(ui.success(`Added Ollama model: ${id}`));
+            }
+            else {
+                console.log(ui.warn(`Model ${id} already exists for Ollama.`));
+            }
+        }
+        else if (action === 'add-ollama-cloud') {
+            if (!id)
+                return console.log(ui.error('Error: --id is required for add-ollama-cloud'));
+            const models = config.get('registeredModels');
+            if (!models.find((m) => m.id === id && m.provider === 'ollama-cloud')) {
+                models.push({ provider: 'ollama-cloud', id: id });
+                config.set('registeredModels', models);
+                console.log(ui.success(`Added Ollama Cloud model: ${id}`));
+            }
+            else {
+                console.log(ui.warn(`Model ${id} already exists for Ollama Cloud.`));
+            }
+        }
+        else if (action === 'add-openrouter') {
+            if (!id)
+                return console.log(ui.error('Error: --id is required for add-openrouter. Example: pokt models add-openrouter -i google/gemini-2.5-flash'));
+            const models = config.get('registeredModels');
+            if (!models.find((m) => m.id === id && m.provider === 'openrouter')) {
+                models.push({ provider: 'openrouter', id: id });
+                config.set('registeredModels', models);
+                console.log(ui.success(`Added OpenRouter model: ${id}`));
+            }
+            else {
+                console.log(ui.warn(`Model ${id} already exists for OpenRouter.`));
+            }
+        }
+        else if (action === 'use') {
+            if (!id || !provider)
+                return console.log(ui.error('Error: --id and --provider are required for use'));
+            const models = config.get('registeredModels');
+            const model = models.find((m) => m.id === id && m.provider === provider);
+            if (model) {
+                config.set('activeModel', model);
+                console.log(ui.success(`Active model set to [${provider}] ${id}`));
+            }
+            else {
+                console.log(ui.error(`Model ${id} for provider ${provider} not found. Run: pokt models list`));
+            }
+        }
+    }
+};

package/dist/commands/provider.d.ts

@@ -0,0 +1,6 @@
+import type * as Yargs from 'yargs';
+interface ProviderArgs {
+    provider?: string;
+}
+export declare const providerCommand: Yargs.CommandModule<{}, ProviderArgs>;
+export {};

package/dist/commands/provider.js

@@ -0,0 +1,53 @@
+import { config, ALL_PROVIDERS } from '../config.js';
+import { ui } from '../ui.js';
+export const providerCommand = {
+    command: 'provider use <provider>',
+    describe: 'Switch API provider (casa de API): controller (Pokt), openrouter, gemini, ollama, ollama-cloud',
+    builder: (yargs) => yargs
+        .positional('provider', {
+        describe: 'Provider to use as primary',
+        type: 'string',
+        choices: [...ALL_PROVIDERS]
+    }),
+    handler: (argv) => {
+        const provider = argv.provider;
+        const models = config.get('registeredModels');
+        const model = models.find((m) => m.provider === provider);
+        if (!model) {
+            if (provider === 'controller') {
+                console.log(ui.error('Controller model not found. Add it with: pokt config set-pokt-token -v <token>'));
+            }
+            else if (provider === 'openrouter') {
+                console.log(ui.error('No OpenRouter model. Run: pokt models fetch-openrouter then pokt models list'));
+            }
+            else if (provider === 'ollama') {
+                console.log(ui.error('No Ollama (local) model. Run: pokt models fetch-ollama then pokt models list'));
+            }
+            else if (provider === 'ollama-cloud') {
+                console.log(ui.error('No Ollama Cloud model. Run: pokt models fetch-ollama-cloud then pokt models list'));
+            }
+            else {
+                console.log(ui.error(`No model for provider "${provider}". Run: pokt models list and add one.`));
+            }
+            return;
+        }
+        if (provider === 'openrouter' && !config.get('openrouterToken')) {
+            console.log(ui.error('OpenRouter token not set. Use: pokt config set-openrouter -v <token>'));
+            return;
+        }
+        if (provider === 'gemini' && !config.get('geminiApiKey')) {
+            console.log(ui.error('Gemini API key not set. Use: pokt config set-gemini -v <key>'));
+            return;
+        }
+        if (provider === 'controller' && !config.get('poktToken')) {
+            console.log(ui.error('Pokt token not set. Use: pokt config set-pokt-token -v <token>'));
+            return;
+        }
+        if (provider === 'ollama-cloud' && !config.get('ollamaCloudApiKey')) {
+            console.log(ui.error('Ollama Cloud API key not set. Use: pokt config set-ollama-cloud -v <key>'));
+            return;
+        }
+        config.set('activeModel', model);
+        console.log(ui.success(`Primary provider set to [${provider}] (model: ${model.id}). Use "pokt chat" to start.`));
+    }
+};

package/dist/config.d.ts

@@ -0,0 +1,35 @@
+import Conf from 'conf';
+export type Provider = 'openrouter' | 'ollama' | 'ollama-cloud' | 'gemini' | 'controller';
+export declare const PROVIDER_LABELS: Record<Provider, string>;
+/** Lista de todos os provedores disponíveis (único lugar para incluir novos no futuro) */
+export declare const ALL_PROVIDERS: readonly Provider[];
+export interface ModelConfig {
+    provider: Provider;
+    id: string;
+}
+export interface McpServerConfig {
+    name: string;
+    type: 'stdio' | 'http';
+    /** Para stdio: comando a executar (ex: "npx", "node") */
+    command?: string;
+    /** Para stdio: argumentos (ex: ["-y", "mcp-server-filesystem"]) */
+    args?: string[];
+    /** Para http: URL do servidor MCP (Streamable HTTP ou SSE) */
+    url?: string;
+}
+interface AppConfig {
+    openrouterToken: string;
+    geminiApiKey: string;
+    ollamaBaseUrl: string;
+    ollamaCloudApiKey: string;
+    controllerBaseUrl: string;
+    poktToken: string;
+    registeredModels: ModelConfig[];
+    activeModel: ModelConfig | null;
+    mcpServers: McpServerConfig[];
+}
+export declare const config: Conf<AppConfig>;
+export declare const getControllerBaseUrl: () => string;
+/** Prioridade: modelo ativo explícito → Pokt (controller) se token setado → OpenRouter → Gemini → Ollama Cloud → Ollama local */
+export declare function getEffectiveActiveModel(): ModelConfig | null;
+export {};

package/dist/config.js

@@ -0,0 +1,66 @@
+import Conf from 'conf';
+export const PROVIDER_LABELS = {
+    controller: 'Pokt API (Controller)',
+    openrouter: 'OpenRouter',
+    gemini: 'Gemini',
+    ollama: 'Ollama (local)',
+    'ollama-cloud': 'Ollama Cloud'
+};
+/** Lista de todos os provedores disponíveis (único lugar para incluir novos no futuro) */
+export const ALL_PROVIDERS = Object.keys(PROVIDER_LABELS);
+const DEFAULT_CONTROLLER_URL = 'https://pokt-cli-controller.vercel.app';
+export const config = new Conf({
+    projectName: 'pokt-cli',
+    defaults: {
+        openrouterToken: '',
+        geminiApiKey: '',
+        ollamaBaseUrl: 'http://localhost:11434',
+        ollamaCloudApiKey: '',
+        controllerBaseUrl: DEFAULT_CONTROLLER_URL,
+        poktToken: '',
+        registeredModels: [
+            { provider: 'controller', id: 'default' },
+            { provider: 'openrouter', id: 'google/gemini-2.0-flash-001' },
+            { provider: 'openrouter', id: 'anthropic/claude-3.5-sonnet' },
+            { provider: 'gemini', id: 'gemini-1.5-flash' },
+            { provider: 'gemini', id: 'gemini-1.5-pro' }
+        ],
+        activeModel: null,
+        mcpServers: [],
+    }
+});
+export const getControllerBaseUrl = () => {
+    const url = config.get('controllerBaseUrl') || DEFAULT_CONTROLLER_URL;
+    return url.replace(/\/$/, '');
+};
+/** Prioridade: modelo ativo explícito → Pokt (controller) se token setado → OpenRouter → Gemini → Ollama Cloud → Ollama local */
+export function getEffectiveActiveModel() {
+    const explicit = config.get('activeModel');
+    if (explicit)
+        return explicit;
+    const models = config.get('registeredModels');
+    if (config.get('poktToken')) {
+        const c = models.find((m) => m.provider === 'controller');
+        if (c)
+            return c;
+    }
+    if (config.get('openrouterToken')) {
+        const o = models.find((m) => m.provider === 'openrouter');
+        if (o)
+            return o;
+    }
+    if (config.get('geminiApiKey')) {
+        const g = models.find((m) => m.provider === 'gemini');
+        if (g)
+            return g;
+    }
+    if (config.get('ollamaCloudApiKey')) {
+        const oc = models.find((m) => m.provider === 'ollama-cloud');
+        if (oc)
+            return oc;
+    }
+    const ollama = models.find((m) => m.provider === 'ollama');
+    if (ollama)
+        return ollama;
+    return models[0] ?? null;
+}

package/dist/mcp/client.d.ts

@@ -0,0 +1,59 @@
+import type { McpServerConfig } from '../config.js';
+import type { ChatCompletionTool } from 'openai/resources/chat/completions/completions.js';
+export interface McpToolDef {
+    serverName: string;
+    name: string;
+    /** Nome exposto ao LLM (com prefixo para evitar colisão) */
+    exposedName: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpClientSession {
+    serverName: string;
+    client: {
+        listTools: () => Promise<{
+            tools: Array<{
+                name: string;
+                description?: string;
+                inputSchema?: Record<string, unknown>;
+            }>;
+        }>;
+        callTool: (params: {
+            name: string;
+            arguments?: Record<string, unknown>;
+        }) => Promise<{
+            content: Array<{
+                type?: string;
+                text?: string;
+            }>;
+        }>;
+    };
+    tools: McpToolDef[];
+    transport?: {
+        close?: () => void;
+    };
+}
+/**
+ * Converte tool MCP para formato OpenAI ChatCompletionTool.
+ */
+export declare function mcpToolToOpenAI(t: McpToolDef): ChatCompletionTool;
+/**
+ * Conecta a um servidor MCP (stdio) e retorna a sessão com tools listados.
+ */
+export declare function connectMcpServer(serverConfig: McpServerConfig): Promise<McpClientSession | null>;
+/**
+ * Desconecta todos os clientes MCP.
+ */
+export declare function disconnectAllMcp(): Promise<void>;
+/**
+ * Retorna todas as tools MCP de todas as sessões ativas em formato OpenAI.
+ */
+export declare function getAllMcpToolsOpenAI(): ChatCompletionTool[];
+/**
+ * Executa uma tool pelo nome exposto (mcp_<server>_<tool>). Retorna o resultado em string.
+ */
+export declare function callMcpTool(exposedName: string, argsStr: string): Promise<string>;
+/**
+ * Verifica se um nome de tool é de MCP (deve ser roteado ao cliente MCP).
+ */
+export declare function isMcpTool(name: string): boolean;

package/dist/mcp/client.js

@@ -0,0 +1,130 @@
+/**
+ * Cliente MCP (Model Context Protocol) para conectar a servidores MCP
+ * e expor tools como funções disponíveis no chat.
+ */
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const sdkPath = path.dirname(require.resolve('@modelcontextprotocol/sdk/package.json'));
+const stdioModulePath = pathToFileURL(path.join(sdkPath, 'dist/esm/client/stdio.js')).href;
+const MCP_PREFIX = 'mcp_';
+let sessions = [];
+/**
+ * Converte tool MCP para formato OpenAI ChatCompletionTool.
+ */
+export function mcpToolToOpenAI(t) {
+    const params = t.inputSchema?.type === 'object' ? t.inputSchema : { type: 'object', properties: t.inputSchema ?? {} };
+    return {
+        type: 'function',
+        function: {
+            name: t.exposedName,
+            description: t.description,
+            parameters: params,
+        },
+    };
+}
+/**
+ * Conecta a um servidor MCP (stdio) e retorna a sessão com tools listados.
+ */
+export async function connectMcpServer(serverConfig) {
+    try {
+        const { Client } = await import('@modelcontextprotocol/sdk/client');
+        const { StdioClientTransport } = await import(stdioModulePath);
+        if (serverConfig.type !== 'stdio' || !serverConfig.command) {
+            return null;
+        }
+        const transport = new StdioClientTransport({
+            command: serverConfig.command,
+            args: serverConfig.args ?? [],
+            env: process.env,
+        });
+        const client = new Client({ name: 'pokt-cli', version: '1.0.0' });
+        await client.connect(transport);
+        const list = await client.listTools();
+        const tools = (list.tools ?? []).map((t) => ({
+            serverName: serverConfig.name,
+            name: t.name,
+            exposedName: `${MCP_PREFIX}${serverConfig.name}_${t.name}`.replace(/\s+/g, '_'),
+            description: t.description ?? `MCP tool: ${t.name}`,
+            inputSchema: t.inputSchema ?? { type: 'object', properties: {} },
+        }));
+        const session = {
+            serverName: serverConfig.name,
+            client: client,
+            tools,
+            transport: transport,
+        };
+        sessions.push(session);
+        return session;
+    }
+    catch (err) {
+        console.error(`[MCP] Failed to connect to ${serverConfig.name}:`, err);
+        return null;
+    }
+}
+/**
+ * Desconecta todos os clientes MCP.
+ */
+export async function disconnectAllMcp() {
+    for (const s of sessions) {
+        try {
+            if (s.transport?.close)
+                s.transport.close();
+        }
+        catch (_) { }
+    }
+    sessions = [];
+}
+/**
+ * Retorna todas as tools MCP de todas as sessões ativas em formato OpenAI.
+ */
+export function getAllMcpToolsOpenAI() {
+    const out = [];
+    for (const s of sessions) {
+        for (const t of s.tools) {
+            out.push(mcpToolToOpenAI(t));
+        }
+    }
+    return out;
+}
+/**
+ * Executa uma tool pelo nome exposto (mcp_<server>_<tool>). Retorna o resultado em string.
+ */
+export async function callMcpTool(exposedName, argsStr) {
+    if (!exposedName.startsWith(MCP_PREFIX)) {
+        return `[MCP] Not an MCP tool: ${exposedName}`;
+    }
+    const session = sessions.find(s => s.tools.some(t => t.exposedName === exposedName));
+    const tool = session?.tools.find(t => t.exposedName === exposedName);
+    if (!session || !tool) {
+        return `[MCP] Tool not found: ${exposedName}`;
+    }
+    try {
+        let args = {};
+        if (argsStr?.trim()) {
+            try {
+                args = JSON.parse(argsStr);
+            }
+            catch {
+                args = {};
+            }
+        }
+        const result = await session.client.callTool({ name: tool.name, arguments: args });
+        const content = result.content;
+        if (Array.isArray(content)) {
+            return content.map((c) => (c.type === 'text' && typeof c.text === 'string' ? c.text : JSON.stringify(c))).join('\n');
+        }
+        return typeof content === 'string' ? content : JSON.stringify(content);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return `[MCP] Error calling ${exposedName}: ${msg}`;
+    }
+}
+/**
+ * Verifica se um nome de tool é de MCP (deve ser roteado ao cliente MCP).
+ */
+export function isMcpTool(name) {
+    return name.startsWith(MCP_PREFIX);
+}

package/dist/ui.d.ts

@@ -0,0 +1,31 @@
+export declare const ui: {
+    title: (text: string) => any;
+    subtitle: (text: string) => any;
+    success: (text: string) => any;
+    error: (text: string) => any;
+    warn: (text: string) => any;
+    dim: (text: string) => any;
+    labelYou: () => any;
+    labelPokt: () => any;
+    accent: (text: string) => any;
+    muted: (text: string) => any;
+    /** Banner principal estilo Gemini CLI: logo + nome + versão */
+    banner: (customVersion?: string) => string;
+    /** Status de login / provider (uma linha) */
+    statusLine: (providerLabel: string, configPath?: string) => any;
+    /** Seção "Tips for getting started" */
+    tips: () => string;
+    /** Linha de atalhos acima do input */
+    shortcutsLine: (left?: string, right?: string, center?: string) => string;
+    /** Placeholder do input */
+    inputPlaceholder: () => any;
+    /** Barra de status inferior: path, branch, sandbox, model */
+    statusBar: (opts: {
+        cwd?: string;
+        branch?: string;
+        sandbox?: string;
+        model?: string;
+    }) => string;
+    /** Separador visual sutil */
+    separator: () => any;
+};