codemaxxing 1.0.0 → 1.0.2

package/src/utils/mcp.ts

@@ -1,307 +0,0 @@
-/**
- * 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

@@ -1,218 +0,0 @@
-import { execSync } from "child_process";
-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: "limited" | "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: "\u26A0\uFE0F May not support tool calling well",
-    speed: "~60 tok/s on M1",
-    quality: "limited",
-  },
-  {
-    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, limited: 0 };
-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";    // ❌
-  }
-}
-
-/** Check if llmfit binary is available */
-export function isLlmfitAvailable(): boolean {
-  try {
-    const cmd = process.platform === "win32" ? "where llmfit" : "which llmfit";
-    execSync(cmd, { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-interface LlmfitModel {
-  name: string;
-  provider: string;
-  params_b: number;
-  quant: string;
-  fit: string;
-  estimated_tps: number;
-  vram_gb: number;
-  ram_gb: number;
-}
-
-function mapLlmfitFit(fit: string): ModelFit {
-  switch (fit) {
-    case "perfect": return "perfect";
-    case "good": return "good";
-    case "marginal": return "tight";
-    default: return "skip";
-  }
-}
-
-function mapLlmfitQuality(params_b: number): "limited" | "good" | "great" | "best" {
-  if (params_b >= 14) return "best";
-  if (params_b >= 7) return "great";
-  if (params_b >= 5) return "good";
-  return "limited";
-}
-
-/** Get recommendations using llmfit if available, otherwise fall back to hardcoded list */
-export function getRecommendationsWithLlmfit(hardware: HardwareInfo): { models: ScoredModel[]; usedLlmfit: boolean } {
-  if (!isLlmfitAvailable()) {
-    return { models: getRecommendations(hardware), usedLlmfit: false };
-  }
-
-  try {
-    const raw = execSync("llmfit recommend --use-case coding --format json --limit 10", {
-      encoding: "utf-8",
-      timeout: 15000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    const llmfitModels: LlmfitModel[] = JSON.parse(raw.trim());
-    if (!Array.isArray(llmfitModels) || llmfitModels.length === 0) {
-      return { models: getRecommendations(hardware), usedLlmfit: false };
-    }
-
-    const scored: ScoredModel[] = llmfitModels
-      .filter((m) => m.provider === "ollama")
-      .map((m) => ({
-        name: m.name.split(":")[0]?.replace(/-/g, " ").replace(/\b\w/g, c => c.toUpperCase()) + ` ${m.params_b}B`,
-        ollamaId: m.name,
-        size: Math.ceil(m.vram_gb),
-        ramRequired: Math.ceil(m.ram_gb),
-        vramOptimal: Math.ceil(m.vram_gb),
-        description: `${m.quant} · ~${m.estimated_tps.toFixed(0)} tok/s`,
-        speed: `~${m.estimated_tps.toFixed(0)} tok/s`,
-        quality: mapLlmfitQuality(m.params_b),
-        fit: mapLlmfitFit(m.fit),
-      }));
-
-    if (scored.length === 0) {
-      return { models: getRecommendations(hardware), usedLlmfit: false };
-    }
-
-    return { models: scored, usedLlmfit: true };
-  } catch {
-    return { models: getRecommendations(hardware), usedLlmfit: false };
-  }
-}