codemaxxing 0.3.0 → 0.4.0

package/dist/utils/ollama.js

@@ -0,0 +1,121 @@
+import { execSync, spawn } from "child_process";
+/** Check if ollama binary exists on PATH */
+export function isOllamaInstalled() {
+    try {
+        const cmd = process.platform === "win32" ? "where ollama" : "which ollama";
+        execSync(cmd, { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check if ollama server is responding */
+export async function isOllamaRunning() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        const res = await fetch("http://localhost:11434/api/tags", { signal: controller.signal });
+        clearTimeout(timeout);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** Get the install command for the user's OS */
+export function getOllamaInstallCommand(os) {
+    switch (os) {
+        case "macos": return "brew install ollama";
+        case "linux": return "curl -fsSL https://ollama.com/install.sh | sh";
+        case "windows": return "winget install Ollama.Ollama";
+    }
+}
+/** Start ollama serve in background */
+export function startOllama() {
+    const child = spawn("ollama", ["serve"], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+/**
+ * Pull a model from Ollama registry.
+ * Calls onProgress with download updates.
+ * Returns a promise that resolves when complete.
+ */
+export function pullModel(modelId, onProgress) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("ollama", ["pull", modelId], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let lastOutput = "";
+        const parseLine = (data) => {
+            lastOutput = data;
+            // Ollama pull output looks like:
+            // pulling manifest
+            // pulling abc123... 58% ▕██████████░░░░░░░░░░▏ 2.9 GB/5.0 GB
+            // verifying sha256 digest
+            // writing manifest
+            // success
+            // Try to parse percentage
+            const pctMatch = data.match(/(\d+)%/);
+            const sizeMatch = data.match(/([\d.]+)\s*GB\s*\/\s*([\d.]+)\s*GB/);
+            if (pctMatch) {
+                const percent = parseInt(pctMatch[1]);
+                let completed;
+                let total;
+                if (sizeMatch) {
+                    completed = parseFloat(sizeMatch[1]) * 1024 * 1024 * 1024;
+                    total = parseFloat(sizeMatch[2]) * 1024 * 1024 * 1024;
+                }
+                onProgress?.({ status: "downloading", total, completed, percent });
+            }
+            else if (data.includes("pulling manifest")) {
+                onProgress?.({ status: "pulling manifest", percent: 0 });
+            }
+            else if (data.includes("verifying")) {
+                onProgress?.({ status: "verifying", percent: 100 });
+            }
+            else if (data.includes("writing manifest")) {
+                onProgress?.({ status: "writing manifest", percent: 100 });
+            }
+            else if (data.includes("success")) {
+                onProgress?.({ status: "success", percent: 100 });
+            }
+        };
+        child.stdout?.on("data", (data) => {
+            parseLine(data.toString().trim());
+        });
+        child.stderr?.on("data", (data) => {
+            // Ollama writes progress to stderr
+            parseLine(data.toString().trim());
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`ollama pull failed (exit ${code}): ${lastOutput}`));
+            }
+        });
+        child.on("error", (err) => {
+            reject(new Error(`Failed to run ollama pull: ${err.message}`));
+        });
+    });
+}
+/** List models installed in Ollama */
+export async function listInstalledModels() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch("http://localhost:11434/api/tags", { signal: controller.signal });
+        clearTimeout(timeout);
+        if (res.ok) {
+            const data = (await res.json());
+            return (data.models ?? []).map((m) => m.name);
+        }
+    }
+    catch { /* not running */ }
+    return [];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemaxxing",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "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");