open-agents-ai 0.1.0 → 0.2.1

package/dist/index.js

@@ -101,7 +101,7 @@ var init_config = __esm({
     "use strict";
     DEFAULT_CONFIG = Object.freeze({
       backendUrl: "http://localhost:11434",
-      model: "qwen3.5:122b",
+      model: "qwen3.5:latest",
       backendType: "ollama",
       apiKey: "",
       maxRetries: 3,
@@ -5066,9 +5066,12 @@ function renderCompactHeader(model) {
 }
 function renderSlashHelp() {
   const commands = [
-    ["/model", "Select from available Ollama models"],
+    ["/model", "Select from available models"],
     ["/model <name>", "Switch to a specific model"],
-    ["/models", "List all available Ollama models"],
+    ["/models", "List all available models"],
+    ["/endpoint", "Show current endpoint"],
+    ["/endpoint <url>", "Set backend URL (auto-detects type)"],
+    ["/endpoint <url> --auth <t>", "Set endpoint with Bearer auth"],
     ["/config", "Show current configuration"],
     ["/verbose", "Toggle verbose mode"],
     ["/clear", "Clear the screen"],
@@ -5260,6 +5263,10 @@ async function handleSlashCommand(input, ctx) {
     case "models":
       await listModels(ctx);
       return "handled";
+    case "endpoint":
+    case "ep":
+      await handleEndpoint(arg, ctx);
+      return "handled";
     default:
       renderWarning(`Unknown command: /${cmd}. Type /help for available commands.`);
       return "handled";
@@ -5285,6 +5292,90 @@ async function showModelPicker(ctx) {
     renderError(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
+async function handleEndpoint(arg, ctx) {
+  if (!arg) {
+    process.stdout.write(`
+  ${c2.bold("Current endpoint:")}
+
+`);
+    process.stdout.write(`  ${c2.cyan("URL".padEnd(12))} ${ctx.config.backendUrl}
+`);
+    process.stdout.write(`  ${c2.cyan("Type".padEnd(12))} ${ctx.config.backendType}
+`);
+    process.stdout.write(`  ${c2.cyan("Auth".padEnd(12))} ${ctx.config.apiKey ? "Bearer token set" : "none"}
+`);
+    process.stdout.write(`
+  ${c2.dim("Usage: /endpoint <url> [--auth <token>]")}
+`);
+    process.stdout.write(`  ${c2.dim("  /endpoint http://localhost:11434         (Ollama, no auth)")}
+`);
+    process.stdout.write(`  ${c2.dim("  /endpoint http://remote:8000/v1 --auth sk-...  (OpenAI-compatible)")}
+`);
+    process.stdout.write(`  ${c2.dim("  /endpoint http://remote:8000/v1          (OpenAI-compatible, no auth)")}
+
+`);
+    return;
+  }
+  const parts = arg.split(/\s+/);
+  const url = parts[0];
+  let apiKey;
+  const authIdx = parts.indexOf("--auth");
+  if (authIdx !== -1 && parts[authIdx + 1]) {
+    apiKey = parts[authIdx + 1];
+  }
+  try {
+    new URL(url);
+  } catch {
+    renderError(`Invalid URL: "${url}"`);
+    return;
+  }
+  let backendType = "ollama";
+  if (url.includes("/v1") || url.includes(":8000") || apiKey) {
+    backendType = "vllm";
+  }
+  process.stdout.write(`
+  ${c2.dim("Testing connection...")} `);
+  try {
+    const healthUrl = backendType === "ollama" ? `${url.replace(/\/$/, "")}/api/tags` : `${url.replace(/\/$/, "")}/models`;
+    const headers = {};
+    if (apiKey)
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    const resp = await fetch(healthUrl, {
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok)
+      throw new Error(`HTTP ${resp.status}`);
+    process.stdout.write(`${c2.green("\u2714")} Connected
+`);
+  } catch (err) {
+    process.stdout.write(`${c2.yellow("\u26A0")} Could not verify
+`);
+    renderWarning(`Endpoint may not be reachable: ${err instanceof Error ? err.message : String(err)}`);
+    renderInfo("Setting endpoint anyway \u2014 it may come online later.");
+  }
+  ctx.setEndpoint(url, backendType, apiKey);
+  setConfigValue("backendUrl", url);
+  setConfigValue("backendType", backendType);
+  if (apiKey) {
+    setConfigValue("apiKey", apiKey);
+  }
+  process.stdout.write(`
+  ${c2.green("\u2714")} Endpoint updated and saved:
+`);
+  process.stdout.write(`    ${c2.cyan("URL".padEnd(8))} ${url}
+`);
+  process.stdout.write(`    ${c2.cyan("Type".padEnd(8))} ${backendType}
+`);
+  if (apiKey) {
+    process.stdout.write(`    ${c2.cyan("Auth".padEnd(8))} Bearer ${apiKey.slice(0, 8)}...
+`);
+  } else {
+    process.stdout.write(`    ${c2.cyan("Auth".padEnd(8))} none
+`);
+  }
+  process.stdout.write("\n");
+}
 async function switchModel(query, ctx) {
   try {
     const models = await fetchOllamaModels(ctx.config.backendUrl);
@@ -5309,11 +5400,399 @@ var init_commands = __esm({
     "use strict";
     init_model_picker();
     init_render();
+    init_config();
   }
 });
 
-// packages/cli/dist/tui/interactive.js
+// packages/cli/dist/tui/setup.js
 import * as readline from "node:readline";
+import { execSync } from "node:child_process";
+import { existsSync as existsSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function detectSystemSpecs() {
+  let totalRamGB = 0;
+  let availableRamGB = 0;
+  let gpuVramGB = 0;
+  let gpuName = "";
+  try {
+    const memInfo = execSync("free -b 2>/dev/null || sysctl -n hw.memsize 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    if (memInfo.includes("Mem:")) {
+      const match = memInfo.match(/^Mem:\s+(\d+)\s+\d+\s+\d+\s+\d+\s+\d+\s+(\d+)/m);
+      if (match) {
+        totalRamGB = parseInt(match[1], 10) / 1024 ** 3;
+        availableRamGB = parseInt(match[2], 10) / 1024 ** 3;
+      }
+    } else {
+      const bytes = parseInt(memInfo.trim(), 10);
+      if (!isNaN(bytes)) {
+        totalRamGB = bytes / 1024 ** 3;
+        availableRamGB = totalRamGB * 0.7;
+      }
+    }
+  } catch {
+  }
+  try {
+    const nvidiaSmi = execSync("nvidia-smi --query-gpu=memory.total,name --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
+    const lines = nvidiaSmi.trim().split("\n");
+    if (lines.length > 0) {
+      for (const line of lines) {
+        const parts = line.split(",").map((s) => s.trim());
+        const vramMB = parseInt(parts[0] ?? "0", 10);
+        if (!isNaN(vramMB))
+          gpuVramGB += vramMB / 1024;
+        if (!gpuName && parts[1])
+          gpuName = parts[1];
+      }
+    }
+  } catch {
+  }
+  return {
+    totalRamGB: Math.round(totalRamGB * 10) / 10,
+    availableRamGB: Math.round(availableRamGB * 10) / 10,
+    gpuVramGB: Math.round(gpuVramGB * 10) / 10,
+    gpuName
+  };
+}
+function recommendModel(specs) {
+  const effectiveGB = Math.max(specs.gpuVramGB, specs.availableRamGB);
+  const budget = effectiveGB * 0.8;
+  const localVariants = QWEN_VARIANTS.filter((v) => !v.cloud);
+  for (let i = localVariants.length - 1; i >= 0; i--) {
+    if (localVariants[i].sizeGB <= budget) {
+      return localVariants[i];
+    }
+  }
+  return QWEN_VARIANTS.find((v) => v.tag === "qwen3.5:cloud");
+}
+function calculateContextWindow(specs, modelSizeGB) {
+  const totalAvail = Math.max(specs.gpuVramGB, specs.totalRamGB);
+  const remaining = totalAvail - modelSizeGB;
+  if (remaining >= 200)
+    return { numCtx: 131072, label: "128K" };
+  if (remaining >= 100)
+    return { numCtx: 65536, label: "64K" };
+  if (remaining >= 50)
+    return { numCtx: 32768, label: "32K" };
+  if (remaining >= 20)
+    return { numCtx: 16384, label: "16K" };
+  if (remaining >= 8)
+    return { numCtx: 8192, label: "8K" };
+  return { numCtx: 4096, label: "4K" };
+}
+function modelSupportsToolCalling(modelName) {
+  const lower = modelName.toLowerCase();
+  for (const known of TOOL_CALLING_MODELS) {
+    if (lower.startsWith(known) || lower.includes(known))
+      return true;
+  }
+  return false;
+}
+function ask(rl, question) {
+  return new Promise((resolve11) => {
+    rl.question(question, (answer) => resolve11(answer.trim()));
+  });
+}
+function pullModelWithAutoUpdate(tag) {
+  try {
+    execSync(`ollama pull ${tag}`, {
+      stdio: "inherit",
+      timeout: 36e5
+      // 1 hour max
+    });
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const stderr = err?.stderr?.toString?.() ?? errMsg;
+    const combined = errMsg + "\n" + stderr;
+    if (combined.includes("412") || combined.includes("newer version") || combined.includes("requires a newer version")) {
+      process.stdout.write(`
+  ${c2.yellow("\u26A0")} Ollama needs to be updated for this model.
+`);
+      process.stdout.write(`  ${c2.cyan("\u25CF")} Updating Ollama via official install script...
+
+`);
+      try {
+        execSync("curl -fsSL https://ollama.com/install.sh | sh", {
+          stdio: "inherit",
+          timeout: 3e5
+          // 5 min max for install
+        });
+        process.stdout.write(`
+  ${c2.green("\u2714")} Ollama updated successfully.
+`);
+        process.stdout.write(`  ${c2.cyan("\u25CF")} Retrying pull of ${c2.bold(tag)}...
+
+`);
+        execSync(`ollama pull ${tag}`, {
+          stdio: "inherit",
+          timeout: 36e5
+        });
+      } catch (updateErr) {
+        const updateMsg = updateErr instanceof Error ? updateErr.message : String(updateErr);
+        throw new Error(`Failed to update Ollama and retry pull: ${updateMsg}
+Try manually:
+  curl -fsSL https://ollama.com/install.sh | sh
+  ollama pull ${tag}`);
+      }
+    } else {
+      throw err;
+    }
+  }
+}
+async function runSetupWizard(config) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  try {
+    return await doSetup(config, rl);
+  } finally {
+    rl.close();
+  }
+}
+async function doSetup(config, rl) {
+  process.stdout.write(`
+  ${c2.bold(c2.cyan("open-agents"))}
+`);
+  process.stdout.write(`  ${c2.dim("\u2500".repeat(60))}
+`);
+  process.stdout.write(`  ${c2.bold("First-run setup")}
+
+`);
+  process.stdout.write(`  ${c2.cyan("\u25CF")} Detecting system specs...
+`);
+  const specs = detectSystemSpecs();
+  process.stdout.write(`  ${c2.dim("  RAM:")} ${specs.totalRamGB.toFixed(1)} GB total, ${specs.availableRamGB.toFixed(1)} GB available
+`);
+  if (specs.gpuVramGB > 0) {
+    process.stdout.write(`  ${c2.dim("  GPU:")} ${specs.gpuName || "NVIDIA"} \u2014 ${specs.gpuVramGB.toFixed(1)} GB VRAM
+`);
+  } else {
+    process.stdout.write(`  ${c2.dim("  GPU:")} No NVIDIA GPU detected (CPU inference)
+`);
+  }
+  process.stdout.write("\n");
+  let models = [];
+  try {
+    models = await fetchOllamaModels(config.backendUrl);
+  } catch {
+    renderError(`Cannot reach Ollama at ${config.backendUrl}`);
+    renderInfo("Start Ollama with: ollama serve");
+    renderInfo("Or use /endpoint to configure a remote backend after startup.");
+    const answer = await ask(rl, `
+  ${c2.bold("Continue without Ollama?")} (y/n) `);
+    if (answer.toLowerCase() !== "y")
+      return null;
+    return config.model;
+  }
+  const currentModel = findModel(models, config.model);
+  if (currentModel) {
+    process.stdout.write(`  ${c2.green("\u2714")} Model ${c2.bold(currentModel.name)} is available.
+
+`);
+    return currentModel.name;
+  }
+  process.stdout.write(`  ${c2.yellow("\u26A0")} Default model ${c2.bold(config.model)} is not available.
+
+`);
+  const toolCallingModels = models.filter((m) => modelSupportsToolCalling(m.name));
+  if (toolCallingModels.length > 0) {
+    process.stdout.write(`  ${c2.cyan("\u25CF")} Found ${toolCallingModels.length} model(s) with tool-calling support:
+
+`);
+    for (let i = 0; i < Math.min(toolCallingModels.length, 10); i++) {
+      const m = toolCallingModels[i];
+      process.stdout.write(`    ${c2.bold(String(i + 1))}. ${m.name} ${c2.dim(`(${m.size})`)}
+`);
+    }
+    process.stdout.write(`
+    ${c2.dim("0")}. Pull a new qwen3.5 model instead
+`);
+    process.stdout.write("\n");
+    const choice = await ask(rl, `  ${c2.bold("Select a model")} (1-${Math.min(toolCallingModels.length, 10)}, or 0 to pull new): `);
+    const idx = parseInt(choice, 10);
+    if (idx > 0 && idx <= toolCallingModels.length) {
+      const selected = toolCallingModels[idx - 1];
+      setConfigValue("model", selected.name);
+      process.stdout.write(`
+  ${c2.green("\u2714")} Selected ${c2.bold(selected.name)}. Saved to config.
+
+`);
+      return selected.name;
+    }
+  } else {
+    process.stdout.write(`  ${c2.yellow("\u26A0")} No tool-calling capable models found on this system.
+
+`);
+  }
+  const recommended = recommendModel(specs);
+  process.stdout.write(`  ${c2.cyan("\u25CF")} Recommended model based on your system:
+
+`);
+  const localVariants = QWEN_VARIANTS.filter((v) => !v.cloud);
+  for (let i = 0; i < localVariants.length; i++) {
+    const v = localVariants[i];
+    const fits = v.sizeGB <= Math.max(specs.gpuVramGB, specs.availableRamGB) * 0.8;
+    const isRec = v.tag === recommended.tag;
+    const marker = isRec ? c2.green("\u2192") : fits ? c2.dim(" ") : c2.red("\u2716");
+    const name = isRec ? c2.bold(c2.green(v.tag)) : fits ? v.tag : c2.dim(v.tag);
+    const label = isRec ? c2.bold(v.label) : c2.dim(v.label);
+    const tooLarge = !fits && !v.cloud ? c2.red(" (exceeds available memory)") : "";
+    process.stdout.write(`    ${marker} ${String(i + 1).padStart(2)}. ${name.padEnd(isRec ? 45 : 25)} ${label}${tooLarge}
+`);
+  }
+  process.stdout.write(`
+    ${c2.dim(" ")} ${String(localVariants.length + 1).padStart(2)}. ${c2.dim("qwen3.5:cloud")}              ${c2.dim("Ollama Cloud")}
+`);
+  process.stdout.write(`    ${c2.dim(" ")} ${String(localVariants.length + 2).padStart(2)}. ${c2.dim("qwen3.5:397b-cloud")}         ${c2.dim("397B Ollama Cloud")}
+`);
+  process.stdout.write("\n");
+  const pullChoice = await ask(rl, `  ${c2.bold("Select a model to pull")} (1-${localVariants.length + 2}, or Enter for recommended): `);
+  const pullIdx = pullChoice ? parseInt(pullChoice, 10) : 0;
+  let selectedVariant;
+  if (pullIdx === 0 || isNaN(pullIdx)) {
+    selectedVariant = recommended;
+  } else if (pullIdx <= localVariants.length) {
+    selectedVariant = localVariants[pullIdx - 1];
+  } else if (pullIdx === localVariants.length + 1) {
+    selectedVariant = QWEN_VARIANTS.find((v) => v.tag === "qwen3.5:cloud");
+  } else {
+    selectedVariant = QWEN_VARIANTS.find((v) => v.tag === "qwen3.5:397b-cloud");
+  }
+  const confirmPull = await ask(rl, `
+  Pull ${c2.bold(selectedVariant.tag)} (${selectedVariant.label})? (Y/n) `);
+  if (confirmPull.toLowerCase() === "n") {
+    process.stdout.write(`
+  ${c2.dim("Skipping model pull. You can pull manually with: ollama pull <model>")}
+
+`);
+    return config.model;
+  }
+  process.stdout.write(`
+  ${c2.cyan("\u25CF")} Pulling ${c2.bold(selectedVariant.tag)}... (this may take a while)
+`);
+  try {
+    pullModelWithAutoUpdate(selectedVariant.tag);
+    process.stdout.write(`
+  ${c2.green("\u2714")} Model ${c2.bold(selectedVariant.tag)} pulled successfully.
+
+`);
+  } catch (err) {
+    renderError(`Failed to pull model: ${err instanceof Error ? err.message : String(err)}`);
+    renderInfo("Try manually: ollama pull " + selectedVariant.tag);
+    return config.model;
+  }
+  if (!selectedVariant.cloud) {
+    const ctx = calculateContextWindow(specs, selectedVariant.sizeGB);
+    const customName = `open-agents-${selectedVariant.tag.replace(":", "-").replace(".", "")}`;
+    process.stdout.write(`  ${c2.cyan("\u25CF")} Context window recommendation: ${c2.bold(ctx.label)} (${ctx.numCtx} tokens)
+`);
+    process.stdout.write(`    ${c2.dim(`Based on ${specs.totalRamGB.toFixed(0)} GB RAM, ${selectedVariant.sizeGB} GB model`)}
+
+`);
+    const createModelfile = await ask(rl, `  Create optimized model "${c2.bold(customName)}" with ${ctx.label} context? (Y/n) `);
+    if (createModelfile.toLowerCase() !== "n") {
+      try {
+        const modelfileContent = [
+          `FROM ${selectedVariant.tag}`,
+          `PARAMETER num_ctx ${ctx.numCtx}`,
+          `PARAMETER temperature 0`,
+          `PARAMETER num_predict 16384`,
+          `PARAMETER stop "<|endoftext|>"`
+        ].join("\n");
+        const modelDir = join7(homedir2(), ".open-agents", "models");
+        mkdirSync2(modelDir, { recursive: true });
+        const modelfilePath = join7(modelDir, `Modelfile.${customName}`);
+        writeFileSync2(modelfilePath, modelfileContent + "\n", "utf8");
+        process.stdout.write(`  ${c2.dim("Creating model...")} `);
+        execSync(`ollama create ${customName} -f ${modelfilePath}`, {
+          stdio: "pipe",
+          timeout: 12e4
+        });
+        process.stdout.write(`${c2.green("\u2714")}
+`);
+        setConfigValue("model", customName);
+        process.stdout.write(`
+  ${c2.green("\u2714")} Model ${c2.bold(customName)} created with ${ctx.label} context.
+`);
+        process.stdout.write(`  ${c2.green("\u2714")} Saved as default model in config.
+
+`);
+        return customName;
+      } catch (err) {
+        renderWarning(`Could not create custom model: ${err instanceof Error ? err.message : String(err)}`);
+        renderInfo(`Using base model ${selectedVariant.tag} instead.`);
+      }
+    }
+    setConfigValue("model", selectedVariant.tag);
+    process.stdout.write(`
+  ${c2.green("\u2714")} Saved ${c2.bold(selectedVariant.tag)} as default model.
+
+`);
+    return selectedVariant.tag;
+  }
+  setConfigValue("model", selectedVariant.tag);
+  process.stdout.write(`
+  ${c2.green("\u2714")} Saved ${c2.bold(selectedVariant.tag)} as default model.
+
+`);
+  return selectedVariant.tag;
+}
+async function isModelAvailable(config) {
+  try {
+    const models = await fetchOllamaModels(config.backendUrl);
+    return !!findModel(models, config.model);
+  } catch {
+    return false;
+  }
+}
+function isFirstRun() {
+  try {
+    return !existsSync2(join7(homedir2(), ".open-agents", "config.json"));
+  } catch {
+    return true;
+  }
+}
+var QWEN_VARIANTS, TOOL_CALLING_MODELS;
+var init_setup = __esm({
+  "packages/cli/dist/tui/setup.js"() {
+    "use strict";
+    init_model_picker();
+    init_render();
+    init_config();
+    QWEN_VARIANTS = [
+      { tag: "qwen3.5:0.8b", sizeGB: 1, label: "0.8B params (1.0 GB)", cloud: false },
+      { tag: "qwen3.5:2b", sizeGB: 2.7, label: "2B params (2.7 GB)", cloud: false },
+      { tag: "qwen3.5:4b", sizeGB: 3.4, label: "4B params (3.4 GB)", cloud: false },
+      { tag: "qwen3.5:9b", sizeGB: 6.6, label: "9B params (6.6 GB) \u2014 recommended minimum", cloud: false },
+      { tag: "qwen3.5:27b", sizeGB: 17, label: "27B params (17 GB)", cloud: false },
+      { tag: "qwen3.5:35b", sizeGB: 24, label: "35B params (24 GB)", cloud: false },
+      { tag: "qwen3.5:122b", sizeGB: 81, label: "122B params (81 GB) \u2014 best local", cloud: false },
+      { tag: "qwen3.5:cloud", sizeGB: 0, label: "Cloud (Ollama Cloud)", cloud: true },
+      { tag: "qwen3.5:397b-cloud", sizeGB: 0, label: "397B Cloud (Ollama Cloud)", cloud: true }
+    ];
+    TOOL_CALLING_MODELS = /* @__PURE__ */ new Set([
+      "qwen3.5",
+      "qwen3",
+      "qwen2.5",
+      "llama3.3",
+      "llama3.1",
+      "mistral",
+      "mixtral",
+      "command-r",
+      "gemma3",
+      "devstral",
+      "deepseek"
+    ]);
+  }
+});
+
+// packages/cli/dist/tui/interactive.js
+import * as readline2 from "node:readline";
 import { cwd } from "node:process";
 import { resolve as resolve9 } from "node:path";
 function adaptTool(tool) {
@@ -5402,6 +5881,14 @@ async function runTask(task, config, repoRoot) {
 }
 async function startInteractive(config, repoPath) {
   const repoRoot = resolve9(repoPath ?? cwd());
+  const needsSetup = isFirstRun() || !await isModelAvailable(config);
+  if (needsSetup && config.backendType === "ollama") {
+    const setupModel = await runSetupWizard(config);
+    if (setupModel === null) {
+      process.exit(0);
+    }
+    config = { ...config, model: setupModel };
+  }
   try {
     const healthUrl = config.backendType === "ollama" ? `${config.backendUrl}/api/tags` : `${config.backendUrl}/v1/models`;
     const resp = await fetch(healthUrl, { signal: AbortSignal.timeout(1e4) });
@@ -5412,11 +5899,12 @@ async function startInteractive(config, repoPath) {
     if (config.backendType === "ollama") {
       renderInfo("Start Ollama with: ollama serve");
     }
+    renderInfo("Use /endpoint to configure a different backend.");
     process.exit(1);
   }
   renderHeader(config.model);
   let currentConfig = { ...config };
-  const rl = readline.createInterface({
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: `${c2.bold(c2.blue("> "))}`,
@@ -5433,6 +5921,14 @@ async function startInteractive(config, repoPath) {
     setVerbose(verbose) {
       currentConfig = { ...currentConfig, verbose };
     },
+    setEndpoint(url, backendType, apiKey) {
+      currentConfig = {
+        ...currentConfig,
+        backendUrl: url,
+        backendType,
+        ...apiKey !== void 0 ? { apiKey } : {}
+      };
+    },
     clearScreen() {
       process.stdout.write("\x1B[2J\x1B[H");
       renderCompactHeader(currentConfig.model);
@@ -5485,6 +5981,14 @@ ${c2.dim("(Use /quit to exit)")}
 }
 async function runWithTUI(task, config, repoPath) {
   const repoRoot = resolve9(repoPath ?? cwd());
+  const needsSetup = isFirstRun() || !await isModelAvailable(config);
+  if (needsSetup && config.backendType === "ollama") {
+    const setupModel = await runSetupWizard(config);
+    if (setupModel === null) {
+      process.exit(0);
+    }
+    config = { ...config, model: setupModel };
+  }
   try {
     const healthUrl = config.backendType === "ollama" ? `${config.backendUrl}/api/tags` : `${config.backendUrl}/v1/models`;
     const resp = await fetch(healthUrl, { signal: AbortSignal.timeout(1e4) });
@@ -5512,6 +6016,7 @@ var init_interactive = __esm({
     init_dist5();
     init_dist2();
     init_commands();
+    init_setup();
     init_render();
   }
 });
@@ -5547,7 +6052,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile7, stat as stat2 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join7, relative, extname as extname2, basename } from "node:path";
+import { join as join8, relative, extname as extname2, basename } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -5591,7 +6096,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile7(join7(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile7(join8(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -5606,7 +6111,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join7(this.config.rootDir, relativePath);
+          const fullPath = join8(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat2(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -5652,7 +6157,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join7(current.path, part),
+                  path: join8(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -5727,13 +6232,13 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve10 } from "node:path";
-import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve10(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync2(repoRoot)) {
+  if (!existsSync3(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
@@ -5979,8 +6484,8 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join8 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { join as join9 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 async function configCommand(opts, config) {
   if (opts.subCommand === "set") {
     return handleSet(opts, config);
@@ -6002,7 +6507,7 @@ function handleShow(opts, config) {
   printKeyValue("verbose", String(config.verbose), 2);
   printKeyValue("dbPath", config.dbPath, 2);
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join8(homedir2(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join9(homedir3(), ".open-agents", "config.json")})`);
   printSection("Environment Variables");
   printInfo("OPEN_AGENTS_BACKEND_URL  \u2014 override backendUrl");
   printInfo("OPEN_AGENTS_MODEL        \u2014 override model");
@@ -6234,8 +6739,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir } from "node:os";
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join10 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -6356,9 +6861,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join9(tmpdir(), `open-agents-eval-${Date.now()}`);
-  mkdirSync2(dir, { recursive: true });
-  writeFileSync2(join9(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join10(tmpdir(), `open-agents-eval-${Date.now()}`);
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync3(join10(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -6417,7 +6922,7 @@ init_output();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname2, join as join10 } from "node:path";
+import { dirname as dirname2, join as join11 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -6524,7 +7029,7 @@ init_output();
 function getVersion() {
   try {
     const require2 = createRequire(import.meta.url);
-    const pkgPath = join10(dirname2(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkgPath = join11(dirname2(fileURLToPath(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — Claude Code-style TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",