codemaxxing 0.2.1 → 0.3.1

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.2.1",
+  "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

@@ -6,10 +6,12 @@ import type {
   ChatCompletionChunk,
 } from "openai/resources/chat/completions";
 import { FILE_TOOLS, executeTool, generateDiff, getExistingContent } from "./tools/files.js";
-import { buildProjectContext, getSystemPrompt } from "./utils/context.js";
+import { detectLinter, runLinter } from "./utils/lint.js";
+import { buildProjectContext, getSystemPrompt, loadProjectRules } from "./utils/context.js";
 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
@@ -71,6 +73,9 @@ export interface AgentOptions {
   onToolApproval?: (name: string, args: Record<string, unknown>, diff?: string) => Promise<"yes" | "no" | "always">;
   onGitCommit?: (message: string) => void;
   onContextCompressed?: (oldTokens: number, newTokens: number) => void;
+  onArchitectPlan?: (plan: string) => void;
+  onLintResult?: (file: string, errors: string) => void;
+  onMCPStatus?: (server: string, status: string) => void;
   contextCompressionThreshold?: number;
 }
 
@@ -101,6 +106,11 @@ export class CodingAgent {
   private systemPrompt: string = "";
   private compressionThreshold: number;
   private sessionDisabledSkills: Set<string> = new Set();
+  private projectRulesSource: string | null = null;
+  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";
@@ -131,7 +141,22 @@ export class CodingAgent {
   async init(): Promise<void> {
     const context = await buildProjectContext(this.cwd);
     const skillPrompts = buildSkillPrompts(this.cwd, this.sessionDisabledSkills);
-    this.systemPrompt = await getSystemPrompt(context, skillPrompts);
+    const rules = loadProjectRules(this.cwd);
+    if (rules) this.projectRulesSource = rules.source;
+    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 },
@@ -174,6 +199,16 @@ export class CodingAgent {
     return this.repoMap;
   }
 
+  /**
+   * Send a message, routing through architect model if enabled
+   */
+  async send(userMessage: string): Promise<string> {
+    if (this.architectModel) {
+      return this.architectChat(userMessage);
+    }
+    return this.chat(userMessage);
+  }
+
   /**
    * Stream a response from the model.
    * Assembles tool call chunks, emits tokens in real-time,
@@ -335,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)
@@ -347,6 +389,23 @@ export class CodingAgent {
           }
         }
 
+        // Auto-lint after successful write_file
+        if (this.autoLintEnabled && this.detectedLinter && toolCall.name === "write_file" && result.startsWith("✅")) {
+          const filePath = String(args.path ?? "");
+          const lintErrors = runLinter(this.detectedLinter, filePath, this.cwd);
+          if (lintErrors) {
+            this.options.onLintResult?.(filePath, lintErrors);
+            const lintMsg: ChatCompletionMessageParam = {
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: result + `\n\nLint errors detected in ${filePath}:\n${lintErrors}\nPlease fix these issues.`,
+            };
+            this.messages.push(lintMsg);
+            saveMessage(this.sessionId, lintMsg);
+            continue; // skip the normal tool message push
+          }
+        }
+
         const toolMsg: ChatCompletionMessageParam = {
           role: "tool",
           tool_call_id: toolCall.id,
@@ -530,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
@@ -542,6 +608,23 @@ export class CodingAgent {
           }
         }
 
+        // Auto-lint after successful write_file
+        if (this.autoLintEnabled && this.detectedLinter && toolCall.name === "write_file" && result.startsWith("✅")) {
+          const filePath = String(args.path ?? "");
+          const lintErrors = runLinter(this.detectedLinter, filePath, this.cwd);
+          if (lintErrors) {
+            this.options.onLintResult?.(filePath, lintErrors);
+            const lintMsg: ChatCompletionMessageParam = {
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: result + `\n\nLint errors detected in ${filePath}:\n${lintErrors}\nPlease fix these issues.`,
+            };
+            this.messages.push(lintMsg);
+            saveMessage(this.sessionId, lintMsg);
+            continue;
+          }
+        }
+
         const toolMsg: ChatCompletionMessageParam = {
           role: "tool",
           tool_call_id: toolCall.id,
@@ -712,6 +795,98 @@ export class CodingAgent {
     return this.cwd;
   }
 
+  getProjectRulesSource(): string | null {
+    return this.projectRulesSource;
+  }
+
+  setArchitectModel(model: string | null): void {
+    this.architectModel = model;
+  }
+
+  getArchitectModel(): string | null {
+    return this.architectModel;
+  }
+
+  setAutoLint(enabled: boolean): void {
+    this.autoLintEnabled = enabled;
+  }
+
+  isAutoLintEnabled(): boolean {
+    return this.autoLintEnabled;
+  }
+
+  getDetectedLinter(): { command: string; name: string } | null {
+    return this.detectedLinter;
+  }
+
+  setDetectedLinter(linter: { command: string; name: string } | null): void {
+    this.detectedLinter = linter;
+  }
+
+  /**
+   * Run the architect model to generate a plan, then feed to editor model
+   */
+  private async architectChat(userMessage: string): Promise<string> {
+    const architectSystemPrompt = "You are a senior software architect. Analyze the request and create a detailed implementation plan. List exactly which files to modify, what changes to make, and in what order. Do NOT write code — just plan.";
+
+    let plan = "";
+
+    if (this.providerType === "anthropic" && this.anthropicClient) {
+      const response = await this.anthropicClient.messages.create({
+        model: this.architectModel!,
+        max_tokens: this.maxTokens,
+        system: architectSystemPrompt,
+        messages: [{ role: "user", content: userMessage }],
+      });
+      plan = response.content
+        .filter((b): b is Anthropic.TextBlock => b.type === "text")
+        .map((b) => b.text)
+        .join("");
+    } else {
+      const response = await this.client.chat.completions.create({
+        model: this.architectModel!,
+        max_tokens: this.maxTokens,
+        messages: [
+          { role: "system", content: architectSystemPrompt },
+          { role: "user", content: userMessage },
+        ],
+      });
+      plan = response.choices[0]?.message?.content ?? "(no plan generated)";
+    }
+
+    this.options.onArchitectPlan?.(plan);
+
+    // Feed plan + original request to the editor model
+    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(): 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/cli.ts

@@ -2,7 +2,7 @@
 
 /**
  * Codemaxxing CLI entry point
- * Routes subcommands (login, auth) to auth-cli, everything else to the TUI
+ * Routes subcommands (login, auth, exec) to handlers, everything else to the TUI
  */
 
 import { spawn } from "node:child_process";
@@ -27,6 +27,10 @@ if (subcmd === "login" || subcmd === "auth") {
   });
 
   child.on("exit", (code) => process.exit(code ?? 0));
+} else if (subcmd === "exec") {
+  // Headless/CI mode — no TUI
+  const { runExec } = await import("./exec.js");
+  await runExec(process.argv.slice(3));
 } else {
   // TUI mode — import directly (not spawn) to preserve raw stdin
   await import("./index.js");

package/src/config.ts

@@ -22,6 +22,8 @@ export interface CodemaxxingConfig {
     contextFiles: number;
     maxTokens: number;
     contextCompressionThreshold?: number;
+    architectModel?: string;
+    autoLint?: boolean;
   };
 }
 
@@ -85,6 +87,7 @@ codemaxxing — your code. your model. no excuses.
 
 Usage:
   codemaxxing [options]
+  codemaxxing exec "prompt" [exec-options]
 
 Options:
   -m, --model <model>       Model name to use
@@ -93,11 +96,19 @@ Options:
   -u, --base-url <url>      Base URL for the provider API
   -h, --help                Show this help
 
+Exec options (headless/CI mode):
+  --auto-approve            Skip tool approval prompts
+  --json                    Output JSON instead of streaming text
+  -m, --model <model>       Model to use
+  -p, --provider <name>     Provider profile
+
 Examples:
   codemaxxing                                    # Auto-detect local LLM
   codemaxxing -m gpt-4o -u https://api.openai.com/v1 -k sk-...
   codemaxxing -p openrouter                      # Use saved provider profile
   codemaxxing -m qwen3.5-35b                     # Override model only
+  codemaxxing exec "fix the failing tests"       # Headless mode
+  echo "explain this code" | codemaxxing exec    # Pipe input
 
 Config: ~/.codemaxxing/settings.json
 `);