codemaxxing 0.3.1 → 0.4.1

package/src/utils/hardware.ts

@@ -0,0 +1,131 @@
+import os from "os";
+import { execSync } from "child_process";
+
+export interface HardwareInfo {
+  cpu: { name: string; cores: number; speed: number };
+  ram: number; // bytes
+  gpu: { name: string; vram: number } | null; // vram in bytes, null if no GPU
+  os: "macos" | "linux" | "windows";
+  appleSilicon: boolean;
+}
+
+function getOS(): "macos" | "linux" | "windows" {
+  switch (process.platform) {
+    case "darwin": return "macos";
+    case "win32": return "windows";
+    default: return "linux";
+  }
+}
+
+function getCPU(): { name: string; cores: number; speed: number } {
+  const cpus = os.cpus();
+  return {
+    name: cpus[0]?.model?.trim() ?? "Unknown CPU",
+    cores: cpus.length,
+    speed: cpus[0]?.speed ?? 0, // MHz
+  };
+}
+
+function getGPU(platform: "macos" | "linux" | "windows"): { name: string; vram: number } | null {
+  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: string = gpu.sppci_model ?? gpu._name ?? "Unknown GPU";
+        // On Apple Silicon, VRAM is shared (unified memory) — report total RAM
+        const vramStr: string = 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(): HardwareInfo {
+  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: number): string {
+  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/src/utils/models.ts

@@ -0,0 +1,217 @@
+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: "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";    // ❌
+  }
+}
+
+/** 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): "good" | "great" | "best" {
+  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: 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 };
+  }
+}

package/src/utils/ollama.ts

@@ -0,0 +1,232 @@
+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}`));
+    });
+  });
+}
+
+export interface OllamaModelInfo {
+  name: string;
+  size: number; // bytes
+  modified_at: string;
+  digest: string;
+}
+
+/** List models installed in Ollama with detailed info */
+export async function listInstalledModelsDetailed(): Promise<OllamaModelInfo[]> {
+  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; size: number; modified_at: string; digest: string }> };
+      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(): Promise<string[]> {
+  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(): Promise<{ ok: boolean; message: string }> {
+  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: any) {
+    return { ok: false, message: `Failed to stop Ollama: ${err.message}` };
+  }
+}
+
+/** Delete a model from disk */
+export function deleteModel(modelId: string): { ok: boolean; message: string } {
+  try {
+    execSync(`ollama rm ${modelId}`, { stdio: ["pipe", "pipe", "pipe"], timeout: 30000 });
+    return { ok: true, message: `Deleted ${modelId}` };
+  } catch (err: any) {
+    return { ok: false, message: `Failed to delete ${modelId}: ${err.stderr?.toString().trim() || err.message}` };
+  }
+}
+
+/** Get GPU memory usage info (best-effort) */
+export function getGPUMemoryUsage(): string | null {
+  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;
+}