codemaxxing 0.3.1 → 0.4.0

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