loclaude 0.0.1-alpha.2 → 0.0.1-alpha.3

package/libs/cli/dist/index.js

@@ -277,6 +277,76 @@ var require_bytes = __commonJS((exports, module) => {
   }
 });
 
+// ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
 // ../../node_modules/.bun/cac@6.7.14/node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
 function toArr(any) {
@@ -2674,15 +2744,67 @@ var dist_default3 = createPrompt((config, done) => {
 // lib/utils.ts
 var import_bytes = __toESM(require_bytes(), 1);
 
+// lib/output.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var brand = (text) => import_picocolors.default.cyan(import_picocolors.default.bold(text));
+var success = (text) => `${import_picocolors.default.green("✓")} ${text}`;
+var warn = (text) => `${import_picocolors.default.yellow("⚠")} ${text}`;
+var error = (text) => `${import_picocolors.default.red("✗")} ${text}`;
+var info = (text) => `${import_picocolors.default.cyan("ℹ")} ${text}`;
+var dim = (text) => import_picocolors.default.dim(text);
+var green = (text) => import_picocolors.default.green(text);
+var yellow = (text) => import_picocolors.default.yellow(text);
+var red = (text) => import_picocolors.default.red(text);
+var cyan = (text) => import_picocolors.default.cyan(text);
+var magenta = (text) => import_picocolors.default.magenta(text);
+function header(text) {
+  console.log("");
+  console.log(brand(`  ${text}`));
+  console.log(import_picocolors.default.dim("  " + "─".repeat(text.length + 2)));
+}
+function labelValue(label, value) {
+  console.log(`  ${import_picocolors.default.dim(label + ":")} ${value}`);
+}
+function statusLine(status, name, message, extra) {
+  const icons = { ok: "✓", warning: "⚠", error: "✗" };
+  const colors = { ok: import_picocolors.default.green, warning: import_picocolors.default.yellow, error: import_picocolors.default.red };
+  let line = `${colors[status](icons[status])} ${name}: ${message}`;
+  if (extra) {
+    line += ` ${import_picocolors.default.dim(`(${extra})`)}`;
+  }
+  return line;
+}
+function tableRow(columns, widths) {
+  return columns.map((col, i) => {
+    const width = widths[i] || col.length;
+    return col.padEnd(width);
+  }).join("  ");
+}
+function tableHeader(columns, widths) {
+  const headerRow = tableRow(columns.map((c) => import_picocolors.default.bold(c)), widths);
+  const underlineRow = widths.map((w) => "─".repeat(w)).join("  ");
+  console.log(headerRow);
+  console.log(import_picocolors.default.dim(underlineRow));
+}
+function url(urlStr) {
+  return import_picocolors.default.underline(import_picocolors.default.cyan(urlStr));
+}
+function cmd(command) {
+  return import_picocolors.default.cyan(command);
+}
+function file(filePath) {
+  return import_picocolors.default.magenta(filePath);
+}
+
 // lib/spawn.ts
-async function spawn(cmd, opts = {}) {
-  const command = cmd[0];
-  const args = cmd.slice(1);
+async function spawn(cmd2, opts = {}) {
+  const command = cmd2[0];
+  const args = cmd2.slice(1);
   if (command === undefined) {
     throw new Error("No command provided");
   }
   if (typeof Bun !== "undefined") {
-    const proc = Bun.spawn(cmd, {
+    const proc = Bun.spawn(cmd2, {
       env: opts.env ?? process.env,
       cwd: opts.cwd ?? process.cwd(),
       stdin: opts.stdin ?? "inherit",
@@ -2702,14 +2824,14 @@ async function spawn(cmd, opts = {}) {
     });
   }
 }
-async function spawnCapture(cmd, opts = {}) {
-  const command = cmd[0];
-  const args = cmd.slice(1);
+async function spawnCapture(cmd2, opts = {}) {
+  const command = cmd2[0];
+  const args = cmd2.slice(1);
   if (command === undefined) {
     throw new Error("No command provided");
   }
   if (typeof Bun !== "undefined") {
-    const proc = Bun.spawn(cmd, {
+    const proc = Bun.spawn(cmd2, {
       env: opts.env ?? process.env,
       cwd: opts.cwd,
       stdin: opts.stdin ?? "ignore",
@@ -2744,17 +2866,17 @@ async function spawnCapture(cmd, opts = {}) {
     });
   }
 }
-async function commandExists(cmd) {
+async function commandExists(cmd2) {
   try {
-    const result = await spawnCapture(process.platform === "win32" ? ["where", cmd] : ["which", cmd]);
+    const result = await spawnCapture(process.platform === "win32" ? ["where", cmd2] : ["which", cmd2]);
     return result.exitCode === 0;
   } catch {
     return false;
   }
 }
-async function getCommandVersion(cmd) {
+async function getCommandVersion(cmd2) {
   try {
-    const result = await spawnCapture([cmd, "--version"]);
+    const result = await spawnCapture([cmd2, "--version"]);
     if (result.exitCode === 0 && result.stdout) {
       return result.stdout.trim().split(`
 `)[0] ?? null;
@@ -2775,33 +2897,100 @@ async function fetchOllamaModels() {
   const data = await response.json();
   return data.models ?? [];
 }
+async function fetchRunningModels() {
+  const ollamaUrl = getOllamaUrl();
+  try {
+    const response = await fetch(`${ollamaUrl}/api/ps`, {
+      signal: AbortSignal.timeout(5000)
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return data.models ?? [];
+  } catch (error2) {
+    return [];
+  }
+}
+async function isModelLoaded(modelName) {
+  const runningModels = await fetchRunningModels();
+  return runningModels.some((m) => m.model === modelName || m.name === modelName || m.model.startsWith(modelName + ":") || modelName.startsWith(m.model));
+}
+async function loadModel(modelName, keepAlive = "10m") {
+  const ollamaUrl = getOllamaUrl();
+  const response = await fetch(`${ollamaUrl}/api/generate`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: modelName,
+      prompt: "",
+      stream: false,
+      keep_alive: keepAlive
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to load model: ${response.statusText}`);
+  }
+  await response.json();
+}
+async function ensureModelLoaded(modelName) {
+  const isLoaded = await isModelLoaded(modelName);
+  if (isLoaded) {
+    console.log(dim(`  Model ${magenta(modelName)} is already loaded`));
+    return;
+  }
+  console.log(info(`Loading model ${magenta(modelName)}...`));
+  console.log(dim("  This may take a moment on first run"));
+  try {
+    await loadModel(modelName, "10m");
+    console.log(success(`Model ${magenta(modelName)} loaded (keep_alive: 10m)`));
+  } catch (error2) {
+    console.log(warn(`Could not pre-load model (will load on first request)`));
+    console.log(dim(`  ${error2 instanceof Error ? error2.message : "Unknown error"}`));
+  }
+}
 async function selectModelInteractively() {
   const ollamaUrl = getOllamaUrl();
   let models;
   try {
     models = await fetchOllamaModels();
-  } catch (error) {
-    console.error("Error: Could not connect to Ollama at", ollamaUrl);
-    console.error("Make sure Ollama is running: loclaude docker-up");
+  } catch (error2) {
+    console.log(warn(`Could not connect to Ollama at ${ollamaUrl}`));
+    console.log(dim("  Make sure Ollama is running: loclaude docker-up"));
     process.exit(1);
   }
   if (models.length === 0) {
-    console.error("Error: No models found in Ollama.");
-    console.error("Pull a model first: loclaude models-pull <model-name>");
+    console.log(warn("No models found in Ollama."));
+    console.log(dim("  Pull a model first: loclaude models-pull <model-name>"));
     process.exit(1);
   }
+  const runningModels = await fetchRunningModels();
+  const loadedModelNames = new Set(runningModels.map((m) => m.model));
   const selected = await dist_default3({
     message: "Select a model",
-    choices: models.map((model) => ({
-      name: `${model.name} (${import_bytes.default(model.size)})`,
-      value: model.name
-    }))
+    choices: models.map((model) => {
+      const isLoaded = loadedModelNames.has(model.name);
+      const loadedIndicator = isLoaded ? " [loaded]" : "";
+      return {
+        name: `${model.name} (${import_bytes.default(model.size)})${loadedIndicator}`,
+        value: model.name
+      };
+    })
   });
   return selected;
 }
 async function launchClaude(model, passthroughArgs) {
   const ollamaUrl = getOllamaUrl();
   const extraArgs = getClaudeExtraArgs();
+  console.log("");
+  console.log(cyan("Launching Claude Code with Ollama"));
+  console.log(dim(`  Model: ${magenta(model)}`));
+  console.log(dim(`  API:   ${ollamaUrl}`));
+  console.log("");
+  await ensureModelLoaded(model);
+  console.log("");
   const env = {
     ...process.env,
     ANTHROPIC_AUTH_TOKEN: "ollama",
@@ -2815,51 +3004,351 @@ async function launchClaude(model, passthroughArgs) {
 // lib/commands/init.ts
 import { existsSync as existsSync2, mkdirSync, writeFileSync, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
-var DOCKER_COMPOSE_TEMPLATE = `services:
+
+// lib/commands/doctor.ts
+async function checkDocker() {
+  const exists = await commandExists("docker");
+  if (!exists) {
+    return {
+      name: "Docker",
+      status: "error",
+      message: "Not installed",
+      hint: "Install Docker: https://docs.docker.com/get-docker/"
+    };
+  }
+  const version = await getCommandVersion("docker");
+  return {
+    name: "Docker",
+    status: "ok",
+    message: "Installed",
+    version: version ?? undefined
+  };
+}
+async function checkDockerCompose() {
+  const result = await spawnCapture(["docker", "compose", "version"]);
+  if (result.exitCode === 0) {
+    const version = result.stdout?.trim().split(`
+`)[0];
+    return {
+      name: "Docker Compose",
+      status: "ok",
+      message: "Installed (v2)",
+      version: version ?? undefined
+    };
+  }
+  const v1Exists = await commandExists("docker-compose");
+  if (v1Exists) {
+    const version = await getCommandVersion("docker-compose");
+    return {
+      name: "Docker Compose",
+      status: "warning",
+      message: "Using legacy v1",
+      version: version ?? undefined,
+      hint: "Consider upgrading to Docker Compose v2"
+    };
+  }
+  return {
+    name: "Docker Compose",
+    status: "error",
+    message: "Not installed",
+    hint: "Docker Compose is included with Docker Desktop, or install separately"
+  };
+}
+async function checkNvidiaSmi() {
+  const exists = await commandExists("nvidia-smi");
+  if (!exists) {
+    return {
+      name: "NVIDIA GPU",
+      status: "warning",
+      message: "nvidia-smi not found",
+      hint: "GPU support requires NVIDIA drivers. CPU-only mode will be used."
+    };
+  }
+  const result = await spawnCapture(["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"]);
+  if (result.exitCode === 0 && result.stdout) {
+    const gpus = result.stdout.trim().split(`
+`).filter(Boolean);
+    return {
+      name: "NVIDIA GPU",
+      status: "ok",
+      message: `${gpus.length} GPU(s) detected`,
+      version: gpus[0]
+    };
+  }
+  return {
+    name: "NVIDIA GPU",
+    status: "warning",
+    message: "nvidia-smi failed",
+    hint: "GPU may not be available. Check NVIDIA drivers."
+  };
+}
+async function checkNvidiaContainerToolkit() {
+  const result = await spawnCapture(["docker", "info", "--format", "{{.Runtimes}}"]);
+  if (result.exitCode === 0 && result.stdout?.includes("nvidia")) {
+    return {
+      name: "NVIDIA Container Toolkit",
+      status: "ok",
+      message: "nvidia runtime available"
+    };
+  }
+  return {
+    name: "NVIDIA Container Toolkit",
+    status: "warning",
+    message: "nvidia runtime not found",
+    hint: "Install: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html"
+  };
+}
+async function checkClaude() {
+  const exists = await commandExists("claude");
+  if (!exists) {
+    return {
+      name: "Claude Code",
+      status: "error",
+      message: "Not installed",
+      hint: "Install: npm install -g @anthropic-ai/claude-code"
+    };
+  }
+  const version = await getCommandVersion("claude");
+  return {
+    name: "Claude Code",
+    status: "ok",
+    message: "Installed",
+    version: version ?? undefined
+  };
+}
+async function checkOllamaConnection() {
+  const ollamaUrl = getOllamaUrl();
+  try {
+    const response = await fetch(`${ollamaUrl}/api/tags`, {
+      signal: AbortSignal.timeout(5000)
+    });
+    if (response.ok) {
+      const data = await response.json();
+      const modelCount = data.models?.length ?? 0;
+      return {
+        name: "Ollama API",
+        status: "ok",
+        message: `Connected (${modelCount} model${modelCount === 1 ? "" : "s"})`,
+        version: ollamaUrl
+      };
+    }
+    return {
+      name: "Ollama API",
+      status: "warning",
+      message: `HTTP ${response.status}`,
+      hint: "Ollama may not be running. Try: loclaude docker-up"
+    };
+  } catch (error3) {
+    return {
+      name: "Ollama API",
+      status: "warning",
+      message: "Not reachable",
+      hint: `Cannot connect to ${ollamaUrl}. Start Ollama: loclaude docker-up`
+    };
+  }
+}
+function formatCheck(check) {
+  let line = statusLine(check.status, check.name, check.message, check.version);
+  if (check.hint) {
+    line += `
+    ${dim("→")} ${dim(check.hint)}`;
+  }
+  return line;
+}
+async function doctor() {
+  header("System Health Check");
+  console.log("");
+  const checks = await Promise.all([
+    checkDocker(),
+    checkDockerCompose(),
+    checkNvidiaSmi(),
+    checkNvidiaContainerToolkit(),
+    checkClaude(),
+    checkOllamaConnection()
+  ]);
+  for (const check of checks) {
+    console.log(formatCheck(check));
+  }
+  const errors2 = checks.filter((c) => c.status === "error");
+  const warnings = checks.filter((c) => c.status === "warning");
+  console.log("");
+  if (errors2.length > 0) {
+    console.log(red(`${errors2.length} error(s) found.`) + " Fix these before proceeding.");
+    process.exit(1);
+  } else if (warnings.length > 0) {
+    console.log(yellow(`${warnings.length} warning(s).`) + " loclaude may work with limited functionality.");
+  } else {
+    console.log(green("All checks passed!") + " Ready to use loclaude.");
+  }
+}
+async function hasNvidiaGpu() {
+  const exists = await commandExists("nvidia-smi");
+  if (!exists)
+    return false;
+  const result = await spawnCapture(["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"]);
+  return result.exitCode === 0 && Boolean(result.stdout?.trim());
+}
+
+// lib/commands/init.ts
+var DOCKER_COMPOSE_TEMPLATE_GPU = `# =============================================================================
+# LOCLAUDE DOCKER COMPOSE - GPU MODE
+# =============================================================================
+# This configuration runs Ollama with NVIDIA GPU acceleration for fast inference.
+# Generated by: loclaude init
+#
+# Prerequisites:
+#   - NVIDIA GPU with CUDA support
+#   - NVIDIA drivers installed on host
+#   - NVIDIA Container Toolkit: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit
+#
+# Quick test for GPU support:
+#   docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi
+#
+# =============================================================================
+
+services:
+  # ===========================================================================
+  # OLLAMA - Local LLM Inference Server
+  # ===========================================================================
+  # Ollama provides the AI backend that Claude Code connects to.
+  # It runs large language models locally on your hardware.
+  #
+  # API Documentation: https://github.com/ollama/ollama/blob/main/docs/api.md
+  # Model Library: https://ollama.com/library
+  # ===========================================================================
   ollama:
+    # Official Ollama image - 'latest' ensures newest features and model support
     image: ollama/ollama:latest
+
+    # Fixed container name for easy CLI access:
+    #   docker exec ollama ollama list
+    #   docker logs ollama
     container_name: ollama
+
+    # NVIDIA Container Runtime - Required for GPU access
+    # This makes CUDA libraries available inside the container
     runtime: nvidia
+
     environment:
+      # ---------------------------------------------------------------------------
+      # GPU Configuration
+      # ---------------------------------------------------------------------------
+      # NVIDIA_VISIBLE_DEVICES: Which GPUs to expose to the container
+      #   - 'all': Use all available GPUs (recommended for most setups)
+      #   - '0': Use only GPU 0
+      #   - '0,1': Use GPUs 0 and 1
       - NVIDIA_VISIBLE_DEVICES=all
+
+      # NVIDIA_DRIVER_CAPABILITIES: What GPU features to enable
+      #   - 'compute': CUDA compute (required for inference)
+      #   - 'utility': nvidia-smi and other tools
       - NVIDIA_DRIVER_CAPABILITIES=compute,utility
+
+      # ---------------------------------------------------------------------------
+      # Ollama Configuration (Optional)
+      # ---------------------------------------------------------------------------
+      # Uncomment these to customize Ollama behavior:
+
+      # Maximum number of models loaded in memory simultaneously
+      # Lower this if you're running out of VRAM
+      # - OLLAMA_MAX_LOADED_MODELS=1
+
+      # Maximum parallel inference requests per model
+      # Higher values use more VRAM but handle more concurrent requests
+      # - OLLAMA_NUM_PARALLEL=1
+
+      # Enable debug logging for troubleshooting
+      # - OLLAMA_DEBUG=1
+
+      # Custom model storage location (inside container)
+      # - OLLAMA_MODELS=/root/.ollama
+
     volumes:
+      # ---------------------------------------------------------------------------
+      # Model Storage
+      # ---------------------------------------------------------------------------
+      # Maps ./models on your host to /root/.ollama in the container
+      # This persists downloaded models across container restarts
+      #
+      # Disk space requirements (approximate):
+      #   - 7B model:  ~4GB
+      #   - 13B model: ~8GB
+      #   - 30B model: ~16GB
+      #   - 70B model: ~40GB
       - ./models:/root/.ollama
+
     ports:
+      # Ollama API port - access at http://localhost:11434
+      # Used by Claude Code and other Ollama clients
       - "11434:11434"
+
+    # Restart policy - keeps Ollama running unless manually stopped
     restart: unless-stopped
+
     healthcheck:
+      # Verify Ollama is responsive by listing models
       test: ["CMD", "ollama", "list"]
-      interval: 300s
-      timeout: 2s
-      retries: 3
-      start_period: 40s
+      interval: 300s      # Check every 5 minutes
+      timeout: 2s         # Fail if no response in 2 seconds
+      retries: 3          # Mark unhealthy after 3 consecutive failures
+      start_period: 40s   # Grace period for initial model loading
+
     deploy:
       resources:
         reservations:
           devices:
+            # Request GPU access from Docker
             - driver: nvidia
-              count: all
-              capabilities: [gpu]
+              count: all           # Use all available GPUs
+              capabilities: [gpu]  # Request GPU compute capability
 
+  # ===========================================================================
+  # OPEN WEBUI - Chat Interface (Optional)
+  # ===========================================================================
+  # Open WebUI provides a ChatGPT-like interface for your local models.
+  # Access at http://localhost:3000 after starting containers.
+  #
+  # Features:
+  #   - Multi-model chat interface
+  #   - Conversation history
+  #   - Model management UI
+  #   - RAG/document upload support
+  #
+  # Documentation: https://docs.openwebui.com/
+  # ===========================================================================
   open-webui:
+    # CUDA-enabled image for GPU-accelerated features (embeddings, etc.)
+    # Change to :main if you don't need GPU features in the UI
     image: ghcr.io/open-webui/open-webui:cuda
+
     container_name: open-webui
+
     ports:
+      # Web UI port - access at http://localhost:3000
       - "3000:8080"
+
     environment:
+      # Tell Open WebUI where to find Ollama
+      # Uses Docker internal networking (service name as hostname)
       - OLLAMA_BASE_URL=http://ollama:11434
+
+    # Wait for Ollama to be ready before starting
     depends_on:
       - ollama
+
     restart: unless-stopped
+
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
       interval: 30s
       timeout: 10s
       retries: 3
       start_period: 60s
+
     volumes:
+      # Persistent storage for conversations, settings, and user data
       - open-webui:/app/backend/data
+
     deploy:
       resources:
         reservations:
@@ -2868,32 +3357,174 @@ var DOCKER_COMPOSE_TEMPLATE = `services:
               count: all
               capabilities: [gpu]
 
+# =============================================================================
+# VOLUMES
+# =============================================================================
+# Named volumes for persistent data that survives container recreation
 volumes:
   open-webui:
+    # Open WebUI data: conversations, user settings, uploads
+    # Located at /var/lib/docker/volumes/open-webui/_data on host
 `;
-var CONFIG_TEMPLATE = `{
-  "ollama": {
+var DOCKER_COMPOSE_TEMPLATE_CPU = `# =============================================================================
+# LOCLAUDE DOCKER COMPOSE - CPU MODE
+# =============================================================================
+# This configuration runs Ollama in CPU-only mode.
+# Inference will be slower than GPU mode but works on any system.
+# Generated by: loclaude init --no-gpu
+#
+# Performance notes:
+#   - 7B models: ~10-20 tokens/sec on modern CPUs
+#   - Larger models will be significantly slower
+#   - Consider using quantized models (Q4_K_M, Q5_K_M) for better performance
+#
+# Recommended CPU-optimized models:
+#   - llama3.2:3b (fast, good for simple tasks)
+#   - qwen2.5-coder:7b (coding tasks)
+#   - gemma2:9b (general purpose)
+#
+# =============================================================================
+
+services:
+  # ===========================================================================
+  # OLLAMA - Local LLM Inference Server (CPU Mode)
+  # ===========================================================================
+  # Ollama provides the AI backend that Claude Code connects to.
+  # Running in CPU mode - no GPU acceleration.
+  #
+  # API Documentation: https://github.com/ollama/ollama/blob/main/docs/api.md
+  # Model Library: https://ollama.com/library
+  # ===========================================================================
+  ollama:
+    # Official Ollama image - works for both CPU and GPU
+    image: ollama/ollama:latest
+
+    # Fixed container name for easy CLI access
+    container_name: ollama
+
+    # NOTE: No 'runtime: nvidia' - running in CPU mode
+
+    environment:
+      # ---------------------------------------------------------------------------
+      # Ollama Configuration (Optional)
+      # ---------------------------------------------------------------------------
+      # Uncomment these to customize Ollama behavior:
+
+      # Maximum number of models loaded in memory simultaneously
+      # CPU mode uses system RAM instead of VRAM
+      # - OLLAMA_MAX_LOADED_MODELS=1
+
+      # Number of CPU threads to use (default: auto-detect)
+      # - OLLAMA_NUM_THREADS=8
+
+      # Enable debug logging for troubleshooting
+      # - OLLAMA_DEBUG=1
+
+    volumes:
+      # ---------------------------------------------------------------------------
+      # Model Storage
+      # ---------------------------------------------------------------------------
+      # Maps ./models on your host to /root/.ollama in the container
+      # This persists downloaded models across container restarts
+      - ./models:/root/.ollama
+
+    ports:
+      # Ollama API port - access at http://localhost:11434
+      - "11434:11434"
+
+    restart: unless-stopped
+
+    healthcheck:
+      test: ["CMD", "ollama", "list"]
+      interval: 300s
+      timeout: 2s
+      retries: 3
+      start_period: 40s
+
+    # CPU resource limits (optional - uncomment to constrain)
+    # deploy:
+    #   resources:
+    #     limits:
+    #       cpus: '4'      # Limit to 4 CPU cores
+    #       memory: 16G    # Limit to 16GB RAM
+    #     reservations:
+    #       cpus: '2'      # Reserve at least 2 cores
+    #       memory: 8G     # Reserve at least 8GB RAM
+
+  # ===========================================================================
+  # OPEN WEBUI - Chat Interface (Optional)
+  # ===========================================================================
+  # Open WebUI provides a ChatGPT-like interface for your local models.
+  # Access at http://localhost:3000 after starting containers.
+  #
+  # Documentation: https://docs.openwebui.com/
+  # ===========================================================================
+  open-webui:
+    # Standard image (no CUDA) - smaller download, CPU-only features
+    image: ghcr.io/open-webui/open-webui:main
+
+    container_name: open-webui
+
+    ports:
+      - "3000:8080"
+
+    environment:
+      - OLLAMA_BASE_URL=http://ollama:11434
+
+    depends_on:
+      - ollama
+
+    restart: unless-stopped
+
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+
+    volumes:
+      - open-webui:/app/backend/data
+
+# =============================================================================
+# VOLUMES
+# =============================================================================
+volumes:
+  open-webui:
+`;
+function getConfigTemplate(gpu) {
+  return `{
+  "ollama": {
     "url": "http://localhost:11434",
-    "defaultModel": "qwen3-coder:30b"
+    "defaultModel": "${gpu ? "qwen3-coder:30b" : "qwen2.5-coder:7b"}"
   },
   "docker": {
     "composeFile": "./docker-compose.yml",
-    "gpu": true
+    "gpu": ${gpu}
   }
 }
 `;
+}
 var GITIGNORE_TEMPLATE = `# Ollama models (large binary files)
+# These are downloaded by Ollama and can be re-pulled anytime
 models/
 `;
-var MISE_TOML_TEMPLATE = `# Mise task runner configuration
-# Run \`mise tasks\` to see all available tasks
-# https://mise.jdx.dev/
+var MISE_TOML_TEMPLATE = `# =============================================================================
+# MISE TASK RUNNER CONFIGURATION
+# =============================================================================
+# Mise is a task runner that provides convenient shortcuts for common operations.
+# Run 'mise tasks' to see all available tasks.
+#
+# Documentation: https://mise.jdx.dev/
+# Install: curl https://mise.jdx.dev/install.sh | sh
+# =============================================================================
 
 [tasks]
 
 # =============================================================================
 # Docker Management
 # =============================================================================
+# Commands for managing the Ollama and Open WebUI containers
 
 [tasks.up]
 description = "Start Ollama and Open WebUI containers"
@@ -2918,6 +3549,7 @@ run = "loclaude docker-logs --follow"
 # =============================================================================
 # Model Management
 # =============================================================================
+# Commands for managing Ollama models (download, remove, list)
 
 [tasks.models]
 description = "List installed models"
@@ -2927,9 +3559,14 @@ run = "loclaude models"
 description = "Pull a model (usage: mise run pull <model-name>)"
 run = "loclaude models-pull {{arg(name='model')}}"
 
+[tasks."pull:recommended"]
+description = "Pull the recommended coding model"
+run = "loclaude models-pull qwen3-coder:30b"
+
 # =============================================================================
 # Claude Code
 # =============================================================================
+# Commands for running Claude Code with local Ollama
 
 [tasks.claude]
 description = "Run Claude Code with local Ollama"
@@ -2942,14 +3579,19 @@ run = "loclaude run -m {{arg(name='model')}}"
 # =============================================================================
 # Diagnostics
 # =============================================================================
+# Commands for checking system health and troubleshooting
 
 [tasks.doctor]
 description = "Check system requirements"
 run = "loclaude doctor"
 
 [tasks.gpu]
-description = "Check GPU status"
+description = "Check GPU status (requires NVIDIA GPU)"
 run = "docker exec ollama nvidia-smi"
+
+[tasks.config]
+description = "Show current configuration"
+run = "loclaude config"
 `;
 var README_TEMPLATE = `# Project Name
 
@@ -2958,18 +3600,24 @@ var README_TEMPLATE = `# Project Name
 ## Prerequisites
 
 - [Docker](https://docs.docker.com/get-docker/) with Docker Compose v2
-- [NVIDIA GPU](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) with drivers and container toolkit
 - [mise](https://mise.jdx.dev/) task runner (recommended)
 - [loclaude](https://www.npmjs.com/package/loclaude) CLI (\`npm install -g loclaude\`)
 
+### For GPU Mode (Recommended)
+
+- [NVIDIA GPU](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) with CUDA support
+- NVIDIA drivers installed on host
+- [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
+
 ## Quick Start
 
 \`\`\`bash
 # Start the LLM backend (Ollama + Open WebUI)
 mise run up
 
-# Pull a model
-mise run pull qwen3-coder:30b
+# Pull a model (adjust based on your hardware)
+mise run pull qwen3-coder:30b  # GPU: 30B model (~16GB VRAM)
+mise run pull qwen2.5-coder:7b # CPU: 7B model (faster)
 
 # Run Claude Code with local LLM
 mise run claude
@@ -3004,7 +3652,7 @@ Run \`mise tasks\` to see all available commands.
 \`\`\`
 .
 ├── .claude/
-│   └── CLAUDE.md          # Claude Code instructions
+│   └── CLAUDE.md          # Claude Code project instructions
 ├── .loclaude/
 │   └── config.json        # Loclaude configuration
 ├── models/                # Ollama model storage (gitignored)
@@ -3036,6 +3684,25 @@ Run \`mise tasks\` to see all available commands.
 |----------|-------------|---------|
 | \`OLLAMA_URL\` | Ollama API endpoint | \`http://localhost:11434\` |
 | \`OLLAMA_MODEL\` | Default model name | \`qwen3-coder:30b\` |
+| \`LOCLAUDE_GPU\` | Enable GPU mode | \`true\` |
+
+## Recommended Models
+
+### For GPU (NVIDIA with 16GB+ VRAM)
+
+| Model | Size | Use Case |
+|-------|------|----------|
+| \`qwen3-coder:30b\` | ~16GB | Best coding performance |
+| \`gpt-oss:20b\` | ~12GB | General purpose |
+| \`glm-4.7:cloud\` | Cloud | No local storage needed |
+
+### For CPU or Limited VRAM
+
+| Model | Size | Use Case |
+|-------|------|----------|
+| \`qwen2.5-coder:7b\` | ~4GB | Coding on CPU |
+| \`llama3.2:3b\` | ~2GB | Fast, simple tasks |
+| \`gemma2:9b\` | ~5GB | General purpose |
 
 ## Troubleshooting
 
@@ -3057,6 +3724,12 @@ mise run logs
 mise run down && mise run up
 \`\`\`
 
+### GPU Not Detected
+
+1. Verify NVIDIA drivers: \`nvidia-smi\`
+2. Check Docker GPU access: \`docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi\`
+3. Install NVIDIA Container Toolkit if missing
+
 ## License
 
 MIT
@@ -3123,304 +3796,153 @@ async function init(options = {}) {
   const claudeDir = join2(cwd, ".claude");
   const claudeMdPath = join2(claudeDir, "CLAUDE.md");
   const readmePath = join2(cwd, "README.md");
-  console.log(`Initializing loclaude project...
-`);
+  header("Initializing loclaude project");
+  console.log("");
+  let gpuMode;
+  if (options.gpu === false) {
+    gpuMode = false;
+    console.log(info("CPU-only mode (--no-gpu)"));
+  } else if (options.gpu === true) {
+    gpuMode = true;
+    console.log(info("GPU mode enabled (--gpu)"));
+  } else {
+    console.log(dim("  Detecting GPU..."));
+    gpuMode = await hasNvidiaGpu();
+    if (gpuMode) {
+      console.log(success("NVIDIA GPU detected - using GPU mode"));
+    } else {
+      console.log(warn("No NVIDIA GPU detected - using CPU mode"));
+      console.log(dim("    Use --gpu to force GPU mode if you have an NVIDIA GPU"));
+    }
+  }
+  console.log("");
   if (existsSync2(readmePath) && !options.force) {
-    console.log("⚠️  README.md already exists");
+    console.log(warn(`${file("README.md")} already exists`));
   } else {
     writeFileSync(readmePath, README_TEMPLATE);
-    console.log("✓ Created README.md");
+    console.log(success(`Created ${file("README.md")}`));
   }
   if (existsSync2(composePath) && !options.force) {
-    console.log("⚠️  docker-compose.yml already exists");
-    console.log(`   Use --force to overwrite
-`);
+    console.log(warn(`${file("docker-compose.yml")} already exists`));
+    console.log(dim("    Use --force to overwrite"));
   } else {
-    let composeContent = DOCKER_COMPOSE_TEMPLATE;
+    let composeContent = gpuMode ? DOCKER_COMPOSE_TEMPLATE_GPU : DOCKER_COMPOSE_TEMPLATE_CPU;
     if (options.noWebui) {
-      composeContent = composeContent.replace(/\n  open-webui:[\s\S]*?capabilities: \[gpu\]\n/m, `
-`).replace(/\nvolumes:\n  open-webui:\n/, `
+      composeContent = composeContent.replace(/\n  # =+\n  # OPEN WEBUI[\s\S]*?capabilities: \[gpu\]\n/m, `
+`).replace(/\n  # =+\n  # OPEN WEBUI[\s\S]*?open-webui:\/app\/backend\/data\n/m, `
+`).replace(/\nvolumes:\n  open-webui:\n.*$/m, `
 `);
     }
     writeFileSync(composePath, composeContent);
-    console.log("✓ Created docker-compose.yml");
+    const modeLabel = gpuMode ? cyan("GPU") : cyan("CPU");
+    console.log(success(`Created ${file("docker-compose.yml")} (${modeLabel} mode)`));
   }
   if (existsSync2(miseTomlPath) && !options.force) {
-    console.log("⚠️  mise.toml already exists");
+    console.log(warn(`${file("mise.toml")} already exists`));
   } else {
     writeFileSync(miseTomlPath, MISE_TOML_TEMPLATE);
-    console.log("✓ Created mise.toml");
+    console.log(success(`Created ${file("mise.toml")}`));
   }
   if (!existsSync2(claudeDir)) {
     mkdirSync(claudeDir, { recursive: true });
   }
   if (existsSync2(claudeMdPath) && !options.force) {
-    console.log("⚠️  .claude/CLAUDE.md already exists");
+    console.log(warn(`${file(".claude/CLAUDE.md")} already exists`));
   } else {
     writeFileSync(claudeMdPath, CLAUDE_MD_TEMPLATE);
-    console.log("✓ Created .claude/CLAUDE.md");
+    console.log(success(`Created ${file(".claude/CLAUDE.md")}`));
   }
   if (!existsSync2(configDir)) {
     mkdirSync(configDir, { recursive: true });
-    console.log("✓ Created .loclaude/ directory");
+    console.log(success(`Created ${file(".loclaude/")} directory`));
   }
   if (existsSync2(configPath) && !options.force) {
-    console.log("⚠️  .loclaude/config.json already exists");
+    console.log(warn(`${file(".loclaude/config.json")} already exists`));
   } else {
-    writeFileSync(configPath, CONFIG_TEMPLATE);
-    console.log("✓ Created .loclaude/config.json");
+    writeFileSync(configPath, getConfigTemplate(gpuMode));
+    console.log(success(`Created ${file(".loclaude/config.json")}`));
   }
   if (!existsSync2(modelsDir)) {
     mkdirSync(modelsDir, { recursive: true });
-    console.log("✓ Created models/ directory");
+    console.log(success(`Created ${file("models/")} directory`));
   }
   if (existsSync2(gitignorePath)) {
     const existing = readFileSync2(gitignorePath, "utf-8");
     if (!existing.includes("models/")) {
       writeFileSync(gitignorePath, existing + `
 ` + GITIGNORE_TEMPLATE);
-      console.log("✓ Updated .gitignore");
+      console.log(success(`Updated ${file(".gitignore")}`));
     }
   } else {
     writeFileSync(gitignorePath, GITIGNORE_TEMPLATE);
-    console.log("✓ Created .gitignore");
-  }
-  console.log(`
-\uD83C\uDF89 Project initialized!
-`);
-  console.log("Next steps:");
-  console.log("  1. Start containers:  mise run up");
-  console.log("  2. Pull a model:      mise run pull qwen3-coder:30b");
-  console.log("  3. Run Claude:        mise run claude");
-  console.log(`
-Service URLs:`);
-  console.log("  Ollama API:  http://localhost:11434");
-  if (!options.noWebui) {
-    console.log("  Open WebUI:  http://localhost:3000");
-  }
-}
-// lib/commands/doctor.ts
-async function checkDocker() {
-  const exists = await commandExists("docker");
-  if (!exists) {
-    return {
-      name: "Docker",
-      status: "error",
-      message: "Not installed",
-      hint: "Install Docker: https://docs.docker.com/get-docker/"
-    };
-  }
-  const version = await getCommandVersion("docker");
-  return {
-    name: "Docker",
-    status: "ok",
-    message: "Installed",
-    version: version ?? undefined
-  };
-}
-async function checkDockerCompose() {
-  const result = await spawnCapture(["docker", "compose", "version"]);
-  if (result.exitCode === 0) {
-    const version = result.stdout?.trim().split(`
-`)[0];
-    return {
-      name: "Docker Compose",
-      status: "ok",
-      message: "Installed (v2)",
-      version: version ?? undefined
-    };
-  }
-  const v1Exists = await commandExists("docker-compose");
-  if (v1Exists) {
-    const version = await getCommandVersion("docker-compose");
-    return {
-      name: "Docker Compose",
-      status: "warning",
-      message: "Using legacy v1",
-      version: version ?? undefined,
-      hint: "Consider upgrading to Docker Compose v2"
-    };
-  }
-  return {
-    name: "Docker Compose",
-    status: "error",
-    message: "Not installed",
-    hint: "Docker Compose is included with Docker Desktop, or install separately"
-  };
-}
-async function checkNvidiaSmi() {
-  const exists = await commandExists("nvidia-smi");
-  if (!exists) {
-    return {
-      name: "NVIDIA GPU",
-      status: "warning",
-      message: "nvidia-smi not found",
-      hint: "GPU support requires NVIDIA drivers. CPU-only mode will be used."
-    };
+    console.log(success(`Created ${file(".gitignore")}`));
   }
-  const result = await spawnCapture(["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"]);
-  if (result.exitCode === 0 && result.stdout) {
-    const gpus = result.stdout.trim().split(`
-`).filter(Boolean);
-    return {
-      name: "NVIDIA GPU",
-      status: "ok",
-      message: `${gpus.length} GPU(s) detected`,
-      version: gpus[0]
-    };
-  }
-  return {
-    name: "NVIDIA GPU",
-    status: "warning",
-    message: "nvidia-smi failed",
-    hint: "GPU may not be available. Check NVIDIA drivers."
-  };
-}
-async function checkNvidiaContainerToolkit() {
-  const result = await spawnCapture(["docker", "info", "--format", "{{.Runtimes}}"]);
-  if (result.exitCode === 0 && result.stdout?.includes("nvidia")) {
-    return {
-      name: "NVIDIA Container Toolkit",
-      status: "ok",
-      message: "nvidia runtime available"
-    };
-  }
-  return {
-    name: "NVIDIA Container Toolkit",
-    status: "warning",
-    message: "nvidia runtime not found",
-    hint: "Install: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html"
-  };
-}
-async function checkClaude() {
-  const exists = await commandExists("claude");
-  if (!exists) {
-    return {
-      name: "Claude Code",
-      status: "error",
-      message: "Not installed",
-      hint: "Install: npm install -g @anthropic-ai/claude-code"
-    };
-  }
-  const version = await getCommandVersion("claude");
-  return {
-    name: "Claude Code",
-    status: "ok",
-    message: "Installed",
-    version: version ?? undefined
-  };
-}
-async function checkOllamaConnection() {
-  const ollamaUrl = getOllamaUrl();
-  try {
-    const response = await fetch(`${ollamaUrl}/api/tags`, {
-      signal: AbortSignal.timeout(5000)
-    });
-    if (response.ok) {
-      const data = await response.json();
-      const modelCount = data.models?.length ?? 0;
-      return {
-        name: "Ollama API",
-        status: "ok",
-        message: `Connected (${modelCount} model${modelCount === 1 ? "" : "s"})`,
-        version: ollamaUrl
-      };
-    }
-    return {
-      name: "Ollama API",
-      status: "warning",
-      message: `HTTP ${response.status}`,
-      hint: "Ollama may not be running. Try: loclaude docker-up"
-    };
-  } catch (error) {
-    return {
-      name: "Ollama API",
-      status: "warning",
-      message: "Not reachable",
-      hint: `Cannot connect to ${ollamaUrl}. Start Ollama: loclaude docker-up`
-    };
-  }
-}
-function formatCheck(check) {
-  const icons = {
-    ok: "✓",
-    warning: "⚠",
-    error: "✗"
-  };
-  const colors = {
-    ok: "\x1B[32m",
-    warning: "\x1B[33m",
-    error: "\x1B[31m"
-  };
-  const reset = "\x1B[0m";
-  const icon = icons[check.status];
-  const color = colors[check.status];
-  let line = `${color}${icon}${reset} ${check.name}: ${check.message}`;
-  if (check.version) {
-    line += ` (${check.version})`;
-  }
-  if (check.hint) {
-    line += `
-    ${check.hint}`;
-  }
-  return line;
-}
-async function doctor() {
-  console.log(`Checking system requirements...
-`);
-  const checks = await Promise.all([
-    checkDocker(),
-    checkDockerCompose(),
-    checkNvidiaSmi(),
-    checkNvidiaContainerToolkit(),
-    checkClaude(),
-    checkOllamaConnection()
-  ]);
-  for (const check of checks) {
-    console.log(formatCheck(check));
-  }
-  const errors2 = checks.filter((c) => c.status === "error");
-  const warnings = checks.filter((c) => c.status === "warning");
+  const recommendedModel = gpuMode ? "qwen3-coder:30b" : "qwen2.5-coder:7b";
   console.log("");
-  if (errors2.length > 0) {
-    console.log(`\x1B[31m${errors2.length} error(s) found.\x1B[0m Fix these before proceeding.`);
-    process.exit(1);
-  } else if (warnings.length > 0) {
-    console.log(`\x1B[33m${warnings.length} warning(s).\x1B[0m loclaude may work with limited functionality.`);
-  } else {
-    console.log("\x1B[32mAll checks passed!\x1B[0m Ready to use loclaude.");
+  console.log(green("Project initialized!"));
+  console.log("");
+  console.log(cyan("Next steps:"));
+  console.log(`  1. Start containers:  ${cmd("mise run up")}`);
+  console.log(`  2. Pull a model:      ${cmd(`mise run pull ${recommendedModel}`)}`);
+  console.log(`  3. Run Claude:        ${cmd("mise run claude")}`);
+  console.log("");
+  console.log(cyan("Service URLs:"));
+  console.log(`  Ollama API:  ${url("http://localhost:11434")}`);
+  if (!options.noWebui) {
+    console.log(`  Open WebUI:  ${url("http://localhost:3000")}`);
   }
 }
 // lib/commands/config.ts
-import { inspect } from "util";
 async function configShow() {
   const config = loadConfig();
   const activePath = getActiveConfigPath();
-  console.log(`Current configuration:
-`);
-  console.log(inspect(config, false, 3, true));
-  console.log(`
----`);
+  header("Current Configuration");
+  console.log("");
+  console.log(cyan("Ollama:"));
+  labelValue("  URL", config.ollama.url);
+  labelValue("  Default Model", magenta(config.ollama.defaultModel));
+  console.log("");
+  console.log(cyan("Docker:"));
+  labelValue("  Compose File", config.docker.composeFile);
+  labelValue("  GPU Mode", config.docker.gpu ? green("enabled") : dim("disabled"));
+  console.log("");
+  console.log(cyan("Claude:"));
+  if (config.claude.extraArgs.length > 0) {
+    labelValue("  Extra Args", config.claude.extraArgs.join(" "));
+  } else {
+    labelValue("  Extra Args", dim("none"));
+  }
+  console.log("");
+  console.log(dim("─".repeat(40)));
   if (activePath) {
-    console.log(`Loaded from: ${activePath}`);
+    console.log(dim(`Loaded from: ${file(activePath)}`));
   } else {
-    console.log("Using default configuration (no config file found)");
+    console.log(dim("Using default configuration (no config file found)"));
   }
 }
 async function configPaths() {
   const paths = getConfigSearchPaths();
   const activePath = getActiveConfigPath();
-  console.log(`Config file search paths (in priority order):
-`);
-  for (const path of paths) {
-    const isActive = path === activePath;
-    const marker = isActive ? " ← active" : "";
-    console.log(`  ${path}${marker}`);
+  header("Config Search Paths");
+  console.log("");
+  console.log(dim("Files are checked in priority order (first found wins):"));
+  console.log("");
+  for (let i = 0;i < paths.length; i++) {
+    const configPath = paths[i];
+    if (!configPath)
+      continue;
+    const isActive = configPath === activePath;
+    const num = `${i + 1}.`;
+    if (isActive) {
+      console.log(`  ${num} ${file(configPath)} ${green("← active")}`);
+    } else {
+      console.log(`  ${num} ${dim(configPath)}`);
+    }
   }
+  console.log("");
   if (!activePath) {
-    console.log(`
-No config file found. Using defaults.`);
-    console.log("Run 'loclaude init' to create a project config.");
+    console.log(info("No config file found. Using defaults."));
+    console.log(dim(`  Run ${cmd("loclaude init")} to create a project config.`));
   }
 }
 // lib/commands/docker.ts
@@ -3459,42 +3981,44 @@ function getComposeCommand() {
 async function runCompose(args, options = {}) {
   const composeFile = options.file ?? findComposeFile();
   if (!composeFile) {
-    console.error("Error: No docker-compose.yml found");
-    console.error("Run 'loclaude init' to create one, or specify --file");
+    console.log(error("No docker-compose.yml found"));
+    console.log(dim(`  Run ${cmd("loclaude init")} to create one, or specify --file`));
     return 1;
   }
-  const cmd = [...getComposeCommand(), "-f", composeFile, ...args];
-  return spawn(cmd);
+  const cmd_args = [...getComposeCommand(), "-f", composeFile, ...args];
+  return spawn(cmd_args);
 }
 async function dockerUp(options = {}) {
   const args = ["up"];
   if (options.detach !== false) {
     args.push("-d");
   }
-  console.log(`Starting containers...
-`);
+  console.log(info("Starting containers..."));
+  console.log("");
   const exitCode = await runCompose(args, options);
   if (exitCode === 0) {
-    console.log(`
-✓ Containers started`);
-    console.log(`
-Service URLs:`);
-    console.log("  Ollama API:  http://localhost:11434");
-    console.log("  Open WebUI:  http://localhost:3000");
+    console.log("");
+    console.log(success("Containers started"));
+    console.log("");
+    console.log(cyan("Service URLs:"));
+    console.log(`  Ollama API:  ${url("http://localhost:11434")}`);
+    console.log(`  Open WebUI:  ${url("http://localhost:3000")}`);
   }
   process.exit(exitCode);
 }
 async function dockerDown(options = {}) {
-  console.log(`Stopping containers...
-`);
+  console.log(info("Stopping containers..."));
+  console.log("");
   const exitCode = await runCompose(["down"], options);
   if (exitCode === 0) {
-    console.log(`
-✓ Containers stopped`);
+    console.log("");
+    console.log(success("Containers stopped"));
   }
   process.exit(exitCode);
 }
 async function dockerStatus(options = {}) {
+  console.log(info("Container status:"));
+  console.log("");
   const exitCode = await runCompose(["ps"], options);
   process.exit(exitCode);
 }
@@ -3505,17 +4029,21 @@ async function dockerLogs(options = {}) {
   }
   if (options.service) {
     args.push(options.service);
+    console.log(info(`Logs for ${cyan(options.service)}:`));
+  } else {
+    console.log(info("Container logs:"));
   }
+  console.log("");
   const exitCode = await runCompose(args, options);
   process.exit(exitCode);
 }
 async function dockerRestart(options = {}) {
-  console.log(`Restarting containers...
-`);
+  console.log(info("Restarting containers..."));
+  console.log("");
   const exitCode = await runCompose(["restart"], options);
   if (exitCode === 0) {
-    console.log(`
-✓ Containers restarted`);
+    console.log("");
+    console.log(success("Containers restarted"));
   }
   process.exit(exitCode);
 }
@@ -3532,11 +4060,11 @@ async function fetchModels() {
     }
     const data = await response.json();
     return data.models ?? [];
-  } catch (error) {
-    if (error instanceof Error && error.name === "TimeoutError") {
+  } catch (error3) {
+    if (error3 instanceof Error && error3.name === "TimeoutError") {
       throw new Error(`Connection to Ollama timed out (${ollamaUrl})`);
     }
-    throw error;
+    throw error3;
   }
 }
 async function isOllamaInDocker() {
@@ -3551,83 +4079,99 @@ async function runOllamaCommand(args) {
     return spawn(["ollama", ...args]);
   }
 }
+function formatSize(sizeBytes) {
+  const sizeStr = import_bytes2.default(sizeBytes) ?? "?";
+  const sizeNum = sizeBytes / (1024 * 1024 * 1024);
+  if (sizeNum > 20) {
+    return yellow(sizeStr);
+  } else if (sizeNum > 10) {
+    return cyan(sizeStr);
+  }
+  return dim(sizeStr);
+}
 async function modelsList() {
   try {
     const models = await fetchModels();
     if (models.length === 0) {
-      console.log("No models installed.");
-      console.log(`
-Pull a model with: loclaude models-pull <model-name>`);
-      console.log("Example: loclaude models-pull llama3.2");
+      header("Installed Models");
+      console.log("");
+      console.log(info("No models installed."));
+      console.log("");
+      console.log(`Pull a model with: ${cmd("loclaude models-pull <model-name>")}`);
+      console.log(`Example: ${cmd("loclaude models-pull llama3.2")}`);
       return;
     }
-    console.log(`Installed models:
-`);
+    header("Installed Models");
+    console.log("");
     const nameWidth = Math.max(...models.map((m) => m.name.length), "NAME".length);
     const sizeWidth = 10;
-    console.log(`${"NAME".padEnd(nameWidth)}  ${"SIZE".padStart(sizeWidth)}  MODIFIED`);
-    console.log("-".repeat(nameWidth + sizeWidth + 30));
+    const modifiedWidth = 20;
+    tableHeader(["NAME", "SIZE", "MODIFIED"], [nameWidth, sizeWidth, modifiedWidth]);
     for (const model of models) {
-      const name = model.name.padEnd(nameWidth);
-      const size = (import_bytes2.default(model.size) ?? "?").padStart(sizeWidth);
-      const modified = formatRelativeTime(model.modified_at);
+      const name = magenta(model.name.padEnd(nameWidth));
+      const size = formatSize(model.size).padStart(sizeWidth);
+      const modified = dim(formatRelativeTime(model.modified_at));
       console.log(`${name}  ${size}  ${modified}`);
     }
-    console.log(`
-${models.length} model(s) installed`);
-  } catch (error) {
+    console.log("");
+    console.log(dim(`${models.length} model(s) installed`));
+  } catch (err) {
     const ollamaUrl = getOllamaUrl();
-    console.error("Error: Could not connect to Ollama at", ollamaUrl);
-    console.error("Make sure Ollama is running: loclaude docker-up");
+    console.log(error(`Could not connect to Ollama at ${ollamaUrl}`));
+    console.log(dim(`  Make sure Ollama is running: ${cmd("loclaude docker-up")}`));
     process.exit(1);
   }
 }
 async function modelsPull(modelName) {
   if (!modelName) {
-    console.error("Error: Model name required");
-    console.error("Usage: loclaude models pull <model-name>");
-    console.error("Example: loclaude models pull llama3.2");
+    console.log(error("Model name required"));
+    console.log(dim(`Usage: ${cmd("loclaude models-pull <model-name>")}`));
+    console.log(dim(`Example: ${cmd("loclaude models-pull llama3.2")}`));
     process.exit(1);
   }
-  console.log(`Pulling model: ${modelName}
-`);
+  console.log(info(`Pulling model: ${magenta(modelName)}`));
+  console.log("");
   const exitCode = await runOllamaCommand(["pull", modelName]);
   if (exitCode === 0) {
-    console.log(`
-✓ Model '${modelName}' pulled successfully`);
+    console.log("");
+    console.log(success(`Model '${magenta(modelName)}' pulled successfully`));
   }
   process.exit(exitCode);
 }
 async function modelsRm(modelName) {
   if (!modelName) {
-    console.error("Error: Model name required");
-    console.error("Usage: loclaude models rm <model-name>");
+    console.log(error("Model name required"));
+    console.log(dim(`Usage: ${cmd("loclaude models-rm <model-name>")}`));
     process.exit(1);
   }
-  console.log(`Removing model: ${modelName}
-`);
+  console.log(info(`Removing model: ${magenta(modelName)}`));
+  console.log("");
   const exitCode = await runOllamaCommand(["rm", modelName]);
   if (exitCode === 0) {
-    console.log(`
-✓ Model '${modelName}' removed`);
+    console.log("");
+    console.log(success(`Model '${magenta(modelName)}' removed`));
   }
   process.exit(exitCode);
 }
 async function modelsShow(modelName) {
   if (!modelName) {
-    console.error("Error: Model name required");
-    console.error("Usage: loclaude models show <model-name>");
+    console.log(error("Model name required"));
+    console.log(dim(`Usage: ${cmd("loclaude models-show <model-name>")}`));
     process.exit(1);
   }
+  console.log(info(`Model details: ${magenta(modelName)}`));
+  console.log("");
   const exitCode = await runOllamaCommand(["show", modelName]);
   process.exit(exitCode);
 }
 async function modelsRun(modelName) {
   if (!modelName) {
-    console.error("Error: Model name required");
-    console.error("Usage: loclaude models run <model-name>");
+    console.log(error("Model name required"));
+    console.log(dim(`Usage: ${cmd("loclaude models-run <model-name>")}`));
     process.exit(1);
   }
+  console.log(info(`Running model: ${magenta(modelName)}`));
+  console.log("");
   const exitCode = await runOllamaCommand(["run", modelName]);
   process.exit(exitCode);
 }
@@ -3667,7 +4211,7 @@ cli.command("run [...args]", "Run Claude Code with local Ollama", {
   }
   await launchClaude(model, args);
 });
-cli.command("init", "Initialize a new loclaude project").option("--force", "Overwrite existing files").option("--no-webui", "Skip Open WebUI in docker-compose").action(async (options) => {
+cli.command("init", "Initialize a new loclaude project").option("--force", "Overwrite existing files").option("--no-webui", "Skip Open WebUI in docker-compose").option("--gpu", "Force GPU mode (NVIDIA)").option("--no-gpu", "Force CPU-only mode").action(async (options) => {
   await init(options);
 });
 cli.command("doctor", "Check system requirements and health").action(async () => {
@@ -3723,5 +4267,5 @@ export {
   cli
 };
 
-//# debugId=79E8E47212AC1C8E64756E2164756E21
+//# debugId=D27E5C5FE65A8CD164756E2164756E21
 //# sourceMappingURL=index.js.map