codemaxxing 0.3.0 → 0.4.0

package/dist/utils/hardware.js

@@ -0,0 +1,120 @@
+import os from "os";
+import { execSync } from "child_process";
+function getOS() {
+    switch (process.platform) {
+        case "darwin": return "macos";
+        case "win32": return "windows";
+        default: return "linux";
+    }
+}
+function getCPU() {
+    const cpus = os.cpus();
+    return {
+        name: cpus[0]?.model?.trim() ?? "Unknown CPU",
+        cores: cpus.length,
+        speed: cpus[0]?.speed ?? 0, // MHz
+    };
+}
+function getGPU(platform) {
+    try {
+        if (platform === "macos") {
+            const raw = execSync("system_profiler SPDisplaysDataType -json", {
+                encoding: "utf-8",
+                timeout: 5000,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            const data = JSON.parse(raw);
+            const displays = data?.SPDisplaysDataType;
+            if (Array.isArray(displays) && displays.length > 0) {
+                const gpu = displays[0];
+                const name = gpu.sppci_model ?? gpu._name ?? "Unknown GPU";
+                // On Apple Silicon, VRAM is shared (unified memory) — report total RAM
+                const vramStr = gpu["spdisplays_vram"] ?? gpu["spdisplays_vram_shared"] ?? "";
+                let vram = 0;
+                if (vramStr) {
+                    const match = vramStr.match(/(\d+)\s*(GB|MB)/i);
+                    if (match) {
+                        vram = parseInt(match[1]) * (match[2].toUpperCase() === "GB" ? 1024 * 1024 * 1024 : 1024 * 1024);
+                    }
+                }
+                // Apple Silicon unified memory — use total RAM as VRAM
+                if (vram === 0 && name.toLowerCase().includes("apple")) {
+                    vram = os.totalmem();
+                }
+                return { name, vram };
+            }
+        }
+        if (platform === "linux") {
+            // Try NVIDIA first
+            try {
+                const raw = execSync("nvidia-smi --query-gpu=name,memory.total --format=csv,noheader", {
+                    encoding: "utf-8",
+                    timeout: 5000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                const line = raw.trim().split("\n")[0];
+                if (line) {
+                    const parts = line.split(",").map(s => s.trim());
+                    const name = parts[0] ?? "NVIDIA GPU";
+                    const memMatch = (parts[1] ?? "").match(/(\d+)/);
+                    const vram = memMatch ? parseInt(memMatch[1]) * 1024 * 1024 : 0; // MiB to bytes
+                    return { name, vram };
+                }
+            }
+            catch {
+                // No NVIDIA, try lspci
+                try {
+                    const raw = execSync("lspci | grep -i vga", {
+                        encoding: "utf-8",
+                        timeout: 5000,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                    const line = raw.trim().split("\n")[0];
+                    if (line) {
+                        const name = line.split(":").slice(2).join(":").trim() || "Unknown GPU";
+                        return { name, vram: 0 };
+                    }
+                }
+                catch { /* no lspci */ }
+            }
+        }
+        if (platform === "windows") {
+            try {
+                const raw = execSync("wmic path win32_VideoController get Name,AdapterRAM /format:csv", {
+                    encoding: "utf-8",
+                    timeout: 5000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                const lines = raw.trim().split("\n").filter(l => l.trim() && !l.startsWith("Node"));
+                if (lines.length > 0) {
+                    const parts = lines[0].split(",");
+                    const adapterRAM = parseInt(parts[1] ?? "0");
+                    const name = parts[2]?.trim() ?? "Unknown GPU";
+                    return { name, vram: isNaN(adapterRAM) ? 0 : adapterRAM };
+                }
+            }
+            catch { /* no wmic */ }
+        }
+    }
+    catch {
+        // GPU detection failed
+    }
+    return null;
+}
+export function detectHardware() {
+    const platform = getOS();
+    const cpu = getCPU();
+    const ram = os.totalmem();
+    const gpu = getGPU(platform);
+    // Detect Apple Silicon
+    const appleSilicon = platform === "macos" && /apple\s+m/i.test(cpu.name);
+    return { cpu, ram, gpu, os: platform, appleSilicon };
+}
+/** Format bytes to human-readable string */
+export function formatBytes(bytes) {
+    if (bytes >= 1024 * 1024 * 1024)
+        return `${Math.round(bytes / (1024 * 1024 * 1024))} GB`;
+    if (bytes >= 1024 * 1024)
+        return `${Math.round(bytes / (1024 * 1024))} MB`;
+    return `${Math.round(bytes / 1024)} KB`;
+}

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/dist/utils/models.d.ts

@@ -0,0 +1,17 @@
+import type { HardwareInfo } from "./hardware.js";
+export interface RecommendedModel {
+    name: string;
+    ollamaId: string;
+    size: number;
+    ramRequired: number;
+    vramOptimal: number;
+    description: string;
+    speed: string;
+    quality: "good" | "great" | "best";
+}
+export type ModelFit = "perfect" | "good" | "tight" | "skip";
+export interface ScoredModel extends RecommendedModel {
+    fit: ModelFit;
+}
+export declare function getRecommendations(hardware: HardwareInfo): ScoredModel[];
+export declare function getFitIcon(fit: ModelFit): string;

package/dist/utils/models.js

@@ -0,0 +1,113 @@
+const MODELS = [
+    {
+        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, ramGB, vramGB) {
+    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 = { best: 3, great: 2, good: 1 };
+const fitOrder = { perfect: 4, good: 3, tight: 2, skip: 1 };
+export function getRecommendations(hardware) {
+    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 = 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) {
+    switch (fit) {
+        case "perfect": return "\u2B50"; // ⭐
+        case "good": return "\u2705"; // ✅
+        case "tight": return "\u26A0\uFE0F"; // ⚠️
+        case "skip": return "\u274C"; // ❌
+    }
+}

package/dist/utils/ollama.d.ts

@@ -0,0 +1,22 @@
+/** Check if ollama binary exists on PATH */
+export declare function isOllamaInstalled(): boolean;
+/** Check if ollama server is responding */
+export declare function isOllamaRunning(): Promise<boolean>;
+/** Get the install command for the user's OS */
+export declare function getOllamaInstallCommand(os: "macos" | "linux" | "windows"): string;
+/** Start ollama serve in background */
+export declare function startOllama(): void;
+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 declare function pullModel(modelId: string, onProgress?: (progress: PullProgress) => void): Promise<void>;
+/** List models installed in Ollama */
+export declare function listInstalledModels(): Promise<string[]>;