@vibgrate/cli 2026.721.2 → 2026.722.1

package/dist/chunk-CS37OBE3.js

@@ -0,0 +1,861 @@
+import { indexFor, queryGraph, impactOf } from './chunk-WNIIKCNF.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { spawnSync } from 'child_process';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+
+function runtimeCacheDir() {
+  const base = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+  return path.join(base, "vibgrate", "runtime");
+}
+function isPackageInstalled(spec) {
+  const name = packageName(spec);
+  try {
+    const req = createRequire(path.join(runtimeCacheDir(), "package.json"));
+    req.resolve(name);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureUnavailableMessage(reason, spec) {
+  const name = packageName(spec);
+  switch (reason) {
+    case "offline":
+      return `${name} is needed for this backend but --local/offline is set \u2014 using a backend that needs no install, or drop --local to allow a one-time install.`;
+    case "no-consent":
+      return `${name} is needed for this backend and isn't installed yet. Re-run with --yes to install it once into ${runtimeCacheDir()} (nothing is written into the CLI itself), or pick a backend that needs no install (e.g. --provider ollama).`;
+    case "install-failed":
+      return `couldn't install ${name} (offline, or npm unavailable) \u2014 using a backend that needs no install. It will try again next time.`;
+    case "load-failed":
+    default:
+      return `${name} installed but couldn't be loaded here \u2014 using a backend that needs no install.`;
+  }
+}
+async function ensurePackage(spec, options = {}) {
+  const dir = runtimeCacheDir();
+  const fail = (reason) => {
+    options.onUnavailable?.(reason, spec);
+    return { module: null, dir, reason };
+  };
+  if (isPackageInstalled(spec)) {
+    const mod2 = await load(spec, dir);
+    return mod2 ? { module: mod2, dir } : fail("load-failed");
+  }
+  if (options.local) return fail("offline");
+  const interactive = options.interactive ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  if (!options.consent && !interactive) return fail("no-consent");
+  if (!options.consent && interactive) return fail("no-consent");
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    ensureRuntimeManifest(dir);
+  } catch {
+    return fail("install-failed");
+  }
+  const installer = options.install ?? defaultInstaller;
+  const ok = installer(spec, dir);
+  if (!ok || !isPackageInstalled(spec)) return fail("install-failed");
+  const mod = await load(spec, dir);
+  return mod ? { module: mod, dir } : fail("load-failed");
+}
+function ensureRuntimeManifest(dir) {
+  const manifest = path.join(dir, "package.json");
+  if (!fs.existsSync(manifest)) {
+    fs.writeFileSync(
+      manifest,
+      JSON.stringify({ name: "vibgrate-runtime-deps", private: true, description: "On-demand vg runtime packages" }, null, 2)
+    );
+  }
+}
+async function load(spec, dir) {
+  const name = packageName(spec);
+  try {
+    const req = createRequire(path.join(dir, "package.json"));
+    const resolved = req.resolve(name);
+    const mod = await import(pathToFileURL(resolved).href);
+    return mod?.default ?? mod;
+  } catch {
+    return null;
+  }
+}
+function defaultInstaller(spec, dir) {
+  const res = spawnSync("npm", ["install", "--prefix", dir, "--no-audit", "--no-fund", "--ignore-scripts", spec], {
+    stdio: "ignore",
+    timeout: 18e4
+  });
+  return res.status === 0;
+}
+function packageName(spec) {
+  if (spec.startsWith("@")) {
+    const at2 = spec.indexOf("@", 1);
+    return at2 === -1 ? spec : spec.slice(0, at2);
+  }
+  const at = spec.indexOf("@");
+  return at === -1 ? spec : spec.slice(0, at);
+}
+
+// src/code/providers.ts
+function openAiMessages(messages) {
+  return messages.map((m) => {
+    if (m.role === "tool") return { role: "tool", tool_call_id: m.toolCallId, name: m.name, content: m.content };
+    if (m.role === "assistant" && m.toolCalls?.length) {
+      return {
+        role: "assistant",
+        content: m.content || null,
+        tool_calls: m.toolCalls.map((t) => ({ id: t.id, type: "function", function: { name: t.name, arguments: JSON.stringify(t.arguments) } }))
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
+}
+function openAiTools(tools) {
+  if (!tools?.length) return void 0;
+  return tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+}
+function parseToolCalls(raw, synthesizePrefix = "call") {
+  const calls = raw;
+  if (!Array.isArray(calls)) return [];
+  return calls.map((c, i) => ({
+    id: typeof c.id === "string" && c.id ? c.id : `${synthesizePrefix}_${i}`,
+    name: c.function?.name ?? "unknown",
+    arguments: coerceArgs(c.function?.arguments)
+  }));
+}
+function coerceArgs(raw) {
+  if (raw && typeof raw === "object") return raw;
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function redactSecrets(s) {
+  return s.replace(/\b(sk|xoxb|ghp|gho|glpat|AKIA)[-_][A-Za-z0-9-_]{6,}/g, "$1-***redacted***").replace(/Bearer\s+[A-Za-z0-9._-]{8,}/gi, "Bearer ***redacted***");
+}
+function httpError(label, status, hint) {
+  return new Error(`${label} returned HTTP ${status} \u2014 ${hint}`);
+}
+async function* streamLines(res) {
+  const reader = res.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buf = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, idx).trim();
+      buf = buf.slice(idx + 1);
+      if (line) yield line;
+    }
+  }
+  if (buf.trim()) yield buf.trim();
+}
+function accumulateOpenAiDelta(acc, chunk, onToken) {
+  const c = chunk;
+  const delta = c.choices?.[0]?.delta;
+  if (delta?.content) {
+    acc.text += delta.content;
+    onToken?.(delta.content);
+  }
+  for (const tc of delta?.tool_calls ?? []) {
+    const idx = tc.index ?? 0;
+    const e = acc.tools.get(idx) ?? { args: "" };
+    if (tc.id) e.id = tc.id;
+    if (tc.function?.name) e.name = tc.function.name;
+    if (tc.function?.arguments) e.args += tc.function.arguments;
+    acc.tools.set(idx, e);
+  }
+  if (c.usage) {
+    acc.usage.promptTokens = c.usage.prompt_tokens;
+    acc.usage.completionTokens = c.usage.completion_tokens;
+  }
+}
+function finalizeTools(tools) {
+  return [...tools.entries()].sort((a, b) => a[0] - b[0]).map(([i, e]) => ({ id: e.id ?? `call_${i}`, name: e.name ?? "unknown", arguments: coerceArgs(e.args) }));
+}
+async function postJson(url, body, headers, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { method: "POST", headers: { "content-type": "application/json", ...headers }, body: JSON.stringify(body), signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var MockProvider = class {
+  constructor(model, reply) {
+    this.model = model;
+    this.reply = reply;
+  }
+  model;
+  reply;
+  id = "mock";
+  label = "Mock (deterministic)";
+  local = true;
+  async chat(_messages, _opts) {
+    return { text: this.reply, model: this.model, provider: this.id };
+  }
+};
+var OllamaProvider = class {
+  constructor(model, host = process.env.OLLAMA_HOST || "http://127.0.0.1:11434") {
+    this.model = model;
+    this.host = host;
+  }
+  model;
+  host;
+  id = "ollama";
+  label = "Ollama (local)";
+  local = true;
+  async chat(messages, opts = {}) {
+    const streaming = !!(opts.stream && opts.onToken);
+    let res;
+    try {
+      res = await postJson(
+        `${this.host.replace(/\/$/, "")}/api/chat`,
+        { model: this.model, messages: openAiMessages(messages), stream: streaming, tools: openAiTools(opts.tools), options: { temperature: opts.temperature ?? 0 } },
+        {},
+        opts.timeoutMs ?? 12e4
+      );
+    } catch {
+      throw new Error(`couldn't reach Ollama at ${this.host} \u2014 is \`ollama serve\` running? (start it, or pass --provider to use a different backend)`);
+    }
+    if (!res.ok) throw httpError("Ollama", res.status, res.status === 404 ? `model "${this.model}" isn't pulled \u2014 run \`ollama pull ${this.model}\` or pick another with --model` : "check `ollama serve` and the model name");
+    if (streaming) {
+      let text = "";
+      let toolCallsRaw;
+      const usage = {};
+      for await (const line of streamLines(res)) {
+        try {
+          const obj = JSON.parse(line);
+          const delta = obj.message?.content;
+          if (delta) {
+            text += delta;
+            opts.onToken?.(delta);
+          }
+          if (obj.message?.tool_calls) toolCallsRaw = obj.message.tool_calls;
+          if (typeof obj.prompt_eval_count === "number") usage.promptTokens = obj.prompt_eval_count;
+          if (typeof obj.eval_count === "number") usage.completionTokens = obj.eval_count;
+        } catch {
+        }
+      }
+      return { text, model: this.model, provider: this.id, toolCalls: parseToolCalls(toolCallsRaw), usage };
+    }
+    const data = await res.json();
+    return {
+      text: data.message?.content ?? "",
+      model: this.model,
+      provider: this.id,
+      toolCalls: parseToolCalls(data.message?.tool_calls),
+      usage: { promptTokens: data.prompt_eval_count, completionTokens: data.eval_count }
+    };
+  }
+};
+var OpenAiCompatibleProvider = class {
+  constructor(model, config) {
+    this.model = model;
+    this.config = config;
+    this.id = config.id;
+    this.label = config.label;
+    this.local = config.local;
+  }
+  model;
+  config;
+  id;
+  label;
+  local;
+  async chat(messages, opts = {}) {
+    const headers = {};
+    if (this.config.apiKeyEnv) {
+      const key = process.env[this.config.apiKeyEnv];
+      if (!key) {
+        throw new Error(`${this.label} needs an API key in ${this.config.apiKeyEnv} \u2014 set it in your environment (never pass keys as flags), or use --local for an on-device backend.`);
+      }
+      headers.authorization = `Bearer ${key}`;
+    }
+    const streaming = !!(opts.stream && opts.onToken);
+    const url = `${this.config.baseUrl.replace(/\/$/, "")}/chat/completions`;
+    const body = {
+      model: this.model,
+      messages: openAiMessages(messages),
+      tools: openAiTools(opts.tools),
+      temperature: opts.temperature ?? 0,
+      max_tokens: opts.maxTokens,
+      stream: streaming,
+      ...streaming ? { stream_options: { include_usage: true } } : {}
+    };
+    let res;
+    try {
+      res = await postJson(url, body, headers, opts.timeoutMs ?? 12e4);
+    } catch {
+      throw new Error(`couldn't reach ${this.label} at ${this.config.baseUrl} \u2014 check the endpoint is up (or use --local).`);
+    }
+    if (!res.ok) {
+      const hint = res.status === 401 || res.status === 403 ? `the key in ${this.config.apiKeyEnv ?? "(none)"} was rejected \u2014 check it has access to "${this.model}"` : `check the model id "${this.model}" and the endpoint`;
+      throw httpError(this.label, res.status, hint);
+    }
+    if (streaming) {
+      const acc = { text: "", tools: /* @__PURE__ */ new Map(), usage: {} };
+      for await (const line of streamLines(res)) {
+        if (!line.startsWith("data:")) continue;
+        const payload = line.slice(5).trim();
+        if (payload === "[DONE]") break;
+        try {
+          accumulateOpenAiDelta(acc, JSON.parse(payload), opts.onToken);
+        } catch {
+        }
+      }
+      const tools = finalizeTools(acc.tools);
+      return { text: acc.text, model: this.model, provider: this.id, toolCalls: tools.length ? tools : void 0, usage: acc.usage };
+    }
+    const data = await res.json();
+    const message = data.choices?.[0]?.message;
+    return {
+      text: message?.content ?? "",
+      model: this.model,
+      provider: this.id,
+      toolCalls: parseToolCalls(message?.tool_calls),
+      usage: { promptTokens: data.usage?.prompt_tokens, completionTokens: data.usage?.completion_tokens }
+    };
+  }
+};
+var OPENAI_COMPATIBLE = {
+  openrouter: { baseUrl: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY", local: false, label: "OpenRouter" },
+  litellm: { baseUrl: process.env.LITELLM_BASE_URL || "http://127.0.0.1:4000", apiKeyEnv: "LITELLM_API_KEY", local: false, label: "LiteLLM" },
+  openai: { baseUrl: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", local: false, label: "OpenAI" },
+  together: { baseUrl: "https://api.together.xyz/v1", apiKeyEnv: "TOGETHER_API_KEY", local: false, label: "Together" },
+  lmstudio: { baseUrl: process.env.LMSTUDIO_BASE_URL || "http://127.0.0.1:1234/v1", local: true, label: "LM Studio (local)" }
+};
+var LocalLlamaProvider = class {
+  constructor(model, modelPath, ensure = ensurePackage, consent = false) {
+    this.model = model;
+    this.modelPath = modelPath;
+    this.ensure = ensure;
+    this.consent = consent;
+  }
+  model;
+  modelPath;
+  ensure;
+  consent;
+  id = "llama-cpp";
+  label = "llama.cpp (local)";
+  local = true;
+  session = null;
+  async chat(messages, opts = {}) {
+    const res = await this.ensure("node-llama-cpp@^3", { consent: this.consent, onUnavailable: () => {
+    } });
+    if (!res.module) {
+      throw new Error(ensureUnavailableMessage(res.reason ?? "no-consent", "node-llama-cpp"));
+    }
+    const lib = res.module;
+    try {
+      const llama = await lib.getLlama();
+      const model = await llama.loadModel({ modelPath: this.modelPath });
+      const ctx = await model.createContext();
+      const { LlamaChatSession } = lib;
+      const chat = new LlamaChatSession({ contextSequence: ctx.getSequence() });
+      const prompt = messages.map((m) => `${m.role}: ${m.content}`).join("\n\n");
+      const text = await chat.prompt(prompt, { temperature: opts.temperature ?? 0, maxTokens: opts.maxTokens });
+      return { text, model: this.model, provider: this.id };
+    } catch (e) {
+      throw new Error(`local llama.cpp inference failed for ${this.modelPath} \u2014 ${redactSecrets(e.message)}`);
+    }
+  }
+};
+
+// src/code/context.ts
+function buildCodeContext(graph, instruction, options = {}) {
+  const budget = options.budget ?? 3e3;
+  const seedLimit = options.seeds ?? 8;
+  const impactDepth = options.impactDepth ?? 2;
+  const index = indexFor(graph);
+  const q = queryGraph(graph, instruction, { budget: Math.floor(budget * 0.6), limit: seedLimit * 2 });
+  let seeds = q.matches.map((m) => ({ node: m.node, why: m.why }));
+  if (options.files && options.files.length) {
+    const set = new Set(options.files.map(normalize));
+    const inScope = seeds.filter((s) => set.has(normalize(s.node.file)));
+    if (inScope.length) seeds = inScope;
+  }
+  seeds = seeds.slice(0, seedLimit);
+  const impacted = /* @__PURE__ */ new Map();
+  for (const s of seeds) {
+    const impact = impactOf(graph, s.node.id, { depth: impactDepth });
+    for (const item of impact.affected.slice(0, 6)) {
+      const node = index.node(item.id);
+      if (node && !impacted.has(node.id)) impacted.set(node.id, { node, via: s.node.qualifiedName });
+    }
+  }
+  const targetFiles = options.files?.length ? [...new Set(options.files.map(normalize))].sort() : [...new Set(seeds.map((s) => s.node.file))].sort();
+  const seedIds = new Set(seeds.map((s) => s.node.id));
+  const pinnedFacts = pinnedFactsFor(graph, seedIds);
+  const rendered = render(instruction, seeds, [...impacted.values()], targetFiles, pinnedFacts, index, budget);
+  return {
+    instruction,
+    seeds,
+    targetFiles,
+    impacted: [...impacted.values()],
+    pinnedFacts,
+    rendered,
+    tokensEstimate: estimateTokens(rendered)
+  };
+}
+function pinnedFactsFor(graph, seedIds) {
+  if (!graph.facts?.length) return [];
+  const out = [];
+  for (const f of graph.facts) {
+    if (f.kind === "characterization") continue;
+    if (!f.subjectIds.some((id) => seedIds.has(id))) continue;
+    const subjects = f.subjectIds.map((id) => graph.nodes.find((n) => n.id === id)?.qualifiedName ?? id).join(", ");
+    out.push(`${f.kind}: ${subjects} \u2014 ${JSON.stringify(f.predicate)}`);
+  }
+  return out.sort().slice(0, 12);
+}
+function render(instruction, seeds, impacted, targetFiles, pinnedFacts, index, budget) {
+  const lines = [];
+  lines.push("# Repository context (from the deterministic code graph)");
+  lines.push("");
+  if (pinnedFacts.length) {
+    lines.push("## Hard constraints (do not violate)");
+    for (const f of pinnedFacts) lines.push(`- ${f}`);
+    lines.push("");
+  }
+  lines.push("## Relevant symbols");
+  for (const { node, why } of seeds) {
+    const block = [];
+    block.push(`### ${node.qualifiedName}  (${node.kind}, ${node.file}:${node.span.start}-${node.span.end})`);
+    if (node.signature) block.push("`" + node.signature + "`");
+    const callees = uniqueNames(index.callees(node.id).map((x) => x.node.qualifiedName)).slice(0, 6);
+    const callers = uniqueNames(index.callers(node.id).map((x) => x.node.qualifiedName)).slice(0, 6);
+    if (callees.length) block.push(`calls: ${callees.join(", ")}`);
+    if (callers.length) block.push(`called by: ${callers.join(", ")}`);
+    block.push(`importance ${node.importance.toFixed(3)}${node.isHub ? " \xB7 hub (high blast radius)" : ""} \xB7 ${why}`);
+    block.push("");
+    const candidate = lines.concat(block).join("\n");
+    if (estimateTokens(candidate) > budget && lines.length > 3) break;
+    lines.push(...block);
+  }
+  if (impacted.length) {
+    lines.push("## Blast radius (would be affected by a change here)");
+    for (const { node, via } of impacted.slice(0, 10)) {
+      lines.push(`- ${node.qualifiedName} (${node.file}:${node.span.start}) \u2014 depends on ${via}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Files in scope for this edit");
+  for (const f of targetFiles) lines.push(`- ${f}`);
+  lines.push("");
+  lines.push("## Task");
+  lines.push(instruction);
+  return lines.join("\n");
+}
+function uniqueNames(xs) {
+  return [...new Set(xs)];
+}
+function normalize(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// src/code/apply.ts
+function parseEdits(text) {
+  const edits = [];
+  const lines = text.split("\n");
+  let i = 0;
+  let pendingFile = "";
+  const isFence = (s) => /^\s*```/.test(s);
+  while (i < lines.length) {
+    const line = lines[i];
+    const create = /^\s*CREATE\s+(\S.*?)\s*$/.exec(line);
+    if (create) {
+      const file = create[1];
+      const body = [];
+      i++;
+      while (i < lines.length && !/^\s*END CREATE\s*$/.test(lines[i])) {
+        if (!isFence(lines[i])) body.push(lines[i]);
+        i++;
+      }
+      i++;
+      edits.push({ op: "create", file, content: body.join("\n") });
+      pendingFile = "";
+      continue;
+    }
+    const del = /^\s*DELETE\s+(\S.*?)\s*$/.exec(line);
+    if (del) {
+      edits.push({ op: "delete", file: del[1] });
+      i++;
+      pendingFile = "";
+      continue;
+    }
+    if (/^\s*<{5,}\s*SEARCH/.test(line)) {
+      const file = pendingFile;
+      const search = [];
+      const replace = [];
+      i++;
+      while (i < lines.length && !/^\s*={5,}\s*$/.test(lines[i])) {
+        search.push(lines[i]);
+        i++;
+      }
+      i++;
+      while (i < lines.length && !/^\s*>{5,}\s*REPLACE/.test(lines[i])) {
+        replace.push(lines[i]);
+        i++;
+      }
+      i++;
+      edits.push({
+        op: "replace",
+        file,
+        search: search.join("\n"),
+        replace: replace.join("\n"),
+        anchorSymbol: void 0
+      });
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed && !isFence(line) && looksLikePath(trimmed)) pendingFile = trimmed.replace(/[:`]+$/, "");
+    i++;
+  }
+  return edits;
+}
+function looksLikePath(s) {
+  if (/\s/.test(s.replace(/:$/, ""))) return false;
+  return /\//.test(s) || /\.[A-Za-z0-9]{1,8}:?$/.test(s);
+}
+function applyEdit(content, edit, spans = []) {
+  if (edit.op === "create") {
+    if (content !== null && content !== edit.content) {
+      return { content, outcome: { edit, status: "conflict", reason: `${edit.file} already exists \u2014 refusing to overwrite it with a create; use a replace edit instead` } };
+    }
+    return { content: edit.content, outcome: { edit, status: content === edit.content ? "no-op" : "applied", matchedBy: "exact" } };
+  }
+  if (edit.op === "delete") {
+    if (content === null) return { content: null, outcome: { edit, status: "no-op", reason: `${edit.file} does not exist \u2014 nothing to delete` } };
+    return { content: null, outcome: { edit, status: "applied", matchedBy: "exact" } };
+  }
+  if (content === null) {
+    return { content: null, outcome: { edit, status: "not-found", reason: `${edit.file} does not exist \u2014 a replace needs an existing file (did you mean CREATE ${edit.file}?)` } };
+  }
+  if (edit.search === "") {
+    if (content === "") return { content: edit.replace, outcome: { edit, status: "applied", matchedBy: "exact" } };
+    return { content, outcome: { edit, status: "invalid", reason: "empty SEARCH on a non-empty file is ambiguous \u2014 quote the exact lines to replace" } };
+  }
+  if (edit.search === edit.replace) {
+    return { content, outcome: { edit, status: "no-op", reason: "SEARCH and REPLACE are identical \u2014 no change" } };
+  }
+  const located = locate(content, edit.search, edit.anchorSymbol, spans, edit.file);
+  if (located.kind === "none") {
+    return { content, outcome: { edit, status: "not-found", reason: `the SEARCH text was not found in ${edit.file} \u2014 it must match the current file exactly (whitespace-flexible)` } };
+  }
+  if (located.kind === "ambiguous") {
+    return {
+      content,
+      outcome: {
+        edit,
+        status: "ambiguous",
+        reason: `the SEARCH text matches ${located.count} places in ${edit.file} \u2014 add more surrounding lines, or name the symbol so the graph can disambiguate`
+      }
+    };
+  }
+  const next = content.slice(0, located.from) + edit.replace + content.slice(located.to);
+  return { content: next, outcome: { edit, status: "applied", matchedBy: located.matchedBy } };
+}
+function applyEdits(edits, read, spansByFile = () => []) {
+  const state = /* @__PURE__ */ new Map();
+  for (const edit of edits) {
+    let entry = state.get(edit.file);
+    if (!entry) {
+      const before = read(edit.file);
+      entry = { before, after: before, outcomes: [] };
+      state.set(edit.file, entry);
+    }
+    const { content, outcome } = applyEdit(entry.after, edit, spansByFile(edit.file));
+    entry.after = content;
+    entry.outcomes.push(outcome);
+  }
+  return state;
+}
+function locate(content, search, anchor, spans, file) {
+  const exact = allIndexes(content, search);
+  if (exact.length === 1) return { kind: "unique", from: exact[0], to: exact[0] + search.length, matchedBy: "exact" };
+  if (exact.length > 1) {
+    const scoped = scopeToAnchor(content, exact.map((from) => ({ from, to: from + search.length })), anchor, spans, file);
+    if (scoped) return { ...scoped, matchedBy: "graph-span" };
+    return { kind: "ambiguous", count: exact.length };
+  }
+  const flex = flexIndexes(content, search);
+  if (flex.length === 1) return { kind: "unique", from: flex[0].from, to: flex[0].to, matchedBy: "whitespace" };
+  if (flex.length > 1) {
+    const scoped = scopeToAnchor(content, flex, anchor, spans, file);
+    if (scoped) return { ...scoped, matchedBy: "graph-span" };
+    return { kind: "ambiguous", count: flex.length };
+  }
+  return { kind: "none" };
+}
+function allIndexes(hay, needle) {
+  const out = [];
+  if (needle === "") return out;
+  let from = 0;
+  for (; ; ) {
+    const idx = hay.indexOf(needle, from);
+    if (idx === -1) break;
+    out.push(idx);
+    from = idx + needle.length;
+  }
+  return out;
+}
+function flexIndexes(content, search) {
+  const cLines = content.split("\n");
+  const sLines = search.split("\n");
+  while (sLines.length && sLines[0].trim() === "") sLines.shift();
+  while (sLines.length && sLines[sLines.length - 1].trim() === "") sLines.pop();
+  if (sLines.length === 0) return [];
+  const sNorm = sLines.map((l) => l.trim());
+  const lineStart = [];
+  let acc = 0;
+  for (const l of cLines) {
+    lineStart.push(acc);
+    acc += l.length + 1;
+  }
+  const out = [];
+  for (let i = 0; i + sNorm.length <= cLines.length; i++) {
+    let ok = true;
+    for (let j = 0; j < sNorm.length; j++) {
+      if (cLines[i + j].trim() !== sNorm[j]) {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) continue;
+    const from = lineStart[i];
+    const lastLine = i + sNorm.length - 1;
+    const to = lineStart[lastLine] + cLines[lastLine].length;
+    out.push({ from, to });
+  }
+  return out;
+}
+function scopeToAnchor(content, candidates, anchor, spans, file) {
+  if (!anchor) return null;
+  const span = spans.find((s) => s.file === file && s.qualifiedName === anchor);
+  if (!span) return null;
+  const lineOf = lineIndexer(content);
+  const inside = candidates.filter((c) => {
+    const line = lineOf(c.from);
+    return line >= span.start && line <= span.end;
+  });
+  if (inside.length === 1) return { kind: "unique", from: inside[0].from, to: inside[0].to };
+  return null;
+}
+function lineIndexer(content) {
+  const starts = [0];
+  for (let i = 0; i < content.length; i++) if (content[i] === "\n") starts.push(i + 1);
+  return (offset) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  };
+}
+
+// src/code/diff.ts
+function unifiedDiff(before, after, file, context = 3) {
+  if (before === after) return "";
+  if (before === null) return newFileDiff(after ?? "", file);
+  if (after === null) return deletedFileDiff(before, file);
+  const a = splitLines(before);
+  const b = splitLines(after);
+  const ops = diffLines(a, b);
+  const hunks = groupHunks(ops, context);
+  if (hunks.length === 0) return "";
+  const out = [`--- a/${file}`, `+++ b/${file}`];
+  for (const h of hunks) {
+    out.push(`@@ -${h.aStart},${h.aLen} +${h.bStart},${h.bLen} @@`);
+    for (const line of h.lines) out.push(line);
+  }
+  return out.join("\n");
+}
+function newFileDiff(after, file) {
+  const lines = splitLines(after);
+  const out = [`--- /dev/null`, `+++ b/${file}`, `@@ -0,0 +1,${lines.length} @@`];
+  for (const l of lines) out.push(`+${l}`);
+  return out.join("\n");
+}
+function deletedFileDiff(before, file) {
+  const lines = splitLines(before);
+  const out = [`--- a/${file}`, `+++ /dev/null`, `@@ -1,${lines.length} +0,0 @@`];
+  for (const l of lines) out.push(`-${l}`);
+  return out.join("\n");
+}
+function splitLines(s) {
+  if (s === "") return [];
+  const lines = s.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function diffLines(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ tag: "eq", line: a[i] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ tag: "del", line: a[i] });
+      i++;
+    } else {
+      ops.push({ tag: "add", line: b[j] });
+      j++;
+    }
+  }
+  while (i < n) ops.push({ tag: "del", line: a[i++] });
+  while (j < m) ops.push({ tag: "add", line: b[j++] });
+  return ops;
+}
+function groupHunks(ops, context) {
+  const changeIdx = ops.map((o, i) => o.tag === "eq" ? -1 : i).filter((i) => i >= 0);
+  if (changeIdx.length === 0) return [];
+  const windows = [];
+  let start = Math.max(0, changeIdx[0] - context);
+  let end = Math.min(ops.length - 1, changeIdx[0] + context);
+  for (let k = 1; k < changeIdx.length; k++) {
+    const cs = Math.max(0, changeIdx[k] - context);
+    const ce = Math.min(ops.length - 1, changeIdx[k] + context);
+    if (cs <= end + 1) {
+      end = ce;
+    } else {
+      windows.push([start, end]);
+      start = cs;
+      end = ce;
+    }
+  }
+  windows.push([start, end]);
+  const hunks = [];
+  let aLine = 1;
+  let bLine = 1;
+  let idx = 0;
+  for (const [ws, we] of windows) {
+    while (idx < ws) {
+      const o = ops[idx];
+      if (o.tag !== "add") aLine++;
+      if (o.tag !== "del") bLine++;
+      idx++;
+    }
+    const hunk = { aStart: aLine, aLen: 0, bStart: bLine, bLen: 0, lines: [] };
+    for (let k = ws; k <= we; k++) {
+      const o = ops[k];
+      if (o.tag === "eq") {
+        hunk.lines.push(` ${o.line}`);
+        hunk.aLen++;
+        hunk.bLen++;
+        aLine++;
+        bLine++;
+      } else if (o.tag === "del") {
+        hunk.lines.push(`-${o.line}`);
+        hunk.aLen++;
+        aLine++;
+      } else {
+        hunk.lines.push(`+${o.line}`);
+        hunk.bLen++;
+        bLine++;
+      }
+      idx = k + 1;
+    }
+    if (hunk.aLen === 0) hunk.aStart = Math.max(0, hunk.aStart - 1);
+    if (hunk.bLen === 0) hunk.bStart = Math.max(0, hunk.bStart - 1);
+    hunks.push(hunk);
+  }
+  return hunks;
+}
+function summarizeDiffs(diffs) {
+  let adds = 0;
+  let dels = 0;
+  let touched = 0;
+  for (const { diff } of diffs) {
+    if (!diff) continue;
+    touched++;
+    for (const line of diff.split("\n")) {
+      if (line.startsWith("+") && !line.startsWith("+++")) adds++;
+      else if (line.startsWith("-") && !line.startsWith("---")) dels++;
+    }
+  }
+  return `+${adds} -${dels} across ${touched} file(s)`;
+}
+
+// src/code/prompt.ts
+var CODE_SYSTEM_PROMPT = [
+  "You are a precise code-editing assistant operating inside the Vibgrate CLI.",
+  "You are given repository context derived from a deterministic code graph, then a task.",
+  "Propose the smallest correct change. Do not restate unchanged code.",
+  "",
+  "Reply ONLY with edit blocks in this exact format, one per change:",
+  "",
+  "<path/to/file>",
+  "<<<<<<< SEARCH",
+  "<exact current lines to find>",
+  "=======",
+  "<replacement lines>",
+  ">>>>>>> REPLACE",
+  "",
+  "The SEARCH text must match the current file (whitespace differences are tolerated).",
+  "To add a new file use:",
+  "CREATE <path/to/file>",
+  "<full file body>",
+  "END CREATE",
+  "To remove a file use: DELETE <path/to/file>",
+  "",
+  "Respect every hard constraint in the context. Keep edits minimal and self-consistent."
+].join("\n");
+function buildMessages(context) {
+  return [
+    { role: "system", content: CODE_SYSTEM_PROMPT },
+    { role: "user", content: context.rendered },
+    { role: "user", content: `Now produce the edit blocks for: ${context.instruction}` }
+  ];
+}
+var AGENT_SYSTEM_PROMPT = [
+  "You are VG Code, a precise coding agent working inside a real repository.",
+  "You have tools: search_code (searches a deterministic code graph \u2014 prefer it over guessing),",
+  "read_file, list_files, graph_impact (blast radius of a change), edit_file, create_file,",
+  "delete_file, run_command, and finish.",
+  "",
+  "Work in small steps: search or read to understand before you edit; check graph_impact before",
+  "changing shared code; make the smallest correct edit; run the tests or build to verify when useful.",
+  "edit_file replaces an exact snippet \u2014 the search text must match the current file (whitespace is",
+  "tolerated). Do not restate unchanged code. When the task is complete, call finish with a short summary.",
+  "",
+  "Editing, creating, deleting, and running commands require user approval \u2014 expect some to be declined,",
+  "and adapt if so. Never invent file contents; read first."
+].join("\n");
+function buildAgentMessages(context) {
+  return [
+    { role: "system", content: AGENT_SYSTEM_PROMPT },
+    { role: "user", content: context.rendered },
+    { role: "user", content: `Task: ${context.instruction}` }
+  ];
+}
+
+export { LocalLlamaProvider, MockProvider, OPENAI_COMPATIBLE, OllamaProvider, OpenAiCompatibleProvider, applyEdit, applyEdits, buildAgentMessages, buildCodeContext, buildMessages, parseEdits, redactSecrets, summarizeDiffs, unifiedDiff };
+//# sourceMappingURL=chunk-CS37OBE3.js.map
+//# sourceMappingURL=chunk-CS37OBE3.js.map