@pasko70/pibo 1.9.7 → 1.9.9

package/dist/mcp/commands/grep.js

@@ -1,145 +0,0 @@
-/**
- * Grep command - Search tools by pattern
- */
-import { debug, getConcurrencyLimit, getConnection, safeClose, } from '../client.js';
-import { getServerConfig, listServerNames, loadConfig, } from '../config.js';
-import { ErrorCode } from '../errors.js';
-import { formatSearchResults } from '../output.js';
-/**
- * Convert glob pattern to regex
- * Handles: * (any chars), ? (single char), ** (globstar)
- *
- * Examples:
- * - "*file*" matches "read_file", "file_utils"
- * - "**test**" matches "test", "my_test_tool", "testing"
- * - "server/*" matches "server/tool" but not "server/sub/tool"
- * - "server/**" matches "server/tool" and "server/sub/tool"
- */
-export function globToRegex(pattern) {
-    let escaped = '';
-    let i = 0;
-    while (i < pattern.length) {
-        const char = pattern[i];
-        if (char === '*' && pattern[i + 1] === '*') {
-            // ** (globstar) - match anything including slashes (zero or more chars)
-            escaped += '.*';
-            i += 2;
-            // Skip any immediately following * (e.g., *** becomes .*)
-            while (pattern[i] === '*') {
-                i++;
-            }
-        }
-        else if (char === '*') {
-            // * - match any chars except slash (zero or more)
-            escaped += '[^/]*';
-            i += 1;
-        }
-        else if (char === '?') {
-            // ? - match single char (not slash)
-            escaped += '[^/]';
-            i += 1;
-        }
-        else if ('[.+^${}()|\\]'.includes(char)) {
-            // Escape special regex chars
-            escaped += `\\${char}`;
-            i += 1;
-        }
-        else {
-            escaped += char;
-            i += 1;
-        }
-    }
-    return new RegExp(`^${escaped}$`, 'i');
-}
-/**
- * Process items with limited concurrency, preserving order
- */
-async function processWithConcurrency(items, processor, maxConcurrency) {
-    const results = new Array(items.length);
-    let currentIndex = 0;
-    async function worker() {
-        while (currentIndex < items.length) {
-            const index = currentIndex++;
-            results[index] = await processor(items[index], index);
-        }
-    }
-    // Start workers up to concurrency limit
-    const workers = Array.from({ length: Math.min(maxConcurrency, items.length) }, () => worker());
-    await Promise.all(workers);
-    return results;
-}
-/**
- * Search tools in a single server (uses daemon if enabled)
- */
-async function searchServerTools(serverName, config, pattern) {
-    let connection = null;
-    try {
-        const serverConfig = getServerConfig(config, serverName);
-        connection = await getConnection(serverName, serverConfig);
-        const tools = await connection.listTools();
-        const results = [];
-        for (const tool of tools) {
-            // Match against tool name only (not server name or description)
-            if (pattern.test(tool.name)) {
-                results.push({ server: serverName, tool });
-            }
-        }
-        debug(`${serverName}: found ${results.length} matches`);
-        return { serverName, results };
-    }
-    catch (error) {
-        const errorMsg = error.message;
-        debug(`${serverName}: connection failed - ${errorMsg}`);
-        return { serverName, results: [], error: errorMsg };
-    }
-    finally {
-        if (connection) {
-            await safeClose(connection.close);
-        }
-    }
-}
-/**
- * Execute the grep command
- */
-export async function grepCommand(options) {
-    let config;
-    try {
-        config = await loadConfig(options.configPath);
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(ErrorCode.CLIENT_ERROR);
-    }
-    const pattern = globToRegex(options.pattern);
-    const serverNames = listServerNames(config);
-    if (serverNames.length === 0) {
-        console.log('No MCP servers configured.');
-        console.log('Next: pibo mcp config help');
-        return;
-    }
-    const concurrencyLimit = getConcurrencyLimit();
-    debug(`Searching ${serverNames.length} servers for pattern "${options.pattern}" (concurrency: ${concurrencyLimit})`);
-    // Process servers in parallel with concurrency limit
-    const serverResults = await processWithConcurrency(serverNames, (serverName) => searchServerTools(serverName, config, pattern), concurrencyLimit);
-    const allResults = [];
-    const failedServers = [];
-    for (const result of serverResults) {
-        allResults.push(...result.results);
-        if (result.error) {
-            failedServers.push(result.serverName);
-        }
-    }
-    // Show failed servers warning
-    if (failedServers.length > 0) {
-        console.error(`Warning: ${failedServers.length} server(s) failed to connect: ${failedServers.join(', ')}`);
-    }
-    if (allResults.length === 0) {
-        console.log(`No tools found matching "${options.pattern}"`);
-        console.log('  Tip: Pattern matches tool names only (not server names)');
-        console.log(`  Tip: Use '*' for wildcards, e.g. '*file*' or 'read_*'`);
-        console.log(`  Tip: Run 'pibo mcp' to list all available tools`);
-        return;
-    }
-    // Human-readable output
-    console.log(formatSearchResults(allResults, options.withDescriptions));
-}

package/dist/mcp/commands/info.js

@@ -1,83 +0,0 @@
-/**
- * Info command - Show server or tool details
- */
-import { getConnection, safeClose } from '../client.js';
-import { formatConfigSourceSummaries, getConfigSourceSummaries, loadConfig, } from '../config.js';
-import { ErrorCode, formatCliError, serverConnectionError, toolNotFoundError, } from '../errors.js';
-import { formatServerDetails, formatToolSchema } from '../output.js';
-/**
- * Parse target into server and optional tool name
- */
-function parseTarget(target) {
-    const parts = target.split('/');
-    if (parts.length === 1) {
-        return { server: parts[0] };
-    }
-    return { server: parts[0], tool: parts.slice(1).join('/') };
-}
-/**
- * Execute the info command
- */
-export async function infoCommand(options) {
-    let config;
-    try {
-        config = await loadConfig(options.configPath);
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(ErrorCode.CLIENT_ERROR);
-    }
-    const { server: serverName, tool: toolName } = parseTarget(options.target);
-    const serverConfig = config.mcpServers[serverName];
-    if (!serverConfig) {
-        const available = Object.keys(config.mcpServers);
-        const serverList = available.length > 0 ? available.join(', ') : '(none)';
-        const summaries = await getConfigSourceSummaries(options.configPath);
-        console.error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'SERVER_NOT_FOUND',
-            message: `Server "${serverName}" not found in config`,
-            details: [
-                `Merged available servers: ${serverList}`,
-                'Config search paths:',
-                formatConfigSourceSummaries(summaries),
-            ].join('\n'),
-            suggestion: available.length > 0
-                ? `Use one of: ${available.map((s) => `pibo mcp info ${s}`).join(', ')}`
-                : `Add server to mcp_servers.json: { "mcpServers": { "${serverName}": { ... } } }`,
-        }));
-        process.exit(ErrorCode.CLIENT_ERROR);
-    }
-    let connection;
-    try {
-        connection = await getConnection(serverName, serverConfig);
-    }
-    catch (error) {
-        console.error(formatCliError(serverConnectionError(serverName, error.message)));
-        process.exit(ErrorCode.NETWORK_ERROR);
-    }
-    try {
-        if (toolName) {
-            // Show specific tool schema
-            const tools = await connection.listTools();
-            const tool = tools.find((t) => t.name === toolName);
-            if (!tool) {
-                const availableTools = tools.map((t) => t.name);
-                console.error(formatCliError(toolNotFoundError(toolName, serverName, availableTools)));
-                process.exit(ErrorCode.CLIENT_ERROR);
-            }
-            // Human-readable output
-            console.log(formatToolSchema(serverName, tool));
-        }
-        else {
-            // Show server details
-            const tools = await connection.listTools();
-            const instructions = await connection.getInstructions();
-            // Human-readable output
-            console.log(formatServerDetails(serverName, serverConfig, tools, options.withDescriptions, instructions));
-        }
-    }
-    finally {
-        await safeClose(connection.close);
-    }
-}

package/dist/mcp/commands/list.js

@@ -1,94 +0,0 @@
-/**
- * List command - List all servers and their tools
- */
-import { debug, getConcurrencyLimit, getConnection, safeClose, } from '../client.js';
-import { getServerConfig, listServerNames, loadConfig, } from '../config.js';
-import { ErrorCode } from '../errors.js';
-import { formatServerList } from '../output.js';
-/**
- * Process items with limited concurrency, preserving order
- * Uses a worker pool pattern where each worker grabs the next item from a shared index
- */
-async function processWithConcurrency(items, processor, maxConcurrency) {
-    const results = new Array(items.length);
-    let currentIndex = 0;
-    async function worker() {
-        while (currentIndex < items.length) {
-            const index = currentIndex++;
-            results[index] = await processor(items[index], index);
-        }
-    }
-    // Start workers up to concurrency limit
-    const workers = Array.from({ length: Math.min(maxConcurrency, items.length) }, () => worker());
-    await Promise.all(workers);
-    return results;
-}
-/**
- * Fetch tools from a single server (uses daemon if enabled)
- */
-async function fetchServerTools(serverName, config) {
-    let connection = null;
-    try {
-        const serverConfig = getServerConfig(config, serverName);
-        connection = await getConnection(serverName, serverConfig);
-        const tools = await connection.listTools();
-        const instructions = await connection.getInstructions();
-        debug(`${serverName}: loaded ${tools.length} tools`);
-        return { name: serverName, tools, instructions };
-    }
-    catch (error) {
-        const errorMsg = error.message;
-        debug(`${serverName}: connection failed - ${errorMsg}`);
-        return {
-            name: serverName,
-            tools: [],
-            error: errorMsg,
-        };
-    }
-    finally {
-        if (connection) {
-            await safeClose(connection.close);
-        }
-    }
-}
-/**
- * Execute the list command
- */
-export async function listCommand(options) {
-    let config;
-    try {
-        config = await loadConfig(options.configPath);
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(ErrorCode.CLIENT_ERROR);
-    }
-    const serverNames = listServerNames(config);
-    if (serverNames.length === 0) {
-        console.log('No MCP servers configured.');
-        console.log('Next: pibo mcp config help');
-        return;
-    }
-    const concurrencyLimit = getConcurrencyLimit();
-    debug(`Processing ${serverNames.length} servers with concurrency ${concurrencyLimit}`);
-    // Process servers in parallel with concurrency limit
-    const servers = await processWithConcurrency(serverNames, (name) => fetchServerTools(name, config), concurrencyLimit);
-    // Sort by name to ensure consistent output order
-    servers.sort((a, b) => a.name.localeCompare(b.name));
-    // Convert errors to tool-like display for human output
-    const displayServers = servers.map((s) => ({
-        name: s.name,
-        instructions: s.instructions,
-        tools: s.error
-            ? [
-                {
-                    name: `<error: ${s.error}>`,
-                    description: undefined,
-                    inputSchema: {},
-                },
-            ]
-            : s.tools,
-    }));
-    // Human-readable output
-    console.log(formatServerList(displayServers, options.withDescriptions));
-}

package/dist/mcp/config-command.js

@@ -1,217 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { ensureConfigExists, findConfigPath, getPreferredConfigPath, } from './config.js';
-import { ErrorCode, formatCliError } from './errors.js';
-import { setMcpServerDescription } from './agent-context.js';
-const EXAMPLE_CONFIG = {
-    mcpServers: {
-        filesystem: {
-            command: 'npx',
-            args: ['-y', '@modelcontextprotocol/server-filesystem', '.'],
-        },
-        deepwiki: {
-            url: 'https://mcp.deepwiki.com/mcp',
-        },
-    },
-};
-export function printConfigHelp() {
-    console.log(`
-MCP server configuration
-
-Commands:
-  pibo mcp config init                         Create mcp_servers.json if missing
-  pibo mcp config path                         Print the config path that will be used
-  pibo mcp config paths                        Show config path lookup order
-  pibo mcp config show                         Print the current config JSON
-  pibo mcp config add <name> <json>            Add or replace one server
-  pibo mcp config describe <name> "<text>"     Add or update an agent-facing description
-  pibo mcp config remove <name>                Remove one server
-  pibo mcp config schema                       Show server JSON schema and examples
-  pibo mcp config help                         Show this help
-`);
-}
-export function printConfigPaths() {
-    console.log(`
-MCP config lookup order:
-  1. -c/--config <path>
-  2. MCP_CONFIG_PATH
-  3. ./mcp_servers.json
-  4. ~/.mcp_servers.json
-  5. ~/.config/mcp/mcp_servers.json
-`);
-}
-export function printConfigSchema() {
-    console.log(`
-Server schema:
-  Stdio server:
-    {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
-      "env": { "TOKEN": "\${TOKEN}" },
-      "cwd": ".",
-      "allowedTools": ["read_*"],
-      "disabledTools": ["write_*"],
-      "pibo": {
-        "description": "Access project files through the configured filesystem MCP server.",
-        "descriptionSource": "user"
-      }
-    }
-
-  HTTP server:
-    {
-      "url": "https://example.com/mcp",
-      "headers": { "Authorization": "Bearer \${TOKEN}" },
-      "allowedTools": ["search_*"],
-      "disabledTools": ["dangerous_*"]
-    }
-
-Full example:
-${JSON.stringify(EXAMPLE_CONFIG, null, 2)}
-
-Examples:
-  pibo mcp config init
-  pibo mcp config add filesystem '{"command":"npx","args":["-y","@modelcontextprotocol/server-filesystem","."]}'
-  pibo mcp config add deepwiki '{"url":"https://mcp.deepwiki.com/mcp"}'
-  pibo mcp config describe filesystem "Access project files through the configured filesystem MCP server."
-  pibo mcp config remove filesystem
-`);
-}
-async function readRawConfig(path) {
-    const content = await readFile(path, 'utf-8');
-    const parsed = JSON.parse(content);
-    if (!parsed ||
-        typeof parsed !== 'object' ||
-        !('mcpServers' in parsed) ||
-        typeof parsed.mcpServers !== 'object') {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'CONFIG_MISSING_FIELD',
-            message: 'Config file missing required "mcpServers" object',
-            details: `File: ${path}`,
-            suggestion: 'Run pibo mcp config help to see the expected JSON shape',
-        }));
-    }
-    return parsed;
-}
-async function writeRawConfig(path, config) {
-    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
-}
-function parseServerConfig(input) {
-    let parsed;
-    try {
-        parsed = JSON.parse(input);
-    }
-    catch (error) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'CONFIG_INVALID_SERVER_JSON',
-            message: 'Server config must be valid JSON',
-            details: error.message,
-            suggestion: 'Example: pibo mcp config add filesystem \'{"command":"npx","args":["-y","@modelcontextprotocol/server-filesystem","."]}\'',
-        }));
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'CONFIG_INVALID_SERVER',
-            message: 'Server config must be a JSON object',
-        }));
-    }
-    const config = parsed;
-    const hasCommand = typeof config.command === 'string';
-    const hasUrl = typeof config.url === 'string';
-    if (!hasCommand && !hasUrl) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'CONFIG_INVALID_SERVER',
-            message: 'Server config must include either "command" or "url"',
-            suggestion: 'Use {"command":"..."} for stdio servers or {"url":"https://..."} for HTTP servers',
-        }));
-    }
-    if (hasCommand && hasUrl) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'CONFIG_INVALID_SERVER',
-            message: 'Server config cannot include both "command" and "url"',
-            suggestion: 'Remove one of the two fields',
-        }));
-    }
-    return config;
-}
-export async function configCommand(options) {
-    if (options.action === 'help') {
-        printConfigHelp();
-        return;
-    }
-    if (options.action === 'schema') {
-        printConfigSchema();
-        return;
-    }
-    if (options.action === 'paths') {
-        printConfigPaths();
-        return;
-    }
-    if (options.action === 'path') {
-        console.log(findConfigPath(options.configPath) ?? getPreferredConfigPath(options.configPath));
-        return;
-    }
-    if (options.action === 'init') {
-        const existingPath = findConfigPath(options.configPath);
-        const path = await ensureConfigExists(options.configPath);
-        console.log(existingPath ? `MCP config ready: ${path}` : `Created MCP config: ${path}`);
-        return;
-    }
-    if (options.action === 'describe') {
-        if (!options.name || !options.description) {
-            throw new Error(formatCliError({
-                code: ErrorCode.CLIENT_ERROR,
-                type: 'MISSING_ARGUMENT',
-                message: 'config describe requires <name> and <description>',
-                suggestion: 'Example: pibo mcp config describe filesystem "Access project files through MCP."',
-            }));
-        }
-        await setMcpServerDescription(options.name, options.description, options.configPath);
-        console.log(`Updated MCP server "${options.name}" description`);
-        return;
-    }
-    const path = await ensureConfigExists(options.configPath);
-    const config = await readRawConfig(path);
-    if (options.action === 'show') {
-        console.log(JSON.stringify(config, null, 2));
-        return;
-    }
-    if (options.action === 'add') {
-        if (!options.name || !options.serverJson) {
-            throw new Error(formatCliError({
-                code: ErrorCode.CLIENT_ERROR,
-                type: 'MISSING_ARGUMENT',
-                message: 'config add requires <name> and <json>',
-                suggestion: 'Example: pibo mcp config add filesystem \'{"command":"npx","args":["-y","@modelcontextprotocol/server-filesystem","."]}\'',
-            }));
-        }
-        config.mcpServers[options.name] = parseServerConfig(options.serverJson);
-        await writeRawConfig(path, config);
-        console.log(`Added MCP server "${options.name}" to ${path}`);
-        return;
-    }
-    if (options.action === 'remove') {
-        if (!options.name) {
-            throw new Error(formatCliError({
-                code: ErrorCode.CLIENT_ERROR,
-                type: 'MISSING_ARGUMENT',
-                message: 'config remove requires <name>',
-                suggestion: 'Example: pibo mcp config remove filesystem',
-            }));
-        }
-        if (!(options.name in config.mcpServers)) {
-            throw new Error(formatCliError({
-                code: ErrorCode.CLIENT_ERROR,
-                type: 'SERVER_NOT_FOUND',
-                message: `Server "${options.name}" not found in config`,
-                details: `Available servers: ${Object.keys(config.mcpServers).join(', ') || '(none)'}`,
-            }));
-        }
-        delete config.mcpServers[options.name];
-        await writeRawConfig(path, config);
-        console.log(`Removed MCP server "${options.name}" from ${path}`);
-    }
-}