codemaxxing 0.3.0 → 0.3.1

package/dist/agent.d.ts

@@ -1,3 +1,4 @@
+import { type ConnectedServer } from "./utils/mcp.js";
 import type { ProviderConfig } from "./config.js";
 export interface AgentOptions {
     provider: ProviderConfig;
@@ -13,6 +14,7 @@ export interface AgentOptions {
     onContextCompressed?: (oldTokens: number, newTokens: number) => void;
     onArchitectPlan?: (plan: string) => void;
     onLintResult?: (file: string, errors: string) => void;
+    onMCPStatus?: (server: string, status: string) => void;
     contextCompressionThreshold?: number;
 }
 export declare class CodingAgent {
@@ -41,6 +43,7 @@ export declare class CodingAgent {
     private architectModel;
     private autoLintEnabled;
     private detectedLinter;
+    private mcpServers;
     constructor(options: AgentOptions);
     /**
      * Initialize the agent — call this after constructor to build async context
@@ -124,5 +127,9 @@ export declare class CodingAgent {
      * Run the architect model to generate a plan, then feed to editor model
      */
     private architectChat;
+    getMCPServerCount(): number;
+    getMCPServers(): ConnectedServer[];
+    disconnectMCP(): Promise<void>;
+    reconnectMCP(): Promise<void>;
     reset(): void;
 }

package/dist/agent.js

@@ -6,6 +6,7 @@ import { buildProjectContext, getSystemPrompt, loadProjectRules } from "./utils/
 import { isGitRepo, autoCommit } from "./utils/git.js";
 import { buildSkillPrompts, getActiveSkillCount } from "./utils/skills.js";
 import { createSession, saveMessage, updateTokenEstimate, updateSessionCost, loadMessages } from "./utils/sessions.js";
+import { loadMCPConfig, connectToServers, disconnectAll, getAllMCPTools, parseMCPToolName, callMCPTool } from "./utils/mcp.js";
 // Tools that can modify your project — require approval
 const DANGEROUS_TOOLS = new Set(["write_file", "run_command"]);
 // Cost per 1M tokens (input/output) for common models
@@ -78,6 +79,7 @@ export class CodingAgent {
     architectModel = null;
     autoLintEnabled = true;
     detectedLinter = null;
+    mcpServers = [];
     constructor(options) {
         this.options = options;
         this.providerType = options.provider.type || "openai";
@@ -113,6 +115,15 @@ export class CodingAgent {
         this.systemPrompt = await getSystemPrompt(context, skillPrompts, rules?.content ?? "");
         // Detect project linter
         this.detectedLinter = detectLinter(this.cwd);
+        // Connect to MCP servers
+        const mcpConfig = loadMCPConfig(this.cwd);
+        if (Object.keys(mcpConfig.mcpServers).length > 0) {
+            this.mcpServers = await connectToServers(mcpConfig, this.options.onMCPStatus);
+            if (this.mcpServers.length > 0) {
+                const mcpTools = getAllMCPTools(this.mcpServers);
+                this.tools = [...FILE_TOOLS, ...mcpTools];
+            }
+        }
         this.messages = [
             { role: "system", content: this.systemPrompt },
         ];
@@ -305,7 +316,15 @@ export class CodingAgent {
                         }
                     }
                 }
-                const result = await executeTool(toolCall.name, args, this.cwd);
+                // Route to MCP or built-in tool
+                const mcpParsed = parseMCPToolName(toolCall.name);
+                let result;
+                if (mcpParsed) {
+                    result = await callMCPTool(mcpParsed.serverName, mcpParsed.toolName, args);
+                }
+                else {
+                    result = await executeTool(toolCall.name, args, this.cwd);
+                }
                 this.options.onToolResult?.(toolCall.name, result);
                 // Auto-commit after successful write_file (only if enabled)
                 if (this.gitEnabled && this.autoCommitEnabled && toolCall.name === "write_file" && result.startsWith("✅")) {
@@ -502,7 +521,15 @@ export class CodingAgent {
                         }
                     }
                 }
-                const result = await executeTool(toolCall.name, args, this.cwd);
+                // Route to MCP or built-in tool
+                const mcpParsed = parseMCPToolName(toolCall.name);
+                let result;
+                if (mcpParsed) {
+                    result = await callMCPTool(mcpParsed.serverName, mcpParsed.toolName, args);
+                }
+                else {
+                    result = await executeTool(toolCall.name, args, this.cwd);
+                }
                 this.options.onToolResult?.(toolCall.name, result);
                 // Auto-commit after successful write_file
                 if (this.gitEnabled && this.autoCommitEnabled && toolCall.name === "write_file" && result.startsWith("✅")) {
@@ -738,6 +765,28 @@ export class CodingAgent {
         const editorPrompt = `## Architect Plan\n${plan}\n\n## Original Request\n${userMessage}\n\nExecute the plan above. Follow it step by step.`;
         return this.chat(editorPrompt);
     }
+    getMCPServerCount() {
+        return this.mcpServers.length;
+    }
+    getMCPServers() {
+        return this.mcpServers;
+    }
+    async disconnectMCP() {
+        await disconnectAll();
+        this.mcpServers = [];
+        this.tools = FILE_TOOLS;
+    }
+    async reconnectMCP() {
+        await this.disconnectMCP();
+        const mcpConfig = loadMCPConfig(this.cwd);
+        if (Object.keys(mcpConfig.mcpServers).length > 0) {
+            this.mcpServers = await connectToServers(mcpConfig, this.options.onMCPStatus);
+            if (this.mcpServers.length > 0) {
+                const mcpTools = getAllMCPTools(this.mcpServers);
+                this.tools = [...FILE_TOOLS, ...mcpTools];
+            }
+        }
+    }
     reset() {
         const systemMsg = this.messages[0];
         this.messages = [systemMsg];

package/dist/exec.js

@@ -6,6 +6,7 @@
  */
 import { CodingAgent } from "./agent.js";
 import { loadConfig, applyOverrides, detectLocalProvider } from "./config.js";
+import { disconnectAll } from "./utils/mcp.js";
 function parseExecArgs(argv) {
     const args = {
         prompt: "",
@@ -124,9 +125,16 @@ export async function runExec(argv) {
             process.stderr.write(`⚠ Denied ${name} (use --auto-approve to allow)\n`);
             return "no";
         },
+        onMCPStatus: (server, status) => {
+            process.stderr.write(`MCP ${server}: ${status}\n`);
+        },
     });
     try {
         await agent.init();
+        const mcpCount = agent.getMCPServerCount();
+        if (mcpCount > 0) {
+            process.stderr.write(`MCP: ${mcpCount} server${mcpCount > 1 ? "s" : ""} connected\n`);
+        }
         await agent.send(args.prompt);
         if (!args.json) {
             // Ensure newline at end of output
@@ -142,9 +150,11 @@ export async function runExec(argv) {
             };
             process.stdout.write(JSON.stringify(output, null, 2) + "\n");
         }
+        await disconnectAll();
         process.exit(hasChanges ? 0 : 2);
     }
     catch (err) {
+        await disconnectAll();
         process.stderr.write(`Error: ${err.message}\n`);
         if (args.json) {
             process.stdout.write(JSON.stringify({ error: err.message }, null, 2) + "\n");

package/dist/index.js

@@ -12,6 +12,7 @@ import { isGitRepo, getBranch, getStatus, getDiff, undoLastCommit } from "./util
 import { getTheme, listThemes, THEMES, DEFAULT_THEME } from "./themes.js";
 import { PROVIDERS, getCredentials, openRouterOAuth, anthropicSetupToken, importCodexToken, importQwenToken, copilotDeviceFlow } from "./utils/auth.js";
 import { listInstalledSkills, installSkill, removeSkill, getRegistrySkills, searchRegistry, createSkillScaffold, getActiveSkills, getActiveSkillCount } from "./utils/skills.js";
+import { listServers, addServer, removeServer, getConnectedServers } from "./utils/mcp.js";
 const VERSION = "0.1.9";
 // ── Helpers ──
 function formatTimeAgo(date) {
@@ -58,6 +59,11 @@ const SLASH_COMMANDS = [
     { cmd: "/lint", desc: "show auto-lint status" },
     { cmd: "/lint on", desc: "enable auto-lint" },
     { cmd: "/lint off", desc: "disable auto-lint" },
+    { cmd: "/mcp", desc: "show MCP servers" },
+    { cmd: "/mcp tools", desc: "list MCP tools" },
+    { cmd: "/mcp add", desc: "add MCP server" },
+    { cmd: "/mcp remove", desc: "remove MCP server" },
+    { cmd: "/mcp reconnect", desc: "reconnect MCP servers" },
     { cmd: "/quit", desc: "exit" },
 ];
 const SPINNER_FRAMES = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
@@ -246,6 +252,9 @@ function App() {
             onLintResult: (file, errors) => {
                 addMsg("info", `🔍 Lint errors in ${file}:\n${errors}`);
             },
+            onMCPStatus: (server, status) => {
+                addMsg("info", `🔌 MCP ${server}: ${status}`);
+            },
             contextCompressionThreshold: config.defaults.contextCompressionThreshold,
             onToolApproval: (name, args, diff) => {
                 return new Promise((resolve) => {
@@ -262,6 +271,12 @@ function App() {
             info.push(`📋 ${rulesSource} loaded`);
             setConnectionInfo([...info]);
         }
+        // Show MCP server count
+        const mcpCount = a.getMCPServerCount();
+        if (mcpCount > 0) {
+            info.push(`🔌 ${mcpCount} MCP server${mcpCount > 1 ? "s" : ""} connected`);
+            setConnectionInfo([...info]);
+        }
         setAgent(a);
         setModelName(provider.model);
         providerRef.current = { baseUrl: provider.baseUrl, apiKey: provider.apiKey };
@@ -367,6 +382,11 @@ function App() {
                 "  /lint      — show auto-lint status & detected linter",
                 "  /lint on   — enable auto-lint",
                 "  /lint off  — disable auto-lint",
+                "  /mcp       — show MCP servers & status",
+                "  /mcp tools — list all MCP tools",
+                "  /mcp add   — add MCP server to global config",
+                "  /mcp remove — remove MCP server",
+                "  /mcp reconnect — reconnect all MCP servers",
                 "  /quit      — exit",
             ].join("\n"));
             return;
@@ -534,6 +554,71 @@ function App() {
             addMsg("info", "🔍 Auto-lint OFF");
             return;
         }
+        // ── MCP commands (partially work without agent) ──
+        if (trimmed === "/mcp" || trimmed === "/mcp list") {
+            const servers = listServers(process.cwd());
+            if (servers.length === 0) {
+                addMsg("info", "🔌 No MCP servers configured.\n  Add one: /mcp add <name> <command> [args...]");
+            }
+            else {
+                const lines = servers.map((s) => {
+                    const status = s.connected ? `✔ connected (${s.toolCount} tools)` : "✗ not connected";
+                    return `  ${s.connected ? "●" : "○"} ${s.name} [${s.source}] — ${s.command}\n    ${status}`;
+                });
+                addMsg("info", `🔌 MCP Servers:\n${lines.join("\n")}`);
+            }
+            return;
+        }
+        if (trimmed === "/mcp tools") {
+            const servers = getConnectedServers();
+            if (servers.length === 0) {
+                addMsg("info", "🔌 No MCP servers connected.");
+                return;
+            }
+            const lines = [];
+            for (const server of servers) {
+                lines.push(`${server.name} (${server.tools.length} tools):`);
+                for (const tool of server.tools) {
+                    lines.push(`  • ${tool.name} — ${tool.description ?? "(no description)"}`);
+                }
+            }
+            addMsg("info", `🔌 MCP Tools:\n${lines.join("\n")}`);
+            return;
+        }
+        if (trimmed.startsWith("/mcp add ")) {
+            const parts = trimmed.replace("/mcp add ", "").trim().split(/\s+/);
+            if (parts.length < 2) {
+                addMsg("info", "Usage: /mcp add <name> <command> [args...]\n  Example: /mcp add github npx -y @modelcontextprotocol/server-github");
+                return;
+            }
+            const [name, command, ...cmdArgs] = parts;
+            const result = addServer(name, { command, args: cmdArgs.length > 0 ? cmdArgs : undefined });
+            addMsg(result.ok ? "info" : "error", result.ok ? `✅ ${result.message}` : `✗ ${result.message}`);
+            return;
+        }
+        if (trimmed.startsWith("/mcp remove ")) {
+            const name = trimmed.replace("/mcp remove ", "").trim();
+            if (!name) {
+                addMsg("info", "Usage: /mcp remove <name>");
+                return;
+            }
+            const result = removeServer(name);
+            addMsg(result.ok ? "info" : "error", result.ok ? `✅ ${result.message}` : `✗ ${result.message}`);
+            return;
+        }
+        if (trimmed === "/mcp reconnect") {
+            if (!agent) {
+                addMsg("info", "⚠ No agent connected. Connect first.");
+                return;
+            }
+            addMsg("info", "🔌 Reconnecting MCP servers...");
+            await agent.reconnectMCP();
+            const count = agent.getMCPServerCount();
+            addMsg("info", count > 0
+                ? `✅ ${count} MCP server${count > 1 ? "s" : ""} reconnected.`
+                : "No MCP servers connected.");
+            return;
+        }
         // Commands below require an active LLM connection
         if (!agent) {
             addMsg("info", "⚠ No LLM connected. Use /login to authenticate with a provider, or start a local server.");

package/dist/utils/mcp.d.ts

@@ -0,0 +1,55 @@
+/**
+ * MCP (Model Context Protocol) client support
+ * Connects to external MCP servers and exposes their tools to the LLM agent.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+export interface MCPServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface MCPConfig {
+    mcpServers: Record<string, MCPServerConfig>;
+}
+export interface ConnectedServer {
+    name: string;
+    client: Client;
+    transport: StdioClientTransport;
+    tools: Array<{
+        name: string;
+        description?: string;
+        inputSchema: Record<string, unknown>;
+    }>;
+}
+export declare function loadMCPConfig(cwd: string): MCPConfig;
+export declare function connectToServers(config: MCPConfig, onStatus?: (name: string, status: string) => void): Promise<ConnectedServer[]>;
+export declare function disconnectAll(): Promise<void>;
+export declare function getConnectedServers(): ConnectedServer[];
+export declare function getAllMCPTools(servers: ConnectedServer[]): ChatCompletionTool[];
+/**
+ * Parse an MCP tool call name to extract server name and tool name.
+ * Format: mcp_<serverName>_<toolName>
+ * Server names can contain hyphens but not underscores (by convention).
+ */
+export declare function parseMCPToolName(fullName: string): {
+    serverName: string;
+    toolName: string;
+} | null;
+export declare function callMCPTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<string>;
+export declare function addServer(name: string, config: MCPServerConfig): {
+    ok: boolean;
+    message: string;
+};
+export declare function removeServer(name: string): {
+    ok: boolean;
+    message: string;
+};
+export declare function listServers(cwd: string): Array<{
+    name: string;
+    source: string;
+    command: string;
+    connected: boolean;
+    toolCount: number;
+}>;

package/dist/utils/mcp.js

@@ -0,0 +1,251 @@
+/**
+ * MCP (Model Context Protocol) client support
+ * Connects to external MCP servers and exposes their tools to the LLM agent.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// ── Config paths ──
+const GLOBAL_CONFIG_DIR = join(homedir(), ".codemaxxing");
+const GLOBAL_CONFIG_PATH = join(GLOBAL_CONFIG_DIR, "mcp.json");
+function getProjectConfigPaths(cwd) {
+    return [
+        join(cwd, ".codemaxxing", "mcp.json"),
+        join(cwd, ".cursor", "mcp.json"),
+        join(cwd, "opencode.json"),
+    ];
+}
+// ── Config loading ──
+function loadConfigFile(path) {
+    try {
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function loadMCPConfig(cwd) {
+    const merged = { mcpServers: {} };
+    // Load global config first (lower priority)
+    const globalConfig = loadConfigFile(GLOBAL_CONFIG_PATH);
+    if (globalConfig) {
+        Object.assign(merged.mcpServers, globalConfig.mcpServers);
+    }
+    // Load project configs (higher priority — later overwrites earlier)
+    for (const configPath of getProjectConfigPaths(cwd)) {
+        const config = loadConfigFile(configPath);
+        if (config) {
+            Object.assign(merged.mcpServers, config.mcpServers);
+        }
+    }
+    return merged;
+}
+// ── Connection management ──
+const connectedServers = [];
+export async function connectToServers(config, onStatus) {
+    const entries = Object.entries(config.mcpServers);
+    if (entries.length === 0)
+        return [];
+    for (const [name, serverConfig] of entries) {
+        try {
+            onStatus?.(name, "connecting");
+            const transport = new StdioClientTransport({
+                command: serverConfig.command,
+                args: serverConfig.args ?? [],
+                env: { ...process.env, ...(serverConfig.env ?? {}) },
+            });
+            const client = new Client({
+                name: "codemaxxing",
+                version: "0.3.0",
+            });
+            await client.connect(transport);
+            // Fetch available tools
+            const toolsResult = await client.listTools();
+            const tools = (toolsResult.tools ?? []).map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: (t.inputSchema ?? { type: "object", properties: {} }),
+            }));
+            const server = { name, client, transport, tools };
+            connectedServers.push(server);
+            onStatus?.(name, `connected (${tools.length} tools)`);
+        }
+        catch (err) {
+            onStatus?.(name, `failed: ${err.message}`);
+        }
+    }
+    return connectedServers;
+}
+export async function disconnectAll() {
+    for (const server of connectedServers) {
+        try {
+            await server.client.close();
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    connectedServers.length = 0;
+}
+export function getConnectedServers() {
+    return connectedServers;
+}
+// ── Tool format conversion ──
+export function getAllMCPTools(servers) {
+    const tools = [];
+    for (const server of servers) {
+        for (const tool of server.tools) {
+            tools.push({
+                type: "function",
+                function: {
+                    name: `mcp_${server.name}_${tool.name}`,
+                    description: `[MCP: ${server.name}] ${tool.description ?? tool.name}`,
+                    parameters: tool.inputSchema,
+                },
+            });
+        }
+    }
+    return tools;
+}
+/**
+ * Parse an MCP tool call name to extract server name and tool name.
+ * Format: mcp_<serverName>_<toolName>
+ * Server names can contain hyphens but not underscores (by convention).
+ */
+export function parseMCPToolName(fullName) {
+    if (!fullName.startsWith("mcp_"))
+        return null;
+    const rest = fullName.slice(4); // Remove "mcp_"
+    // Find the server by matching known connected server names
+    for (const server of connectedServers) {
+        const prefix = server.name + "_";
+        if (rest.startsWith(prefix)) {
+            return { serverName: server.name, toolName: rest.slice(prefix.length) };
+        }
+    }
+    // Fallback: split on first underscore
+    const idx = rest.indexOf("_");
+    if (idx === -1)
+        return null;
+    return { serverName: rest.slice(0, idx), toolName: rest.slice(idx + 1) };
+}
+// ── Tool execution ──
+export async function callMCPTool(serverName, toolName, args) {
+    const server = connectedServers.find((s) => s.name === serverName);
+    if (!server) {
+        return `Error: MCP server "${serverName}" not found or not connected.`;
+    }
+    try {
+        const result = await server.client.callTool({ name: toolName, arguments: args });
+        // MCP tool results have a content array
+        const content = result.content;
+        if (Array.isArray(content)) {
+            return content
+                .map((c) => {
+                if (c.type === "text")
+                    return c.text;
+                if (c.type === "image")
+                    return `[image: ${c.mimeType}]`;
+                return JSON.stringify(c);
+            })
+                .join("\n");
+        }
+        return typeof content === "string" ? content : JSON.stringify(content);
+    }
+    catch (err) {
+        return `Error calling MCP tool "${toolName}" on server "${serverName}": ${err.message}`;
+    }
+}
+// ── Server management ──
+export function addServer(name, config) {
+    try {
+        if (!existsSync(GLOBAL_CONFIG_DIR)) {
+            mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+        }
+        let existing = { mcpServers: {} };
+        if (existsSync(GLOBAL_CONFIG_PATH)) {
+            try {
+                existing = JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+                if (!existing.mcpServers)
+                    existing.mcpServers = {};
+            }
+            catch {
+                existing = { mcpServers: {} };
+            }
+        }
+        existing.mcpServers[name] = config;
+        writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+        return { ok: true, message: `Added MCP server "${name}" to global config.` };
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to add server: ${err.message}` };
+    }
+}
+export function removeServer(name) {
+    try {
+        if (!existsSync(GLOBAL_CONFIG_PATH)) {
+            return { ok: false, message: `No global MCP config found.` };
+        }
+        const existing = JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+        if (!existing.mcpServers || !existing.mcpServers[name]) {
+            return { ok: false, message: `Server "${name}" not found in global config.` };
+        }
+        delete existing.mcpServers[name];
+        writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+        return { ok: true, message: `Removed MCP server "${name}" from global config.` };
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to remove server: ${err.message}` };
+    }
+}
+export function listServers(cwd) {
+    const result = [];
+    // Gather from global config
+    const globalConfig = loadConfigFile(GLOBAL_CONFIG_PATH);
+    if (globalConfig) {
+        for (const [name, cfg] of Object.entries(globalConfig.mcpServers)) {
+            const connected = connectedServers.find((s) => s.name === name);
+            result.push({
+                name,
+                source: "global",
+                command: `${cfg.command} ${(cfg.args ?? []).join(" ")}`.trim(),
+                connected: !!connected,
+                toolCount: connected?.tools.length ?? 0,
+            });
+        }
+    }
+    // Gather from project configs
+    for (const configPath of getProjectConfigPaths(cwd)) {
+        const config = loadConfigFile(configPath);
+        if (config) {
+            const source = configPath.includes(".cursor") ? "cursor" : configPath.includes("opencode") ? "opencode" : "project";
+            for (const [name, cfg] of Object.entries(config.mcpServers)) {
+                // Skip if already listed from global (project overrides)
+                const existing = result.find((r) => r.name === name);
+                if (existing) {
+                    existing.source = source;
+                    existing.command = `${cfg.command} ${(cfg.args ?? []).join(" ")}`.trim();
+                    continue;
+                }
+                const connected = connectedServers.find((s) => s.name === name);
+                result.push({
+                    name,
+                    source,
+                    command: `${cfg.command} ${(cfg.args ?? []).join(" ")}`.trim(),
+                    connected: !!connected,
+                    toolCount: connected?.tools.length ?? 0,
+                });
+            }
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemaxxing",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Open-source terminal coding agent. Connect any LLM. Max your code.",
   "main": "dist/index.js",
   "bin": {
@@ -27,6 +27,7 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "@types/react": "^19.2.14",
     "better-sqlite3": "^12.6.2",
     "chalk": "^5.3.0",

package/src/agent.ts

@@ -11,6 +11,7 @@ import { buildProjectContext, getSystemPrompt, loadProjectRules } from "./utils/
 import { isGitRepo, autoCommit } from "./utils/git.js";
 import { buildSkillPrompts, getActiveSkillCount } from "./utils/skills.js";
 import { createSession, saveMessage, updateTokenEstimate, updateSessionCost, loadMessages } from "./utils/sessions.js";
+import { loadMCPConfig, connectToServers, disconnectAll, getAllMCPTools, parseMCPToolName, callMCPTool, getConnectedServers, type ConnectedServer } from "./utils/mcp.js";
 import type { ProviderConfig } from "./config.js";
 
 // Tools that can modify your project — require approval
@@ -74,6 +75,7 @@ export interface AgentOptions {
   onContextCompressed?: (oldTokens: number, newTokens: number) => void;
   onArchitectPlan?: (plan: string) => void;
   onLintResult?: (file: string, errors: string) => void;
+  onMCPStatus?: (server: string, status: string) => void;
   contextCompressionThreshold?: number;
 }
 
@@ -108,6 +110,7 @@ export class CodingAgent {
   private architectModel: string | null = null;
   private autoLintEnabled: boolean = true;
   private detectedLinter: { command: string; name: string } | null = null;
+  private mcpServers: ConnectedServer[] = [];
 
   constructor(private options: AgentOptions) {
     this.providerType = options.provider.type || "openai";
@@ -145,6 +148,16 @@ export class CodingAgent {
     // Detect project linter
     this.detectedLinter = detectLinter(this.cwd);
 
+    // Connect to MCP servers
+    const mcpConfig = loadMCPConfig(this.cwd);
+    if (Object.keys(mcpConfig.mcpServers).length > 0) {
+      this.mcpServers = await connectToServers(mcpConfig, this.options.onMCPStatus);
+      if (this.mcpServers.length > 0) {
+        const mcpTools = getAllMCPTools(this.mcpServers);
+        this.tools = [...FILE_TOOLS, ...mcpTools];
+      }
+    }
+
     this.messages = [
       { role: "system", content: this.systemPrompt },
     ];
@@ -357,7 +370,14 @@ export class CodingAgent {
           }
         }
 
-        const result = await executeTool(toolCall.name, args, this.cwd);
+        // Route to MCP or built-in tool
+        const mcpParsed = parseMCPToolName(toolCall.name);
+        let result: string;
+        if (mcpParsed) {
+          result = await callMCPTool(mcpParsed.serverName, mcpParsed.toolName, args);
+        } else {
+          result = await executeTool(toolCall.name, args, this.cwd);
+        }
         this.options.onToolResult?.(toolCall.name, result);
 
         // Auto-commit after successful write_file (only if enabled)
@@ -569,7 +589,14 @@ export class CodingAgent {
           }
         }
 
-        const result = await executeTool(toolCall.name, args, this.cwd);
+        // Route to MCP or built-in tool
+        const mcpParsed = parseMCPToolName(toolCall.name);
+        let result: string;
+        if (mcpParsed) {
+          result = await callMCPTool(mcpParsed.serverName, mcpParsed.toolName, args);
+        } else {
+          result = await executeTool(toolCall.name, args, this.cwd);
+        }
         this.options.onToolResult?.(toolCall.name, result);
 
         // Auto-commit after successful write_file
@@ -834,6 +861,32 @@ export class CodingAgent {
     return this.chat(editorPrompt);
   }
 
+  getMCPServerCount(): number {
+    return this.mcpServers.length;
+  }
+
+  getMCPServers(): ConnectedServer[] {
+    return this.mcpServers;
+  }
+
+  async disconnectMCP(): Promise<void> {
+    await disconnectAll();
+    this.mcpServers = [];
+    this.tools = FILE_TOOLS;
+  }
+
+  async reconnectMCP(): Promise<void> {
+    await this.disconnectMCP();
+    const mcpConfig = loadMCPConfig(this.cwd);
+    if (Object.keys(mcpConfig.mcpServers).length > 0) {
+      this.mcpServers = await connectToServers(mcpConfig, this.options.onMCPStatus);
+      if (this.mcpServers.length > 0) {
+        const mcpTools = getAllMCPTools(this.mcpServers);
+        this.tools = [...FILE_TOOLS, ...mcpTools];
+      }
+    }
+  }
+
   reset(): void {
     const systemMsg = this.messages[0];
     this.messages = [systemMsg];

package/src/exec.ts

@@ -8,6 +8,7 @@
 import { CodingAgent } from "./agent.js";
 import { loadConfig, applyOverrides, detectLocalProvider } from "./config.js";
 import { getCredential } from "./utils/auth.js";
+import { disconnectAll } from "./utils/mcp.js";
 
 interface ExecArgs {
   prompt: string;
@@ -140,10 +141,19 @@ export async function runExec(argv: string[]): Promise<void> {
       process.stderr.write(`⚠ Denied ${name} (use --auto-approve to allow)\n`);
       return "no";
     },
+    onMCPStatus: (server, status) => {
+      process.stderr.write(`MCP ${server}: ${status}\n`);
+    },
   });
 
   try {
     await agent.init();
+
+    const mcpCount = agent.getMCPServerCount();
+    if (mcpCount > 0) {
+      process.stderr.write(`MCP: ${mcpCount} server${mcpCount > 1 ? "s" : ""} connected\n`);
+    }
+
     await agent.send(args.prompt);
 
     if (!args.json) {
@@ -160,8 +170,10 @@ export async function runExec(argv: string[]): Promise<void> {
       process.stdout.write(JSON.stringify(output, null, 2) + "\n");
     }
 
+    await disconnectAll();
     process.exit(hasChanges ? 0 : 2);
   } catch (err: any) {
+    await disconnectAll();
     process.stderr.write(`Error: ${err.message}\n`);
     if (args.json) {
       process.stdout.write(JSON.stringify({ error: err.message }, null, 2) + "\n");

package/src/index.tsx

@@ -12,6 +12,7 @@ import { isGitRepo, getBranch, getStatus, getDiff, undoLastCommit } from "./util
 import { getTheme, listThemes, THEMES, DEFAULT_THEME, type Theme } from "./themes.js";
 import { PROVIDERS, getCredentials, openRouterOAuth, anthropicSetupToken, importCodexToken, importQwenToken, copilotDeviceFlow, saveApiKey } from "./utils/auth.js";
 import { listInstalledSkills, installSkill, removeSkill, getRegistrySkills, searchRegistry, createSkillScaffold, getActiveSkills, getActiveSkillCount } from "./utils/skills.js";
+import { listServers, addServer, removeServer, getAllMCPTools, getConnectedServers } from "./utils/mcp.js";
 
 const VERSION = "0.1.9";
 
@@ -58,6 +59,11 @@ const SLASH_COMMANDS = [
   { cmd: "/lint", desc: "show auto-lint status" },
   { cmd: "/lint on", desc: "enable auto-lint" },
   { cmd: "/lint off", desc: "disable auto-lint" },
+  { cmd: "/mcp", desc: "show MCP servers" },
+  { cmd: "/mcp tools", desc: "list MCP tools" },
+  { cmd: "/mcp add", desc: "add MCP server" },
+  { cmd: "/mcp remove", desc: "remove MCP server" },
+  { cmd: "/mcp reconnect", desc: "reconnect MCP servers" },
   { cmd: "/quit", desc: "exit" },
 ];
 
@@ -287,6 +293,9 @@ function App() {
       onLintResult: (file, errors) => {
         addMsg("info", `🔍 Lint errors in ${file}:\n${errors}`);
       },
+      onMCPStatus: (server, status) => {
+        addMsg("info", `🔌 MCP ${server}: ${status}`);
+      },
       contextCompressionThreshold: config.defaults.contextCompressionThreshold,
       onToolApproval: (name, args, diff) => {
         return new Promise((resolve) => {
@@ -306,6 +315,13 @@ function App() {
       setConnectionInfo([...info]);
     }
 
+    // Show MCP server count
+    const mcpCount = a.getMCPServerCount();
+    if (mcpCount > 0) {
+      info.push(`🔌 ${mcpCount} MCP server${mcpCount > 1 ? "s" : ""} connected`);
+      setConnectionInfo([...info]);
+    }
+
     setAgent(a);
     setModelName(provider.model);
     providerRef.current = { baseUrl: provider.baseUrl, apiKey: provider.apiKey };
@@ -419,6 +435,11 @@ function App() {
         "  /lint      — show auto-lint status & detected linter",
         "  /lint on   — enable auto-lint",
         "  /lint off  — disable auto-lint",
+        "  /mcp       — show MCP servers & status",
+        "  /mcp tools — list all MCP tools",
+        "  /mcp add   — add MCP server to global config",
+        "  /mcp remove — remove MCP server",
+        "  /mcp reconnect — reconnect all MCP servers",
         "  /quit      — exit",
       ].join("\n"));
       return;
@@ -579,6 +600,71 @@ function App() {
       return;
     }
 
+    // ── MCP commands (partially work without agent) ──
+    if (trimmed === "/mcp" || trimmed === "/mcp list") {
+      const servers = listServers(process.cwd());
+      if (servers.length === 0) {
+        addMsg("info", "🔌 No MCP servers configured.\n  Add one: /mcp add <name> <command> [args...]");
+      } else {
+        const lines = servers.map((s) => {
+          const status = s.connected ? `✔ connected (${s.toolCount} tools)` : "✗ not connected";
+          return `  ${s.connected ? "●" : "○"} ${s.name} [${s.source}] — ${s.command}\n    ${status}`;
+        });
+        addMsg("info", `🔌 MCP Servers:\n${lines.join("\n")}`);
+      }
+      return;
+    }
+    if (trimmed === "/mcp tools") {
+      const servers = getConnectedServers();
+      if (servers.length === 0) {
+        addMsg("info", "🔌 No MCP servers connected.");
+        return;
+      }
+      const lines: string[] = [];
+      for (const server of servers) {
+        lines.push(`${server.name} (${server.tools.length} tools):`);
+        for (const tool of server.tools) {
+          lines.push(`  • ${tool.name} — ${tool.description ?? "(no description)"}`);
+        }
+      }
+      addMsg("info", `🔌 MCP Tools:\n${lines.join("\n")}`);
+      return;
+    }
+    if (trimmed.startsWith("/mcp add ")) {
+      const parts = trimmed.replace("/mcp add ", "").trim().split(/\s+/);
+      if (parts.length < 2) {
+        addMsg("info", "Usage: /mcp add <name> <command> [args...]\n  Example: /mcp add github npx -y @modelcontextprotocol/server-github");
+        return;
+      }
+      const [name, command, ...cmdArgs] = parts;
+      const result = addServer(name, { command, args: cmdArgs.length > 0 ? cmdArgs : undefined });
+      addMsg(result.ok ? "info" : "error", result.ok ? `✅ ${result.message}` : `✗ ${result.message}`);
+      return;
+    }
+    if (trimmed.startsWith("/mcp remove ")) {
+      const name = trimmed.replace("/mcp remove ", "").trim();
+      if (!name) {
+        addMsg("info", "Usage: /mcp remove <name>");
+        return;
+      }
+      const result = removeServer(name);
+      addMsg(result.ok ? "info" : "error", result.ok ? `✅ ${result.message}` : `✗ ${result.message}`);
+      return;
+    }
+    if (trimmed === "/mcp reconnect") {
+      if (!agent) {
+        addMsg("info", "⚠ No agent connected. Connect first.");
+        return;
+      }
+      addMsg("info", "🔌 Reconnecting MCP servers...");
+      await agent.reconnectMCP();
+      const count = agent.getMCPServerCount();
+      addMsg("info", count > 0
+        ? `✅ ${count} MCP server${count > 1 ? "s" : ""} reconnected.`
+        : "No MCP servers connected.");
+      return;
+    }
+
     // Commands below require an active LLM connection
     if (!agent) {
       addMsg("info", "⚠ No LLM connected. Use /login to authenticate with a provider, or start a local server.");

package/src/utils/mcp.ts

@@ -0,0 +1,307 @@
+/**
+ * MCP (Model Context Protocol) client support
+ * Connects to external MCP servers and exposes their tools to the LLM agent.
+ */
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+
+// ── Types ──
+
+export interface MCPServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface MCPConfig {
+  mcpServers: Record<string, MCPServerConfig>;
+}
+
+export interface ConnectedServer {
+  name: string;
+  client: Client;
+  transport: StdioClientTransport;
+  tools: Array<{ name: string; description?: string; inputSchema: Record<string, unknown> }>;
+}
+
+// ── Config paths ──
+
+const GLOBAL_CONFIG_DIR = join(homedir(), ".codemaxxing");
+const GLOBAL_CONFIG_PATH = join(GLOBAL_CONFIG_DIR, "mcp.json");
+
+function getProjectConfigPaths(cwd: string): string[] {
+  return [
+    join(cwd, ".codemaxxing", "mcp.json"),
+    join(cwd, ".cursor", "mcp.json"),
+    join(cwd, "opencode.json"),
+  ];
+}
+
+// ── Config loading ──
+
+function loadConfigFile(path: string): MCPConfig | null {
+  try {
+    if (!existsSync(path)) return null;
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
+      return parsed as MCPConfig;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function loadMCPConfig(cwd: string): MCPConfig {
+  const merged: MCPConfig = { mcpServers: {} };
+
+  // Load global config first (lower priority)
+  const globalConfig = loadConfigFile(GLOBAL_CONFIG_PATH);
+  if (globalConfig) {
+    Object.assign(merged.mcpServers, globalConfig.mcpServers);
+  }
+
+  // Load project configs (higher priority — later overwrites earlier)
+  for (const configPath of getProjectConfigPaths(cwd)) {
+    const config = loadConfigFile(configPath);
+    if (config) {
+      Object.assign(merged.mcpServers, config.mcpServers);
+    }
+  }
+
+  return merged;
+}
+
+// ── Connection management ──
+
+const connectedServers: ConnectedServer[] = [];
+
+export async function connectToServers(
+  config: MCPConfig,
+  onStatus?: (name: string, status: string) => void,
+): Promise<ConnectedServer[]> {
+  const entries = Object.entries(config.mcpServers);
+  if (entries.length === 0) return [];
+
+  for (const [name, serverConfig] of entries) {
+    try {
+      onStatus?.(name, "connecting");
+
+      const transport = new StdioClientTransport({
+        command: serverConfig.command,
+        args: serverConfig.args ?? [],
+        env: { ...process.env, ...(serverConfig.env ?? {}) } as Record<string, string>,
+      });
+
+      const client = new Client({
+        name: "codemaxxing",
+        version: "0.3.0",
+      });
+
+      await client.connect(transport);
+
+      // Fetch available tools
+      const toolsResult = await client.listTools();
+      const tools = (toolsResult.tools ?? []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: (t.inputSchema ?? { type: "object", properties: {} }) as Record<string, unknown>,
+      }));
+
+      const server: ConnectedServer = { name, client, transport, tools };
+      connectedServers.push(server);
+      onStatus?.(name, `connected (${tools.length} tools)`);
+    } catch (err: any) {
+      onStatus?.(name, `failed: ${err.message}`);
+    }
+  }
+
+  return connectedServers;
+}
+
+export async function disconnectAll(): Promise<void> {
+  for (const server of connectedServers) {
+    try {
+      await server.client.close();
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+  connectedServers.length = 0;
+}
+
+export function getConnectedServers(): ConnectedServer[] {
+  return connectedServers;
+}
+
+// ── Tool format conversion ──
+
+export function getAllMCPTools(servers: ConnectedServer[]): ChatCompletionTool[] {
+  const tools: ChatCompletionTool[] = [];
+
+  for (const server of servers) {
+    for (const tool of server.tools) {
+      tools.push({
+        type: "function",
+        function: {
+          name: `mcp_${server.name}_${tool.name}`,
+          description: `[MCP: ${server.name}] ${tool.description ?? tool.name}`,
+          parameters: tool.inputSchema as any,
+        },
+      });
+    }
+  }
+
+  return tools;
+}
+
+/**
+ * Parse an MCP tool call name to extract server name and tool name.
+ * Format: mcp_<serverName>_<toolName>
+ * Server names can contain hyphens but not underscores (by convention).
+ */
+export function parseMCPToolName(fullName: string): { serverName: string; toolName: string } | null {
+  if (!fullName.startsWith("mcp_")) return null;
+  const rest = fullName.slice(4); // Remove "mcp_"
+
+  // Find the server by matching known connected server names
+  for (const server of connectedServers) {
+    const prefix = server.name + "_";
+    if (rest.startsWith(prefix)) {
+      return { serverName: server.name, toolName: rest.slice(prefix.length) };
+    }
+  }
+
+  // Fallback: split on first underscore
+  const idx = rest.indexOf("_");
+  if (idx === -1) return null;
+  return { serverName: rest.slice(0, idx), toolName: rest.slice(idx + 1) };
+}
+
+// ── Tool execution ──
+
+export async function callMCPTool(
+  serverName: string,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<string> {
+  const server = connectedServers.find((s) => s.name === serverName);
+  if (!server) {
+    return `Error: MCP server "${serverName}" not found or not connected.`;
+  }
+
+  try {
+    const result = await server.client.callTool({ name: toolName, arguments: args });
+    // MCP tool results have a content array
+    const content = result.content;
+    if (Array.isArray(content)) {
+      return content
+        .map((c: any) => {
+          if (c.type === "text") return c.text;
+          if (c.type === "image") return `[image: ${c.mimeType}]`;
+          return JSON.stringify(c);
+        })
+        .join("\n");
+    }
+    return typeof content === "string" ? content : JSON.stringify(content);
+  } catch (err: any) {
+    return `Error calling MCP tool "${toolName}" on server "${serverName}": ${err.message}`;
+  }
+}
+
+// ── Server management ──
+
+export function addServer(name: string, config: MCPServerConfig): { ok: boolean; message: string } {
+  try {
+    if (!existsSync(GLOBAL_CONFIG_DIR)) {
+      mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+    }
+
+    let existing: MCPConfig = { mcpServers: {} };
+    if (existsSync(GLOBAL_CONFIG_PATH)) {
+      try {
+        existing = JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+        if (!existing.mcpServers) existing.mcpServers = {};
+      } catch {
+        existing = { mcpServers: {} };
+      }
+    }
+
+    existing.mcpServers[name] = config;
+    writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+    return { ok: true, message: `Added MCP server "${name}" to global config.` };
+  } catch (err: any) {
+    return { ok: false, message: `Failed to add server: ${err.message}` };
+  }
+}
+
+export function removeServer(name: string): { ok: boolean; message: string } {
+  try {
+    if (!existsSync(GLOBAL_CONFIG_PATH)) {
+      return { ok: false, message: `No global MCP config found.` };
+    }
+
+    const existing: MCPConfig = JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+    if (!existing.mcpServers || !existing.mcpServers[name]) {
+      return { ok: false, message: `Server "${name}" not found in global config.` };
+    }
+
+    delete existing.mcpServers[name];
+    writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+    return { ok: true, message: `Removed MCP server "${name}" from global config.` };
+  } catch (err: any) {
+    return { ok: false, message: `Failed to remove server: ${err.message}` };
+  }
+}
+
+export function listServers(cwd: string): Array<{ name: string; source: string; command: string; connected: boolean; toolCount: number }> {
+  const result: Array<{ name: string; source: string; command: string; connected: boolean; toolCount: number }> = [];
+
+  // Gather from global config
+  const globalConfig = loadConfigFile(GLOBAL_CONFIG_PATH);
+  if (globalConfig) {
+    for (const [name, cfg] of Object.entries(globalConfig.mcpServers)) {
+      const connected = connectedServers.find((s) => s.name === name);
+      result.push({
+        name,
+        source: "global",
+        command: `${cfg.command} ${(cfg.args ?? []).join(" ")}`.trim(),
+        connected: !!connected,
+        toolCount: connected?.tools.length ?? 0,
+      });
+    }
+  }
+
+  // Gather from project configs
+  for (const configPath of getProjectConfigPaths(cwd)) {
+    const config = loadConfigFile(configPath);
+    if (config) {
+      const source = configPath.includes(".cursor") ? "cursor" : configPath.includes("opencode") ? "opencode" : "project";
+      for (const [name, cfg] of Object.entries(config.mcpServers)) {
+        // Skip if already listed from global (project overrides)
+        const existing = result.find((r) => r.name === name);
+        if (existing) {
+          existing.source = source;
+          existing.command = `${cfg.command} ${(cfg.args ?? []).join(" ")}`.trim();
+          continue;
+        }
+        const connected = connectedServers.find((s) => s.name === name);
+        result.push({
+          name,
+          source,
+          command: `${cfg.command} ${(cfg.args ?? []).join(" ")}`.trim(),
+          connected: !!connected,
+          toolCount: connected?.tools.length ?? 0,
+        });
+      }
+    }
+  }
+
+  return result;
+}