codemaxxing 0.3.0 → 0.4.0

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;
+}

package/src/utils/models.ts

@@ -0,0 +1,137 @@
+import type { HardwareInfo } from "./hardware.js";
+
+export interface RecommendedModel {
+  name: string;           // Display name
+  ollamaId: string;       // Ollama model ID
+  size: number;           // Download size in GB
+  ramRequired: number;    // Minimum RAM in GB
+  vramOptimal: number;    // Optimal VRAM in GB (0 = CPU fine)
+  description: string;    // One-liner
+  speed: string;          // e.g., "~45 tok/s on M1"
+  quality: "good" | "great" | "best";
+}
+
+export type ModelFit = "perfect" | "good" | "tight" | "skip";
+
+export interface ScoredModel extends RecommendedModel {
+  fit: ModelFit;
+}
+
+const MODELS: RecommendedModel[] = [
+  {
+    name: "Qwen 2.5 Coder 3B",
+    ollamaId: "qwen2.5-coder:3b",
+    size: 2,
+    ramRequired: 8,
+    vramOptimal: 4,
+    description: "Lightweight, fast coding model",
+    speed: "~60 tok/s on M1",
+    quality: "good",
+  },
+  {
+    name: "Qwen 2.5 Coder 7B",
+    ollamaId: "qwen2.5-coder:7b",
+    size: 5,
+    ramRequired: 16,
+    vramOptimal: 8,
+    description: "Sweet spot for most machines",
+    speed: "~45 tok/s on M1",
+    quality: "great",
+  },
+  {
+    name: "Qwen 2.5 Coder 14B",
+    ollamaId: "qwen2.5-coder:14b",
+    size: 9,
+    ramRequired: 32,
+    vramOptimal: 16,
+    description: "High quality coding",
+    speed: "~25 tok/s on M1 Pro",
+    quality: "best",
+  },
+  {
+    name: "Qwen 2.5 Coder 32B",
+    ollamaId: "qwen2.5-coder:32b",
+    size: 20,
+    ramRequired: 48,
+    vramOptimal: 32,
+    description: "Premium quality, needs lots of RAM",
+    speed: "~12 tok/s on M1 Max",
+    quality: "best",
+  },
+  {
+    name: "DeepSeek Coder V2 16B",
+    ollamaId: "deepseek-coder-v2:16b",
+    size: 9,
+    ramRequired: 32,
+    vramOptimal: 16,
+    description: "Strong alternative for coding",
+    speed: "~30 tok/s on M1 Pro",
+    quality: "great",
+  },
+  {
+    name: "CodeLlama 7B",
+    ollamaId: "codellama:7b",
+    size: 4,
+    ramRequired: 16,
+    vramOptimal: 8,
+    description: "Meta's coding model",
+    speed: "~40 tok/s on M1",
+    quality: "good",
+  },
+  {
+    name: "StarCoder2 7B",
+    ollamaId: "starcoder2:7b",
+    size: 4,
+    ramRequired: 16,
+    vramOptimal: 8,
+    description: "Good for code completion",
+    speed: "~40 tok/s on M1",
+    quality: "good",
+  },
+];
+
+function scoreModel(model: RecommendedModel, ramGB: number, vramGB: number): ModelFit {
+  if (ramGB < model.ramRequired) return "skip";
+
+  const ramHeadroom = ramGB - model.ramRequired;
+  const hasGoodVRAM = vramGB >= model.vramOptimal;
+
+  if (hasGoodVRAM && ramHeadroom >= 4) return "perfect";
+  if (hasGoodVRAM || ramHeadroom >= 8) return "good";
+  if (ramHeadroom >= 0) return "tight";
+  return "skip";
+}
+
+const qualityOrder: Record<string, number> = { best: 3, great: 2, good: 1 };
+const fitOrder: Record<string, number> = { perfect: 4, good: 3, tight: 2, skip: 1 };
+
+export function getRecommendations(hardware: HardwareInfo): ScoredModel[] {
+  const ramGB = hardware.ram / (1024 * 1024 * 1024);
+  const vramGB = hardware.gpu?.vram ? hardware.gpu.vram / (1024 * 1024 * 1024) : 0;
+
+  // Apple Silicon uses unified memory — VRAM = RAM
+  const effectiveVRAM = hardware.appleSilicon ? ramGB : vramGB;
+
+  const scored: ScoredModel[] = MODELS.map((m) => ({
+    ...m,
+    fit: scoreModel(m, ramGB, effectiveVRAM),
+  }));
+
+  // Sort: perfect first, then by quality descending
+  scored.sort((a, b) => {
+    const fitDiff = (fitOrder[b.fit] ?? 0) - (fitOrder[a.fit] ?? 0);
+    if (fitDiff !== 0) return fitDiff;
+    return (qualityOrder[b.quality] ?? 0) - (qualityOrder[a.quality] ?? 0);
+  });
+
+  return scored;
+}
+
+export function getFitIcon(fit: ModelFit): string {
+  switch (fit) {
+    case "perfect": return "\u2B50"; // ⭐
+    case "good": return "\u2705";    // ✅
+    case "tight": return "\u26A0\uFE0F";  // ⚠️
+    case "skip": return "\u274C";    // ❌
+  }
+}

package/src/utils/ollama.ts

@@ -0,0 +1,137 @@
+import { execSync, spawn } from "child_process";
+
+/** Check if ollama binary exists on PATH */
+export function isOllamaInstalled(): boolean {
+  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(): Promise<boolean> {
+  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: "macos" | "linux" | "windows"): string {
+  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(): void {
+  const child = spawn("ollama", ["serve"], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+}
+
+export interface PullProgress {
+  status: string;
+  total?: number;
+  completed?: number;
+  percent: number;
+}
+
+/**
+ * Pull a model from Ollama registry.
+ * Calls onProgress with download updates.
+ * Returns a promise that resolves when complete.
+ */
+export function pullModel(
+  modelId: string,
+  onProgress?: (progress: PullProgress) => void
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn("ollama", ["pull", modelId], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let lastOutput = "";
+
+    const parseLine = (data: string) => {
+      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: number | undefined;
+        let total: number | undefined;
+        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: Buffer) => {
+      parseLine(data.toString().trim());
+    });
+
+    child.stderr?.on("data", (data: Buffer) => {
+      // 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(): Promise<string[]> {
+  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()) as { models?: Array<{ name: string }> };
+      return (data.models ?? []).map((m) => m.name);
+    }
+  } catch { /* not running */ }
+  return [];
+}