tarsk 0.4.4 → 0.4.6

package/dist/features/mcp/mcp.config.d.ts

@@ -1,27 +0,0 @@
-/**
- * MCP Configuration loading utilities
- *
- * This file handles loading and parsing MCP configuration files from
- * both .agents/mcp.json and mcp.json locations.
- */
-import type { MCPConfig } from "@tarsk/shared";
-/**
- * Load MCP configuration from a project directory
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to MCP configuration or null if not found
- */
-export declare function loadMCPConfig(projectPath: string): Promise<MCPConfig | null>;
-/**
- * Get the modification time of the MCP configuration file
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to modification date or null if no config found
- */
-export declare function getMCPConfigModificationTime(projectPath: string): Promise<Date | null>;
-/**
- * Check if MCP configuration has changed since last load
- * @param projectPath - Path to the project directory
- * @param lastModified - Last known modification time
- * @returns Promise resolving to true if configuration needs reloading
- */
-export declare function hasMCPConfigChanged(projectPath: string, lastModified: Date | null): Promise<boolean>;
-//# sourceMappingURL=mcp.config.d.ts.map

package/dist/features/mcp/mcp.config.js

@@ -1,148 +0,0 @@
-/**
- * MCP Configuration loading utilities
- *
- * This file handles loading and parsing MCP configuration files from
- * both .agents/mcp.json and mcp.json locations.
- */
-import { readFile, stat, access } from "fs/promises";
-import { join } from "path";
-/**
- * Possible MCP configuration file locations in order of preference
- */
-const MCP_CONFIG_PATHS = [".agents/mcp.json", "mcp.json"];
-/**
- * Load MCP configuration from a project directory
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to MCP configuration or null if not found
- */
-export async function loadMCPConfig(projectPath) {
-    for (const configPath of MCP_CONFIG_PATHS) {
-        const fullPath = join(projectPath, configPath);
-        try {
-            // Check if file exists and is accessible
-            await access(fullPath);
-            // Get file stats for modification time
-            const fileStats = await stat(fullPath);
-            // Read and parse the configuration file
-            const fileContent = await readFile(fullPath, "utf-8");
-            const rawConfig = JSON.parse(fileContent);
-            // Normalize configuration to use 'servers' key (supports both 'servers' and 'mcpServers')
-            const serversData = rawConfig.servers ||
-                rawConfig.mcpServers ||
-                {};
-            const config = {
-                servers: serversData,
-            };
-            // Validate configuration structure
-            if (!isValidMCPConfig(config)) {
-                console.warn(`[MCP] Invalid configuration structure in ${configPath}`);
-                continue;
-            }
-            console.log(`[MCP] Loaded configuration from ${configPath} (${fileStats.mtime.toISOString()})`);
-            return config;
-        }
-        catch (error) {
-            if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
-                console.warn(`[MCP] Error loading configuration from ${configPath}:`, error.message);
-            }
-            // File doesn't exist or other error, try next location
-            continue;
-        }
-    }
-    // No valid configuration found
-    return null;
-}
-/**
- * Get the modification time of the MCP configuration file
- * @param projectPath - Path to the project directory
- * @returns Promise resolving to modification date or null if no config found
- */
-export async function getMCPConfigModificationTime(projectPath) {
-    for (const configPath of MCP_CONFIG_PATHS) {
-        const fullPath = join(projectPath, configPath);
-        try {
-            await access(fullPath);
-            const fileStats = await stat(fullPath);
-            return fileStats.mtime;
-        }
-        catch {
-            // File doesn't exist or not accessible, try next location
-            continue;
-        }
-    }
-    return null;
-}
-/**
- * Validate MCP configuration structure
- * @param config - Configuration to validate
- * @returns True if configuration is valid
- */
-function isValidMCPConfig(config) {
-    if (!config || typeof config !== "object") {
-        return false;
-    }
-    const cfg = config;
-    // Must have servers object (supports both 'servers' and 'mcpServers' keys)
-    const serversKey = cfg.servers ? "servers" : cfg.mcpServers ? "mcpServers" : null;
-    if (!serversKey || typeof cfg[serversKey] !== "object") {
-        return false;
-    }
-    const servers = cfg[serversKey];
-    // Each server must have required properties
-    for (const [serverName, serverConfig] of Object.entries(servers)) {
-        if (!serverConfig || typeof serverConfig !== "object") {
-            console.warn(`[MCP] Invalid server configuration for ${serverName}`);
-            return false;
-        }
-        const server = serverConfig;
-        // Required properties
-        if (!server.command || typeof server.command !== "string") {
-            console.warn(`[MCP] Server ${serverName} missing required 'command' property`);
-            return false;
-        }
-        if (!server.args || !Array.isArray(server.args)) {
-            console.warn(`[MCP] Server ${serverName} missing required 'args' array`);
-            return false;
-        }
-        // Validate args are strings
-        if (!server.args.every((arg) => typeof arg === "string")) {
-            console.warn(`[MCP] Server ${serverName} has non-string arguments`);
-            return false;
-        }
-        // Optional env validation
-        if (server.env && typeof server.env === "object") {
-            const env = server.env;
-            for (const [key, value] of Object.entries(env)) {
-                if (typeof value !== "string") {
-                    console.warn(`[MCP] Server ${serverName} has non-string environment variable ${key}`);
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-}
-/**
- * Check if MCP configuration has changed since last load
- * @param projectPath - Path to the project directory
- * @param lastModified - Last known modification time
- * @returns Promise resolving to true if configuration needs reloading
- */
-export async function hasMCPConfigChanged(projectPath, lastModified) {
-    const currentModified = await getMCPConfigModificationTime(projectPath);
-    if (!currentModified && !lastModified) {
-        // No config then and no config now
-        return false;
-    }
-    if (!currentModified && lastModified) {
-        // Config was deleted
-        return true;
-    }
-    if (currentModified && !lastModified) {
-        // Config was created
-        return true;
-    }
-    // Compare modification times
-    return currentModified.getTime() !== lastModified.getTime();
-}
-//# sourceMappingURL=mcp.config.js.map

package/dist/features/mcp/mcp.manager.d.ts

@@ -1,61 +0,0 @@
-/**
- * MCP Manager implementation
- *
- * This file contains the main MCPManager implementation that handles
- * MCP server lifecycle, configuration loading, and tool management.
- */
-import type { MCPConfig, MCPTool } from "@tarsk/shared";
-import type { MCPManager, MCPToolWrapper } from "./mcp.types.js";
-/**
- * MCP Manager implementation
- */
-export declare class MCPManagerImpl implements MCPManager {
-    private configCache;
-    private serverInstances;
-    private toolWrappers;
-    /**
-     * Load MCP configuration from file
-     */
-    loadConfig(projectPath: string): Promise<MCPConfig | null>;
-    /**
-     * Get all available MCP tools for a project
-     */
-    getTools(projectPath: string): Promise<MCPTool[]>;
-    /**
-     * Execute an MCP tool
-     */
-    executeTool(toolName: string, args: Record<string, unknown>, projectPath: string): Promise<unknown>;
-    /**
-     * Check if MCP configuration needs reloading
-     */
-    needsReload(projectPath: string): Promise<boolean>;
-    /**
-     * Clear cached configuration for a project
-     */
-    clearCache(projectPath: string): void;
-    /**
-     * Get tools from a specific MCP server
-     */
-    private getServerTools;
-    /**
-     * Get or create a server instance
-     */
-    private getOrCreateServerInstance;
-    /**
-     * Create a new server instance and connect to it
-     */
-    private createServerInstance;
-    /**
-     * Execute a tool on a specific server
-     */
-    private executeServerTool;
-    /**
-     * Create Pi Agent compatible tool wrappers for MCP tools
-     */
-    createToolWrappers(projectPath: string): Promise<MCPToolWrapper[]>;
-    /**
-     * Create a single tool wrapper
-     */
-    private createToolWrapper;
-}
-//# sourceMappingURL=mcp.manager.d.ts.map

package/dist/features/mcp/mcp.manager.js

@@ -1,254 +0,0 @@
-/**
- * MCP Manager implementation
- *
- * This file contains the main MCPManager implementation that handles
- * MCP server lifecycle, configuration loading, and tool management.
- */
-import { loadMCPConfig, hasMCPConfigChanged, getMCPConfigModificationTime } from "./mcp.config.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-/**
- * MCP Manager implementation
- */
-export class MCPManagerImpl {
-    configCache = new Map();
-    serverInstances = new Map();
-    toolWrappers = new Map();
-    /**
-     * Load MCP configuration from file
-     */
-    async loadConfig(projectPath) {
-        const cached = this.configCache.get(projectPath);
-        const currentModified = await getMCPConfigModificationTime(projectPath);
-        // Return cached config if it hasn't changed
-        if (cached && cached.lastModified.getTime() === currentModified?.getTime()) {
-            return cached.config;
-        }
-        // Load fresh configuration
-        const config = await loadMCPConfig(projectPath);
-        if (config && currentModified) {
-            this.configCache.set(projectPath, { config, lastModified: currentModified });
-        }
-        return config;
-    }
-    /**
-     * Get all available MCP tools for a project
-     */
-    async getTools(projectPath) {
-        const config = await this.loadConfig(projectPath);
-        if (!config) {
-            return [];
-        }
-        const allTools = [];
-        for (const [serverName, serverConfig] of Object.entries(config.servers)) {
-            const serverTools = await this.getServerTools(serverName, serverConfig, projectPath);
-            allTools.push(...serverTools);
-        }
-        return allTools;
-    }
-    /**
-     * Execute an MCP tool
-     */
-    async executeTool(toolName, args, projectPath) {
-        // Find the server that provides this tool
-        const config = await this.loadConfig(projectPath);
-        if (!config) {
-            throw new Error(`No MCP configuration found for project: ${projectPath}`);
-        }
-        for (const [serverName, serverConfig] of Object.entries(config.servers)) {
-            const tools = await this.getServerTools(serverName, serverConfig, projectPath);
-            const tool = tools.find((t) => t.name === toolName);
-            if (tool) {
-                return this.executeServerTool(serverName, serverConfig, toolName, args, projectPath);
-            }
-        }
-        throw new Error(`MCP tool not found: ${toolName}`);
-    }
-    /**
-     * Check if MCP configuration needs reloading
-     */
-    async needsReload(projectPath) {
-        const cached = this.configCache.get(projectPath);
-        return hasMCPConfigChanged(projectPath, cached?.lastModified ?? null);
-    }
-    /**
-     * Clear cached configuration for a project
-     */
-    clearCache(projectPath) {
-        this.configCache.delete(projectPath);
-        // Clean up server instances for this project
-        const instancesToCleanup = [];
-        for (const [key, instance] of this.serverInstances.entries()) {
-            if (key.startsWith(`${projectPath}:`)) {
-                instancesToCleanup.push(key);
-                // Close MCP client connection if it exists
-                if (instance.client) {
-                    try {
-                        void instance.client.close();
-                        console.log(`[MCP] Closed connection for server: ${key}`);
-                    }
-                    catch (error) {
-                        console.warn(`[MCP] Failed to close connection for server ${key}:`, error);
-                    }
-                }
-            }
-        }
-        instancesToCleanup.forEach((key) => this.serverInstances.delete(key));
-        this.toolWrappers.delete(projectPath);
-    }
-    /**
-     * Get tools from a specific MCP server
-     */
-    async getServerTools(serverName, serverConfig, projectPath) {
-        const instance = await this.getOrCreateServerInstance(serverName, serverConfig, projectPath);
-        if (instance.state !== "connected") {
-            console.warn(`[MCP] Server ${serverName} not connected (state: ${instance.state})`);
-            return [];
-        }
-        return instance.tools;
-    }
-    /**
-     * Get or create a server instance
-     */
-    async getOrCreateServerInstance(serverName, serverConfig, projectPath) {
-        const instanceKey = `${projectPath}:${serverName}`;
-        let instance = this.serverInstances.get(instanceKey);
-        if (!instance || instance.state === "error") {
-            instance = await this.createServerInstance(serverName, serverConfig);
-            this.serverInstances.set(instanceKey, instance);
-        }
-        return instance;
-    }
-    /**
-     * Create a new server instance and connect to it
-     */
-    async createServerInstance(serverName, serverConfig) {
-        const instance = {
-            config: serverConfig,
-            state: "connecting",
-            tools: [],
-        };
-        try {
-            console.log(`[MCP] Connecting to server ${serverName} with command: ${serverConfig.command} ${serverConfig.args.join(" ")}`);
-            // Create stdio transport for the MCP server
-            const transport = new StdioClientTransport({
-                command: serverConfig.command,
-                args: serverConfig.args,
-                env: serverConfig.env,
-            });
-            // Create MCP client
-            const client = new Client({
-                name: "tarsk-cli",
-                version: "0.4.0",
-            }, {
-                capabilities: {},
-            });
-            // Connect to the server
-            await client.connect(transport);
-            console.log(`[MCP] Connected to server ${serverName}`);
-            // List available tools
-            const toolsResponse = await client.listTools();
-            // Convert MCP tools to our internal format
-            instance.tools = toolsResponse.tools.map((tool) => ({
-                name: tool.name,
-                description: tool.description ?? "",
-                inputSchema: tool.inputSchema,
-                serverName,
-            }));
-            instance.client = client;
-            instance.state = "connected";
-            console.log(`[MCP] Connected to server ${serverName}, found ${instance.tools.length} tools`);
-        }
-        catch (error) {
-            instance.state = "error";
-            instance.error = error instanceof Error ? error.message : String(error);
-            // Gracefully handle connection failures without alarming error logs
-            console.log(`[MCP] Unable to connect to server ${serverName}: ${instance.error}`);
-        }
-        return instance;
-    }
-    /**
-     * Execute a tool on a specific server
-     */
-    async executeServerTool(serverName, _serverConfig, toolName, args, _projectPath) {
-        console.log(`[MCP] Executing tool ${toolName} on server ${serverName} with args:`, args);
-        const instanceKey = `${_projectPath}:${serverName}`;
-        const instance = this.serverInstances.get(instanceKey);
-        if (!instance?.client || instance.state !== "connected") {
-            throw new Error(`MCP server ${serverName} is not connected`);
-        }
-        try {
-            // Execute the tool using the MCP client
-            const result = await instance.client.callTool({
-                name: toolName,
-                arguments: args,
-            });
-            console.log(`[MCP] Tool ${toolName} executed successfully on server ${serverName}`);
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`[MCP] Failed to execute tool ${toolName} on server ${serverName}:`, errorMessage);
-            throw new Error(`MCP tool execution failed: ${errorMessage}`);
-        }
-    }
-    /**
-     * Create Pi Agent compatible tool wrappers for MCP tools
-     */
-    async createToolWrappers(projectPath) {
-        const cacheKey = projectPath;
-        const cached = this.toolWrappers.get(cacheKey);
-        // Return cached wrappers if config hasn't changed
-        if (cached && !(await this.needsReload(projectPath))) {
-            return cached;
-        }
-        const mcpTools = await this.getTools(projectPath);
-        const wrappers = [];
-        for (const mcpTool of mcpTools) {
-            const wrapper = this.createToolWrapper(mcpTool, projectPath);
-            wrappers.push(wrapper);
-        }
-        this.toolWrappers.set(cacheKey, wrappers);
-        return wrappers;
-    }
-    /**
-     * Create a single tool wrapper
-     */
-    createToolWrapper(mcpTool, projectPath) {
-        return {
-            name: mcpTool.name,
-            description: mcpTool.description,
-            parameters: mcpTool.inputSchema,
-            label: `${mcpTool.serverName}: ${mcpTool.name}`,
-            execute: async (_toolCallId, params) => {
-                try {
-                    const result = await this.executeTool(mcpTool.name, params, projectPath);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: typeof result === "string" ? result : JSON.stringify(result, null, 2),
-                            },
-                        ],
-                        details: result,
-                    };
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Error executing MCP tool ${mcpTool.name}: ${errorMessage}`,
-                            },
-                        ],
-                        details: { error: errorMessage },
-                    };
-                }
-            },
-            serverName: mcpTool.serverName,
-            mcpTool,
-        };
-    }
-}
-//# sourceMappingURL=mcp.manager.js.map

package/dist/features/mcp/mcp.popular.json

@@ -1,103 +0,0 @@
-[
-    {
-        "id": "context7",
-        "name": "Context7",
-        "description": "Fetches up-to-date, version-specific library documentation and code examples directly into your prompt",
-        "command": "npx",
-        "args": ["-y", "@upstash/context7-mcp@latest"],
-        "env": {},
-        "category": "Documentation"
-    },
-    {
-        "id": "playwright",
-        "name": "Playwright",
-        "description": "Browser automation via Microsoft Playwright — interact with web pages using accessibility snapshots without screenshots",
-        "command": "npx",
-        "args": ["-y", "@playwright/mcp@latest"],
-        "env": {},
-        "category": "Browser"
-    },
-    {
-        "id": "github",
-        "name": "GitHub",
-        "description": "Search repositories, manage issues, create pull requests, and interact with GitHub APIs",
-        "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-github"],
-        "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "" },
-        "category": "Development"
-    },
-    {
-        "id": "sequential-thinking",
-        "name": "Sequential Thinking",
-        "description": "Enhanced reasoning through structured sequential thought processes",
-        "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
-        "env": {},
-        "category": "Utilities"
-    },
-    {
-        "id": "mongodb",
-        "name": "MongoDB",
-        "description": "Query MongoDB databases and Atlas clusters with natural language, schema inspection, and Atlas management",
-        "command": "npx",
-        "args": ["-y", "@mongodb-js/mongodb-mcp-server@latest"],
-        "env": { "MDB_MCP_CONNECTION_STRING": "" },
-        "category": "Database"
-    },
-    {
-        "id": "azure",
-        "name": "Azure",
-        "description": "Access Azure resources including storage, databases, and services via your Azure account",
-        "command": "npx",
-        "args": ["-y", "@azure/mcp@latest", "server", "start"],
-        "env": { "AZURE_TENANT_ID": "", "AZURE_CLIENT_ID": "", "AZURE_CLIENT_SECRET": "" },
-        "category": "Cloud"
-    },
-    {
-        "id": "cloudflare",
-        "name": "Cloudflare",
-        "description": "Deploy Workers, query D1 databases, manage KV, and interact with your Cloudflare account",
-        "command": "npx",
-        "args": ["-y", "@cloudflare/mcp-server-cloudflare@latest"],
-        "env": { "CLOUDFLARE_API_TOKEN": "", "CLOUDFLARE_ACCOUNT_ID": "" },
-        "category": "Cloud"
-    },
-    {
-        "id": "supabase",
-        "name": "Supabase",
-        "description": "Manage Supabase projects, run queries, handle migrations, and interact with your database",
-        "command": "npx",
-        "args": ["-y", "@supabase/mcp-server-supabase@latest"],
-        "env": { "SUPABASE_ACCESS_TOKEN": "" },
-        "category": "Database"
-    },
-    {
-        "id": "notion",
-        "name": "Notion",
-        "description": "Read and write Notion pages, databases, and blocks using your integration token",
-        "command": "npx",
-        "args": ["-y", "@notionhq/notion-mcp-server@latest"],
-        "env": {
-            "OPENAPI_MCP_HEADERS": "{\"Authorization\": \"Bearer ntn_YOUR_TOKEN\", \"Notion-Version\": \"2022-06-28\"}"
-        },
-        "category": "Productivity"
-    },
-    {
-        "id": "postgres",
-        "name": "PostgreSQL",
-        "description": "Connect to and query PostgreSQL databases with full SQL support",
-        "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"],
-        "env": {},
-        "category": "Database"
-    },
-    {
-        "id": "chrome-devtools",
-        "name": "Chrome DevTools",
-        "description": "Control and inspect a live Chrome browser via the Chrome DevTools Protocol — requires Chrome launched with --remote-debugging-port=9222",
-        "command": "npx",
-        "args": ["-y", "chrome-devtools-mcp@latest", "--browser-url=http://127.0.0.1:9222"],
-        "env": {},
-        "category": "Browser"
-    }
-]

package/dist/features/mcp/mcp.routes.d.ts

@@ -1,13 +0,0 @@
-/**
- * MCP routes for the REST API
- *
- * Handles all MCP-related operations:
- * - GET /api/mcp/config?projectPath=... - Get current MCP config for a project
- * - PUT /api/mcp/config - Save or update a server in the MCP config
- * - DELETE /api/mcp/config/:serverName?projectPath=... - Remove a server from MCP config
- * - GET /api/mcp/popular - List popular MCP servers
- * - GET /api/mcp/search?q=...&limit=... - Search MCP registry
- */
-import { Hono } from "hono";
-export declare function createMCPRoutes(): Hono;
-//# sourceMappingURL=mcp.routes.d.ts.map