@vibgrate/cli 2026.721.2 → 2026.722.1

package/dist/interactive-736PBC7J.js

@@ -0,0 +1,820 @@
+import { newSession, loadLatestSession, summarizeSession, saveSession, recordTask } from './chunk-K3SLGULW.js';
+import { runAgent } from './chunk-JBXNQCGE.js';
+import { printCodeLogo, runBuild, resolveProviders } from './chunk-2EVQKZTO.js';
+import { loadGraph, refreshIfStale, discoverModels, detectServeLaunch } from './chunk-VXT6LUGP.js';
+import './chunk-GGJZA3Q6.js';
+import './chunk-JSNHZCIV.js';
+import './chunk-PY3DNX5H.js';
+import './chunk-RXP66R2E.js';
+import './chunk-GI6W53LM.js';
+import './chunk-CRAMOEBE.js';
+import { nodeCodeFs, undoChanges } from './chunk-6CXTPC74.js';
+import { summarizeDiffs } from './chunk-CS37OBE3.js';
+import { readModelSavings } from './chunk-WNIIKCNF.js';
+import './chunk-JFGYT6BI.js';
+import { TtyPrompter, PromptCancelled } from './chunk-JYS4OBN2.js';
+import { info, c, out } from './chunk-CT5BS56U.js';
+import { McpToolset, defaultMcpConnect } from './chunk-LEPTUB4H.js';
+import * as fs from 'fs';
+import * as os2 from 'os';
+import * as path from 'path';
+import { spawnSync, spawn } from 'child_process';
+
+var PROVIDER_LABELS = {
+  anthropic: "Anthropic (Claude)",
+  openai: "OpenAI (GPT)",
+  "x-ai": "xAI (Grok)",
+  google: "Google (Gemini)",
+  "meta-llama": "Meta (Llama)",
+  deepseek: "DeepSeek",
+  mistralai: "Mistral",
+  qwen: "Qwen"
+};
+var FEATURED_ORDER = Object.keys(PROVIDER_LABELS);
+var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function catalogCachePath() {
+  const base = process.env.XDG_CACHE_HOME || path.join(os2.homedir(), ".cache");
+  return path.join(base, "vibgrate", "catalog", "openrouter-models.json");
+}
+async function fetchCatalog(options = {}) {
+  const now = options.now ?? (() => 0);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  if (!options.noCache) {
+    const cached = readCache();
+    if (cached && (options.offline || now() - cached.ts < CACHE_TTL_MS)) {
+      return { providers: groupModels(cached.models), fresh: false, source: "cache" };
+    }
+  }
+  if (options.offline) {
+    const cached = readCache();
+    if (cached) return { providers: groupModels(cached.models), fresh: false, source: "cache" };
+    return { providers: curatedFallback(), fresh: false, source: "fallback" };
+  }
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 8e3);
+    let raw;
+    try {
+      const res = await fetchImpl(OPENROUTER_MODELS_URL, { signal: controller.signal });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      raw = await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+    const models = parseModels(raw);
+    if (models.length === 0) throw new Error("empty catalog");
+    writeCache(models, now());
+    return { providers: groupModels(models), fresh: true, source: "network" };
+  } catch {
+    const cached = readCache();
+    if (cached) return { providers: groupModels(cached.models), fresh: false, source: "cache" };
+    return { providers: curatedFallback(), fresh: false, source: "fallback" };
+  }
+}
+function parseModels(raw) {
+  const data = raw?.data;
+  if (!Array.isArray(data)) return [];
+  const out2 = [];
+  for (const entry of data) {
+    const e = entry;
+    if (typeof e.id !== "string" || !e.id.includes("/")) continue;
+    const provider = e.id.split("/")[0];
+    out2.push({
+      id: e.id,
+      name: typeof e.name === "string" ? e.name : e.id,
+      provider,
+      contextLength: numeric(e.context_length),
+      promptPricePerM: perMillion(e.pricing?.prompt),
+      completionPricePerM: perMillion(e.pricing?.completion)
+    });
+  }
+  return out2;
+}
+function groupModels(models) {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const m of models) {
+    const list = byProvider.get(m.provider) ?? [];
+    list.push(m);
+    byProvider.set(m.provider, list);
+  }
+  const groups = [];
+  for (const [id, list] of byProvider) {
+    groups.push({ id, label: PROVIDER_LABELS[id] ?? titleCase(id), models: list.sort(rankModels) });
+  }
+  groups.sort((a, b) => {
+    const ia = FEATURED_ORDER.indexOf(a.id);
+    const ib = FEATURED_ORDER.indexOf(b.id);
+    if (ia !== -1 || ib !== -1) return (ia === -1 ? 1e9 : ia) - (ib === -1 ? 1e9 : ib);
+    return a.label.localeCompare(b.label);
+  });
+  return groups;
+}
+function rankModels(a, b) {
+  const ca = isCoding(a) ? 0 : 1;
+  const cb = isCoding(b) ? 0 : 1;
+  if (ca !== cb) return ca - cb;
+  const la = a.contextLength ?? 0;
+  const lb = b.contextLength ?? 0;
+  if (la !== lb) return lb - la;
+  return a.id.localeCompare(b.id);
+}
+function isCoding(m) {
+  return /cod(e|er|ing)/i.test(m.id) || /cod(e|er|ing)/i.test(m.name);
+}
+function topProviders(catalog, n = 6) {
+  return catalog.providers.slice(0, n);
+}
+function readCache() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(catalogCachePath(), "utf8"));
+    if (Array.isArray(parsed.models) && typeof parsed.ts === "number") return parsed;
+  } catch {
+  }
+  return null;
+}
+function writeCache(models, ts) {
+  try {
+    const file = catalogCachePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ ts, models }));
+  } catch {
+  }
+}
+function curatedFallback() {
+  return FEATURED_ORDER.map((id) => ({ id, label: PROVIDER_LABELS[id], models: [] }));
+}
+function numeric(v) {
+  const n = typeof v === "string" ? Number(v) : typeof v === "number" ? v : NaN;
+  return Number.isFinite(n) ? n : void 0;
+}
+function perMillion(v) {
+  const n = numeric(v);
+  if (n === void 0) return void 0;
+  return Math.round(n * 1e6 * 1e3) / 1e3;
+}
+function titleCase(id) {
+  return id.replace(/[-_]/g, " ").replace(/\b\w/g, (ch) => ch.toUpperCase());
+}
+
+// src/code/wizard.ts
+var ENTER_SLUG = "__enter_slug__";
+var LOCAL = "__local__";
+var BROWSE = "__browse__";
+async function runProviderWizard(prompter, deps) {
+  const providers = topProviders(deps.catalog, deps.topN ?? 6);
+  const choice = await prompter.select("Where should the model run?", [
+    { label: "Local model (on your machine)", value: LOCAL, hint: deps.localModels.length ? `${deps.localModels.length} found` : "nothing installed yet" },
+    ...providers.map((p) => ({ label: p.label, value: p.id, hint: "via OpenRouter" })),
+    { label: "Enter a provider or model slug myself", value: ENTER_SLUG }
+  ]);
+  if (choice === LOCAL) return pickLocal(prompter, deps);
+  if (choice === ENTER_SLUG) {
+    const slug = (await prompter.input("Model slug (e.g. anthropic/claude-3.5-sonnet, or a provider like openai)")).trim();
+    if (slug.includes("/")) return { kind: "hosted", provider: "openrouter", model: slug, providerSlug: slug.split("/")[0] };
+    const group2 = deps.catalog.providers.find((p) => p.id === slug);
+    if (group2 && group2.models.length) return pickHostedModel(prompter, group2.id, group2.models);
+    const model = (await prompter.input(`Model id for "${slug}"`)).trim();
+    return { kind: "hosted", provider: "openrouter", model: model || slug, providerSlug: slug };
+  }
+  const group = providers.find((p) => p.id === choice);
+  return pickHostedModel(prompter, group.id, group.models);
+}
+async function pickHostedModel(prompter, providerSlug, models) {
+  if (models.length === 0) {
+    const model2 = (await prompter.input(`Enter a ${providerSlug} model id`)).trim();
+    return { kind: "hosted", provider: "openrouter", model: model2, providerSlug };
+  }
+  const model = await prompter.select("Choose a model", [
+    ...models.slice(0, 12).map((m) => ({ label: m.name, value: m.id, hint: modelHint(m.contextLength, m.promptPricePerM) })),
+    { label: "Enter a model slug myself", value: ENTER_SLUG }
+  ]);
+  if (model === ENTER_SLUG) {
+    const typed = (await prompter.input(`Enter a ${providerSlug} model id`)).trim();
+    return { kind: "hosted", provider: "openrouter", model: typed, providerSlug };
+  }
+  return { kind: "hosted", provider: "openrouter", model, providerSlug };
+}
+async function pickLocal(prompter, deps) {
+  const installed = deps.localModels.filter((m) => m.runtime === "ollama");
+  const choices = [
+    ...installed.map((m) => ({ label: m.name, value: m.name, hint: "installed" })),
+    { label: "Browse coding models to pull (Ollama)", value: BROWSE },
+    { label: "Enter a model name to pull", value: ENTER_SLUG }
+  ];
+  const picked = await prompter.select("Local model", choices);
+  if (picked === ENTER_SLUG) {
+    const name = (await prompter.input("Ollama model to pull (e.g. qwen2.5-coder:7b)")).trim();
+    return { kind: "local", provider: "ollama", model: name, providerSlug: "ollama", needsPull: true };
+  }
+  if (picked === BROWSE) {
+    const coding = deps.catalog.providers.flatMap((p) => p.models).filter((m) => /cod(e|er|ing)/i.test(m.id)).slice(0, 10);
+    if (coding.length === 0) {
+      const name = (await prompter.input("Ollama model to pull (e.g. qwen2.5-coder:7b)")).trim();
+      return { kind: "local", provider: "ollama", model: name, providerSlug: "ollama", needsPull: true };
+    }
+    const slug = await prompter.select("Coding model to pull", [
+      ...coding.map((m) => ({ label: m.name, value: toOllamaTag(m.id), hint: m.id })),
+      { label: "Enter a model name myself", value: ENTER_SLUG }
+    ]);
+    if (slug === ENTER_SLUG) {
+      const name = (await prompter.input("Ollama model to pull (e.g. qwen2.5-coder:7b)")).trim();
+      return { kind: "local", provider: "ollama", model: name, providerSlug: "ollama", needsPull: true };
+    }
+    return { kind: "local", provider: "ollama", model: slug, providerSlug: "ollama", needsPull: true };
+  }
+  return { kind: "local", provider: "ollama", model: picked, providerSlug: "ollama", needsPull: false };
+}
+function toOllamaTag(slug) {
+  const tail = slug.split("/").pop() ?? slug;
+  const size = tail.match(/(\d+(?:\.\d+)?)b\b/i);
+  const base = tail.replace(/-instruct\b/i, "").replace(/(\d+(?:\.\d+)?)b\b/i, "").replace(/[-.]+$/g, "").replace(/\s+/g, "-");
+  return size ? `${base}:${size[1]}b` : base;
+}
+function modelHint(contextLength, pricePerM) {
+  const parts = [];
+  if (contextLength) parts.push(`${Math.round(contextLength / 1e3)}k ctx`);
+  if (typeof pricePerM === "number") parts.push(pricePerM === 0 ? "free" : `$${pricePerM}/M in`);
+  return parts.join(" \xB7 ");
+}
+
+// src/code/capability.ts
+var GiB = 1024 ** 3;
+var QUANT_BYTES_PER_PARAM = {
+  f16: 2,
+  fp16: 2,
+  f32: 4,
+  q8: 1.06,
+  q8_0: 1.06,
+  q6: 0.82,
+  q6_k: 0.82,
+  q5: 0.7,
+  q5_k_m: 0.72,
+  q5_k_s: 0.68,
+  q5_0: 0.71,
+  q5_1: 0.77,
+  q4: 0.58,
+  q4_k_m: 0.6,
+  q4_k_s: 0.56,
+  q4_0: 0.56,
+  q4_1: 0.63,
+  q3: 0.46,
+  q3_k_m: 0.48,
+  q3_k_s: 0.44,
+  q2: 0.36,
+  q2_k: 0.4
+};
+var DEFAULT_QUANT = "q4_k_m";
+var RUNTIME_OVERHEAD = 1.2;
+function estimateModelBytes(slug, defaultParamsB = 7) {
+  const lower = slug.toLowerCase();
+  const paramMatch = lower.match(/(\d+(?:\.\d+)?)\s*b\b/);
+  const paramsB = paramMatch ? Number(paramMatch[1]) : void 0;
+  const quant = detectQuant(lower);
+  const bytesPerParam = QUANT_BYTES_PER_PARAM[quant] ?? QUANT_BYTES_PER_PARAM[DEFAULT_QUANT];
+  const effectiveParams = (paramsB ?? defaultParamsB) * 1e9;
+  const bytes = Math.round(effectiveParams * bytesPerParam * RUNTIME_OVERHEAD);
+  return { paramsB, quant, bytes, guessed: paramsB === void 0 };
+}
+function detectQuant(lower) {
+  const keys = Object.keys(QUANT_BYTES_PER_PARAM).sort((a, b) => b.length - a.length);
+  for (const k of keys) if (lower.includes(k)) return k;
+  return DEFAULT_QUANT;
+}
+function parseOllamaPs(stdout) {
+  const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+  const out2 = [];
+  for (const line of lines) {
+    if (/^NAME\b/i.test(line)) continue;
+    const sizeMatch = line.match(/(\d+(?:\.\d+)?)\s*(GB|GiB|MB|MiB|TB)/i);
+    const name = line.split(/\s+/)[0];
+    if (!name || !sizeMatch) continue;
+    out2.push({ name, bytes: toBytes(Number(sizeMatch[1]), sizeMatch[2]) });
+  }
+  return out2;
+}
+function parseNvidiaSmi(stdout) {
+  const line = stdout.split("\n").map((l) => l.trim()).find(Boolean);
+  if (!line) return null;
+  const parts = line.split(",").map((p) => Number(p.trim()));
+  if (parts.length < 2 || !Number.isFinite(parts[0]) || !Number.isFinite(parts[1])) return null;
+  return { totalBytes: parts[0] * 1024 * 1024, usedBytes: parts[1] * 1024 * 1024 };
+}
+function assessCapability(model, sys) {
+  const useVram = typeof sys.vramTotalBytes === "number" && sys.vramTotalBytes > 0;
+  const free = useVram ? sys.vramFreeBytes ?? 0 : sys.freeRamBytes;
+  const loadedBytes = sys.loaded.reduce((n, m) => n + m.bytes, 0);
+  const margin = Math.min(2 * GiB, (useVram ? sys.vramTotalBytes : sys.totalRamBytes) * 0.1);
+  const available = Math.max(0, free - margin);
+  const availableIfUnloaded = Math.max(0, free + loadedBytes - margin);
+  const need = model.bytes;
+  const canRunNow = available >= need;
+  const canRunUnloaded = availableIfUnloaded >= need;
+  const suggestions = [];
+  if (!canRunNow && canRunUnloaded && sys.loaded.length) {
+    const biggest = [...sys.loaded].sort((a, b) => b.bytes - a.bytes);
+    suggestions.push(`unload a loaded model to free memory (e.g. \`ollama stop ${biggest[0].name}\` frees ~${fmt(biggest[0].bytes)})`);
+  }
+  if (!canRunUnloaded) {
+    suggestions.push(`this model needs ~${fmt(need)} but only ~${fmt(availableIfUnloaded)} is available \u2014 choose a smaller model or a lower quant (e.g. q4_K_M)`);
+  }
+  if (model.guessed) {
+    suggestions.push(`couldn't read the parameter count from the name \u2014 this estimate assumes a ~${(model.bytes / GiB).toFixed(1)} GiB model; verify before pulling`);
+  }
+  return {
+    model,
+    availableBytes: available,
+    availableIfUnloadedBytes: availableIfUnloaded,
+    canRun: canRunNow || canRunUnloaded,
+    needsUnload: !canRunNow && canRunUnloaded,
+    suggestions,
+    loaded: sys.loaded
+  };
+}
+function fmt(bytes) {
+  if (bytes >= GiB) return `${(bytes / GiB).toFixed(1)} GiB`;
+  return `${(bytes / (1024 * 1024)).toFixed(0)} MiB`;
+}
+function toBytes(n, unit) {
+  const u = unit.toLowerCase();
+  if (u.startsWith("t")) return n * 1e3 ** 4;
+  if (u.startsWith("g")) return n * (u.includes("i") ? GiB : 1e9);
+  if (u.startsWith("m")) return n * (u.includes("i") ? 1024 * 1024 : 1e6);
+  return n;
+}
+function gatherSystemMemory() {
+  const loaded = safeRun("ollama", ["ps"]).map(parseOllamaPs).flat();
+  const smi = safeRun("nvidia-smi", ["--query-gpu=memory.total,memory.used", "--format=csv,noheader,nounits"]).map(parseNvidiaSmi).find(Boolean);
+  const sys = {
+    totalRamBytes: os2.totalmem(),
+    freeRamBytes: os2.freemem(),
+    loaded
+  };
+  if (smi) {
+    sys.vramTotalBytes = smi.totalBytes;
+    sys.vramFreeBytes = Math.max(0, smi.totalBytes - smi.usedBytes);
+  }
+  return sys;
+}
+function hasOllama() {
+  return spawnSync(process.platform === "win32" ? "where" : "which", ["ollama"], { stdio: "ignore" }).status === 0;
+}
+function stopModel(name) {
+  return spawnSync("ollama", ["stop", name], { stdio: "ignore" }).status === 0;
+}
+function pullModelClean(name, spinner) {
+  return new Promise((resolve) => {
+    const child = spawn("ollama", ["pull", name]);
+    const onData = (buf) => {
+      const line = lastMeaningfulLine(buf.toString());
+      if (line) spinner.update(`pulling ${name} \u2014 ${line}`);
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+  });
+}
+function lastMeaningfulLine(chunk) {
+  const lines = chunk.split(/[\r\n]+/).map((l) => l.trim()).map((l) => l.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/[▏▎▍▌▋▊▉█░▒▓⣀-⣿]/g, "").trim()).filter(Boolean);
+  const last = lines[lines.length - 1] ?? "";
+  const pct = last.match(/(\d+)\s*%/);
+  const status = last.replace(/\s{2,}.*$/, "").slice(0, 48);
+  return pct ? `${status} ${pct[1]}%`.trim() : status;
+}
+function safeRun(bin, args) {
+  try {
+    const res = spawnSync(bin, args, { encoding: "utf8", timeout: 5e3 });
+    if (res.status !== 0 || typeof res.stdout !== "string") return [];
+    return [res.stdout];
+  } catch {
+    return [];
+  }
+}
+
+// src/code/cost.ts
+function costOf(usage, pricing) {
+  const inCost = (usage.promptTokens ?? 0) / 1e6 * (pricing.promptPerM ?? 0);
+  const outCost = (usage.completionTokens ?? 0) / 1e6 * (pricing.completionPerM ?? 0);
+  return round4(inCost + outCost);
+}
+var SessionMeter = class {
+  constructor(pricing = {}) {
+    this.pricing = pricing;
+  }
+  pricing;
+  prompt = 0;
+  completion = 0;
+  cost = 0;
+  turns = 0;
+  /** Update the pricing (e.g. after `/model` switches model mid-session). */
+  setPricing(pricing) {
+    this.pricing = pricing;
+  }
+  /** Record one model turn; returns the incremental cost of just this turn. */
+  add(usage) {
+    this.prompt += usage.promptTokens ?? 0;
+    this.completion += usage.completionTokens ?? 0;
+    this.turns += 1;
+    const delta = costOf(usage, this.pricing);
+    this.cost = round4(this.cost + delta);
+    return delta;
+  }
+  get totals() {
+    return { promptTokens: this.prompt, completionTokens: this.completion, totalTokens: this.prompt + this.completion, cost: this.cost, turns: this.turns };
+  }
+  /** A compact one-line summary, e.g. `3.1k tok · ~$0.0042` (cost only when priced). */
+  summary() {
+    const t = this.totals;
+    const tok = `${fmtTokens(t.totalTokens)} tok`;
+    const priced = this.pricing.promptPerM || this.pricing.completionPerM;
+    return priced ? `${tok} \xB7 ~$${t.cost.toFixed(4)}` : tok;
+  }
+};
+function fmtTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+function round4(x) {
+  return Math.round(x * 1e4) / 1e4;
+}
+var GraphProcess = class _GraphProcess {
+  child;
+  disposed = false;
+  command;
+  args;
+  constructor(child, command, args) {
+    this.child = child;
+    this.command = command;
+    this.args = args;
+    child.once("exit", () => {
+      this.child = null;
+    });
+  }
+  static start(options) {
+    const launch = options.launch ?? detectServeLaunch();
+    const client = options.client ?? "vg-code";
+    const args = [...launch.args, "--client", client];
+    const spawnImpl = options.spawnImpl ?? spawn;
+    try {
+      const child = spawnImpl(launch.command, args, { cwd: options.root, stdio: "ignore", detached: false });
+      if (!child || typeof child.pid !== "number") return null;
+      child.on("error", () => {
+      });
+      return new _GraphProcess(child, launch.command, args);
+    } catch {
+      return null;
+    }
+  }
+  get pid() {
+    return this.child?.pid;
+  }
+  /** True while the child is believed to be running. */
+  get running() {
+    return this.child !== null && !this.disposed;
+  }
+  /** Kill the child. Idempotent and safe to call after the child already exited. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    const child = this.child;
+    this.child = null;
+    if (!child || child.killed) return;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  }
+};
+
+// src/code/interactive.ts
+async function runInteractive(root, global, opts, prompter = new TtyPrompter()) {
+  printCodeLogo(root);
+  try {
+    await ensureMap(root, global, prompter);
+    const selection = await chooseModel(root, global, opts, prompter);
+    if (!selection) return;
+    await codingRepl(root, global, opts, selection, prompter);
+  } catch (e) {
+    if (e instanceof PromptCancelled) {
+      info(c.dim("\n  cancelled \u2014 no changes were made"));
+      return;
+    }
+    throw e;
+  }
+}
+async function ensureMap(root, global, prompter) {
+  const existing = loadGraph(root, global.graph);
+  if (!existing) {
+    const sp2 = prompter.spinner("Building the code map\u2026");
+    try {
+      await runBuild([root], {}, { ...global, quiet: true });
+      sp2.stop("Code map built");
+    } catch (e) {
+      sp2.fail(`couldn't build the code map: ${e.message}`);
+      throw e;
+    }
+    return;
+  }
+  const sp = prompter.spinner("Checking the code map is up to date\u2026");
+  const refreshed = await refreshIfStale(root).catch(() => null);
+  if (refreshed?.status === "refreshed") sp.stop("Code map refreshed");
+  else sp.stop("Code map ready");
+}
+async function chooseModel(root, global, opts, prompter) {
+  if (opts.provider && (opts.model || opts.modelPath)) {
+    const local = opts.provider === "ollama" || opts.provider === "lmstudio" || opts.provider === "llama-cpp" || !!global.local;
+    return { kind: local ? "local" : "hosted", provider: opts.provider === "ollama" ? "ollama" : "openrouter", model: opts.model ?? opts.modelPath ?? "", providerSlug: opts.provider, needsPull: false };
+  }
+  const sp = prompter.spinner("Loading the model catalog\u2026");
+  const catalog = await fetchCatalog({ offline: global.local });
+  sp.stop(catalog.source === "network" ? "Model catalog loaded" : catalog.source === "cache" ? "Model catalog (cached)" : "Model catalog (offline list)");
+  const localModels = discoverModels();
+  const selection = await runProviderWizard(prompter, { catalog, localModels });
+  if (selection.kind === "local" && selection.needsPull) {
+    const ok = await preflightAndPull(selection, prompter);
+    if (!ok) return null;
+  }
+  if (selection.kind === "hosted" && !process.env.OPENROUTER_API_KEY) {
+    prompter.note(c.yellow("Set OPENROUTER_API_KEY in your environment to use this hosted model (keys are never passed as flags)."));
+  }
+  return selection;
+}
+async function preflightAndPull(selection, prompter) {
+  if (!hasOllama()) {
+    prompter.note(c.yellow("Ollama isn\u2019t installed \u2014 get it from https://ollama.com, then re-run. (We never install a runtime for you.)"));
+    return false;
+  }
+  const estimate = estimateModelBytes(selection.model);
+  const report = assessCapability(estimate, gatherSystemMemory());
+  prompter.note(`${c.bold(selection.model)} \u2014 estimated ${fmt(estimate.bytes)}${estimate.guessed ? c.dim(" (size guessed)") : ""}; ~${fmt(report.availableBytes)} free now`);
+  for (const s of report.suggestions) prompter.note(c.dim(`\xB7 ${s}`));
+  if (!report.canRun) {
+    prompter.note(c.red("This machine doesn\u2019t have enough memory for that model \u2014 not pulling it. Pick a smaller model or a lower quant."));
+    return false;
+  }
+  if (report.needsUnload) {
+    const biggest = [...report.loaded].sort((a, b) => b.bytes - a.bytes)[0];
+    if (biggest && await prompter.confirm(`Unload ${biggest.name} to free ~${fmt(biggest.bytes)}?`, true)) {
+      stopModel(biggest.name);
+    }
+  }
+  if (!await prompter.confirm(`Pull ${selection.model} (~${fmt(estimate.bytes)})?`, true)) return false;
+  const sp = prompter.spinner(`Pulling ${selection.model}\u2026`);
+  const ok = await pullModelClean(selection.model, sp);
+  if (ok) sp.stop(`Pulled ${selection.model}`);
+  else sp.fail(`couldn\u2019t pull ${selection.model}`);
+  return ok;
+}
+async function codingRepl(root, global, opts, selection, prompter) {
+  let sel = selection;
+  let route = resolveProviders({ provider: sel.provider, model: sel.model, local: sel.kind === "local" || global.local });
+  const fsImpl = nodeCodeFs(root);
+  const meter = new SessionMeter();
+  let lastChanges = [];
+  let store = newSession(sessionId(), sel.providerSlug, sel.model, Date.now());
+  let priorSummary;
+  if (opts.continueSession) {
+    const prev = loadLatestSession(root);
+    if (prev) {
+      store = prev;
+      lastChanges = prev.lastChanges ?? [];
+      priorSummary = summarizeSession(prev);
+      prompter.note(c.dim(`resumed session \u2014 ${prev.tasks.length} earlier task(s); /undo restores the last change`));
+    } else prompter.note(c.dim("no previous session to continue"));
+  }
+  let mcp;
+  if (opts.mcpServers && Object.keys(opts.mcpServers).length) {
+    const sp = prompter.spinner("Connecting MCP tools\u2026");
+    const { toolset, warnings } = await McpToolset.connect(opts.mcpServers, opts.mcpConnect ?? defaultMcpConnect);
+    mcp = toolset;
+    const from = opts.mcpSources?.length ? ` (from ${opts.mcpSources.join(", ")})` : "";
+    sp.stop(`MCP tools: ${toolset.specs().length} from ${Object.keys(opts.mcpServers).length} server(s)${from}`);
+    for (const w of warnings) prompter.note(c.yellow(`  ${w}`));
+  }
+  const graphProc = GraphProcess.start({ root });
+  const cleanup = () => {
+    graphProc?.dispose();
+    void mcp?.dispose();
+  };
+  process.once("SIGINT", cleanup);
+  const autoNote = opts.auto ? c.yellow(" \xB7 auto-approve ON") : "";
+  prompter.intro(`Ready \u2014 ${sel.providerSlug}/${sel.model}${graphProc ? c.dim(" \xB7 graph " + graphProc.pid) : ""}${autoNote}. Describe a task, or /help. Empty line to exit.`);
+  try {
+    for (; ; ) {
+      const line = (await prompter.input("code \u203A")).trim();
+      if (!line || /^(exit|quit)$/i.test(line) || line === "/exit" || line === "/quit") break;
+      if (line.startsWith("/")) {
+        const [cmd] = line.slice(1).split(/\s+/);
+        if (cmd === "help") {
+          prompter.note("commands: /undo /diff /model /cost /clear /exit");
+        } else if (cmd === "undo") {
+          if (lastChanges.length === 0) prompter.note(c.dim("nothing to undo"));
+          else {
+            const restored = undoChanges(lastChanges, fsImpl);
+            prompter.note(c.green(`\u21A9 reverted ${restored.length} file(s): ${restored.join(", ")}`));
+            lastChanges = [];
+            store = { ...store, lastChanges: [] };
+            saveSession(root, store);
+          }
+        } else if (cmd === "diff") {
+          if (lastChanges.length === 0) prompter.note(c.dim("no recent change"));
+          else for (const ch of lastChanges) if (ch.diff) out(ch.diff);
+        } else if (cmd === "model") {
+          const swapped = await reselectModel(root, global, prompter);
+          if (swapped) {
+            sel = swapped;
+            route = resolveProviders({ provider: sel.provider, model: sel.model, local: sel.kind === "local" || global.local });
+            prompter.note(c.green(`now using ${sel.providerSlug}/${sel.model}`));
+          }
+        } else if (cmd === "cost") {
+          prompter.note(`this session: ${meter.summary()}`);
+          printCost(root);
+        } else if (cmd === "clear") {
+          prompter.note(c.dim("each task already starts fresh \u2014 nothing to clear"));
+        } else {
+          prompter.note(c.yellow(`unknown command /${cmd} \u2014 try /help`));
+        }
+        continue;
+      }
+      const graph = loadGraph(root, global.graph);
+      if (!graph) {
+        prompter.note(c.red("the code map disappeared \u2014 run `vg` to rebuild"));
+        break;
+      }
+      const result = await agentTask({
+        root,
+        graph,
+        instruction: line,
+        providers: route.providers,
+        fsImpl,
+        attribution: { client: "vg-code", provider: sel.providerSlug, model: sel.model },
+        auto: !!opts.auto,
+        maxSteps: opts.maxSteps,
+        denyCommands: opts.denyCommands,
+        testCommand: opts.testCommand,
+        contextBudget: opts.contextBudget,
+        stream: opts.stream,
+        verify: opts.verify,
+        priorSummary,
+        externalTools: mcp ? mcpExternalTools(mcp, agentApprove(opts, prompter)) : void 0,
+        meter,
+        prompter
+      });
+      priorSummary = void 0;
+      if (result.changes.length) {
+        lastChanges = result.changes;
+        prompter.note(c.dim("  /undo to revert \xB7 /diff to review"));
+      }
+      store = recordTask(store, { instruction: line, summary: result.finalText, changes: result.changes, stopped: result.stopped }, Date.now());
+      saveSession(root, store);
+    }
+  } finally {
+    cleanup();
+    process.removeListener("SIGINT", cleanup);
+  }
+  prompter.outro("Done.");
+}
+function agentApprove(opts, prompter) {
+  return async (action) => {
+    if (opts.auto) return true;
+    if (action.kind === "tool") return prompter.confirm(`Call ${action.name}?`, false);
+    return true;
+  };
+}
+function mcpExternalTools(mcp, approve) {
+  return { specs: mcp.specs(), owns: (name) => mcp.owns(name), execute: (call) => mcp.execute(call, approve) };
+}
+function sessionId() {
+  let s = "";
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  for (let i = 0; i < 10; i++) s += alphabet[Math.floor(Math.random() * alphabet.length)];
+  return s;
+}
+async function reselectModel(root, global, prompter) {
+  try {
+    const sp = prompter.spinner("Loading the model catalog\u2026");
+    const catalog = await fetchCatalog({ offline: global.local });
+    sp.stop("Model catalog loaded");
+    const selection = await runProviderWizard(prompter, { catalog, localModels: discoverModels() });
+    if (selection.kind === "local" && selection.needsPull) {
+      const ok = await preflightAndPull(selection, prompter);
+      if (!ok) return null;
+    }
+    return selection;
+  } catch (e) {
+    if (e instanceof PromptCancelled) return null;
+    prompter.note(c.yellow(`couldn't switch model: ${e.message}`));
+    return null;
+  }
+}
+function printCost(root) {
+  const now = Date.now();
+  const models = readModelSavings(root, 30, now);
+  if (models.length === 0) {
+    info(c.dim("  no usage recorded yet this session"));
+    return;
+  }
+  info(c.bold("  savings by model (last 30 days, local)"));
+  for (const m of models) info(`    ${m.key.padEnd(32)} ${m.queries} call(s) \xB7 ~${m.vgTokens} tokens \xB7 saved \u2248 $${m.saved}`);
+}
+async function agentTask(params) {
+  const { prompter } = params;
+  const approve = async (action) => {
+    if (params.auto) return true;
+    if (!prompter) return false;
+    switch (action.kind) {
+      case "edit":
+        out(action.diff);
+        return prompter.confirm(`Apply edit to ${action.file}?`, true);
+      case "create":
+        return prompter.confirm(`Create ${action.file} (${action.bytes} bytes)?`, true);
+      case "delete":
+        return prompter.confirm(`Delete ${action.file}?`, false);
+      case "run":
+        return prompter.confirm(`Run \`${action.command}\`?`, false);
+      case "tool":
+        return prompter.confirm(`Call ${action.name}(${briefArgs(action.args)})?`, false);
+    }
+  };
+  let streaming = false;
+  const closeStream = () => {
+    if (streaming) {
+      process.stderr.write("\n");
+      streaming = false;
+    }
+  };
+  const onEvent = (e) => {
+    if (e.type === "token") {
+      process.stderr.write(e.text);
+      streaming = true;
+      return;
+    }
+    closeStream();
+    if (e.type === "assistant") {
+      if (e.text.trim()) info(e.text.trim());
+    } else if (e.type === "tool-call") {
+      info(c.dim(`  \u2192 ${e.name}(${briefArgs(e.args)})`));
+    } else if (e.type === "tool-result") {
+      info(c.dim(`    ${e.mutated ? c.green("\u2714 ") : ""}${e.content.split("\n")[0].slice(0, 100)}`));
+    } else if (e.type === "compact") {
+      info(c.dim(`  \xB7 compacted context (${e.droppedRounds} earlier round(s) summarized)`));
+    } else if (e.type === "verify") {
+      info(e.passed ? c.green(`  \u2714 ${e.command} passed`) : c.yellow(`  \u2717 ${e.command} failed \u2014 asking the model to fix it`));
+    }
+  };
+  const result = await runAgent({
+    graph: params.graph,
+    root: params.root,
+    instruction: params.instruction,
+    providers: params.providers,
+    fsImpl: params.fsImpl,
+    run: shellRunner(params.root),
+    approve,
+    onEvent,
+    attribution: params.attribution,
+    maxSteps: params.maxSteps,
+    budget: params.budget,
+    contextBudget: params.contextBudget,
+    auto: params.auto,
+    denyCommands: params.denyCommands,
+    testCommand: params.testCommand,
+    stream: params.stream,
+    verify: params.verify,
+    priorSummary: params.priorSummary,
+    externalTools: params.externalTools,
+    now: () => Date.now()
+  });
+  closeStream();
+  const perTask = params.meter?.add(result.usage);
+  const summary = summarizeDiffs(result.changes.map((ch) => ({ file: ch.file, diff: ch.diff })));
+  info("");
+  info(
+    result.stopped === "finished" ? c.green(`\u2714 ${result.finalText}`) : result.stopped === "max-steps" ? c.yellow(`stopped at the step limit \u2014 ${result.changes.length} change(s) so far`) : c.dim(result.finalText)
+  );
+  const meterNote = perTask !== void 0 ? ` \xB7 ${params.meter.summary()}` : "";
+  if (result.changes.length || perTask) info(c.dim(`  ${summary} \xB7 via ${result.provider.id}/${result.provider.model}${result.provider.fellBack ? " (fell back)" : ""}${meterNote}`));
+  return result;
+}
+function briefArgs(args) {
+  const parts = [];
+  for (const [k, v] of Object.entries(args)) {
+    const s = typeof v === "string" ? v : JSON.stringify(v);
+    parts.push(`${k}: ${s.length > 40 ? s.slice(0, 40) + "\u2026" : s}`);
+    if (parts.length >= 2) break;
+  }
+  return parts.join(", ");
+}
+function shellRunner(root) {
+  return (command) => {
+    const res = spawnSync(command, { cwd: root, shell: true, encoding: "utf8", timeout: 12e4, maxBuffer: 10 * 1024 * 1024 });
+    const stdout = (res.stdout ?? "") + (res.stderr ? `
+${res.stderr}` : "");
+    return { stdout, exitCode: res.status ?? 1 };
+  };
+}
+
+export { agentTask, runInteractive };
+//# sourceMappingURL=interactive-736PBC7J.js.map
+//# sourceMappingURL=interactive-736PBC7J.js.map