@pasko70/pibo 1.9.9 → 1.9.10

package/dist/mcp/commands/grep.js

@@ -0,0 +1,145 @@
+/**
+ * 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

@@ -0,0 +1,83 @@
+/**
+ * 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

@@ -0,0 +1,94 @@
+/**
+ * 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

@@ -0,0 +1,217 @@
+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}`);
+    }
+}