codemaxxing 0.3.1 → 0.4.1

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

@@ -0,0 +1,24 @@
+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;
+/** Check if llmfit binary is available */
+export declare function isLlmfitAvailable(): boolean;
+/** Get recommendations using llmfit if available, otherwise fall back to hardcoded list */
+export declare function getRecommendationsWithLlmfit(hardware: HardwareInfo): {
+    models: ScoredModel[];
+    usedLlmfit: boolean;
+};

package/dist/utils/models.js

@@ -0,0 +1,177 @@
+import { execSync } from "child_process";
+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"; // ❌
+    }
+}
+/** Check if llmfit binary is available */
+export function isLlmfitAvailable() {
+    try {
+        const cmd = process.platform === "win32" ? "where llmfit" : "which llmfit";
+        execSync(cmd, { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function mapLlmfitFit(fit) {
+    switch (fit) {
+        case "perfect": return "perfect";
+        case "good": return "good";
+        case "marginal": return "tight";
+        default: return "skip";
+    }
+}
+function mapLlmfitQuality(params_b) {
+    if (params_b >= 14)
+        return "best";
+    if (params_b >= 7)
+        return "great";
+    return "good";
+}
+/** Get recommendations using llmfit if available, otherwise fall back to hardcoded list */
+export function getRecommendationsWithLlmfit(hardware) {
+    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 = JSON.parse(raw.trim());
+        if (!Array.isArray(llmfitModels) || llmfitModels.length === 0) {
+            return { models: getRecommendations(hardware), usedLlmfit: false };
+        }
+        const scored = 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 };
+    }
+}

package/dist/utils/ollama.d.ts

@@ -0,0 +1,42 @@
+/** 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>;
+export interface OllamaModelInfo {
+    name: string;
+    size: number;
+    modified_at: string;
+    digest: string;
+}
+/** List models installed in Ollama with detailed info */
+export declare function listInstalledModelsDetailed(): Promise<OllamaModelInfo[]>;
+/** List models installed in Ollama */
+export declare function listInstalledModels(): Promise<string[]>;
+/** Stop all loaded models (frees VRAM) and kill the Ollama server process */
+export declare function stopOllama(): Promise<{
+    ok: boolean;
+    message: string;
+}>;
+/** Delete a model from disk */
+export declare function deleteModel(modelId: string): {
+    ok: boolean;
+    message: string;
+};
+/** Get GPU memory usage info (best-effort) */
+export declare function getGPUMemoryUsage(): string | null;

package/dist/utils/ollama.js

@@ -0,0 +1,213 @@
+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 with detailed info */
+export async function listInstalledModelsDetailed() {
+    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) => ({
+                name: m.name,
+                size: m.size,
+                modified_at: m.modified_at,
+                digest: m.digest,
+            }));
+        }
+    }
+    catch { /* not running */ }
+    return [];
+}
+/** List models installed in Ollama */
+export async function listInstalledModels() {
+    const models = await listInstalledModelsDetailed();
+    return models.map((m) => m.name);
+}
+/** Stop all loaded models (frees VRAM) and kill the Ollama server process */
+export async function stopOllama() {
+    try {
+        // First unload all models from memory
+        try {
+            execSync("ollama stop", { stdio: ["pipe", "pipe", "pipe"], timeout: 5000 });
+        }
+        catch { /* may fail if no models loaded */ }
+        // Kill the server process
+        if (process.platform === "win32") {
+            execSync("taskkill /f /im ollama.exe", { stdio: ["pipe", "pipe", "pipe"], timeout: 5000 });
+        }
+        else if (process.platform === "darwin") {
+            // Try launchctl first (Ollama app), then pkill
+            try {
+                execSync("launchctl stop com.ollama.ollama", { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+            }
+            catch {
+                try {
+                    execSync("pkill ollama", { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+                }
+                catch { /* already stopped */ }
+            }
+        }
+        else {
+            // Linux
+            try {
+                execSync("systemctl stop ollama", { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+            }
+            catch {
+                try {
+                    execSync("pkill ollama", { stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+                }
+                catch { /* already stopped */ }
+            }
+        }
+        // Verify it stopped
+        await new Promise(r => setTimeout(r, 500));
+        const stillRunning = await isOllamaRunning();
+        if (stillRunning) {
+            return { ok: false, message: "Ollama is still running. Try killing it manually." };
+        }
+        return { ok: true, message: "Ollama stopped." };
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to stop Ollama: ${err.message}` };
+    }
+}
+/** Delete a model from disk */
+export function deleteModel(modelId) {
+    try {
+        execSync(`ollama rm ${modelId}`, { stdio: ["pipe", "pipe", "pipe"], timeout: 30000 });
+        return { ok: true, message: `Deleted ${modelId}` };
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to delete ${modelId}: ${err.stderr?.toString().trim() || err.message}` };
+    }
+}
+/** Get GPU memory usage info (best-effort) */
+export function getGPUMemoryUsage() {
+    try {
+        if (process.platform === "darwin") {
+            // Apple Silicon — check memory pressure
+            const raw = execSync("memory_pressure", { encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"] });
+            const match = raw.match(/System-wide memory free percentage:\s*(\d+)%/);
+            if (match) {
+                return `${100 - parseInt(match[1])}% system memory in use`;
+            }
+            return null;
+        }
+        // NVIDIA GPU
+        const raw = execSync("nvidia-smi --query-gpu=memory.used,memory.total --format=csv,noheader,nounits", {
+            encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+        });
+        const parts = raw.trim().split(",").map(s => s.trim());
+        if (parts.length === 2) {
+            return `${parts[0]} MiB / ${parts[1]} MiB GPU memory`;
+        }
+    }
+    catch { /* no GPU info available */ }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemaxxing",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Open-source terminal coding agent. Connect any LLM. Max your code.",
   "main": "dist/index.js",
   "bin": {

package/src/config.ts

@@ -24,6 +24,7 @@ export interface CodemaxxingConfig {
     contextCompressionThreshold?: number;
     architectModel?: string;
     autoLint?: boolean;
+    stopOllamaOnExit?: boolean;
   };
 }
 
@@ -138,6 +139,20 @@ export function loadConfig(): CodemaxxingConfig {
   }
 }
 
+/** Save config to disk (merges with existing) */
+export function saveConfig(updates: Partial<CodemaxxingConfig>): void {
+  const current = loadConfig();
+  const merged = {
+    ...current,
+    ...updates,
+    defaults: { ...current.defaults, ...(updates.defaults ?? {}) },
+  };
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+}
+
 /**
  * Apply CLI overrides to a provider config
  */