gearbox-code 0.1.10 → 0.1.11

package/dist/cli.mjs

@@ -70313,7 +70313,7 @@ var import_react21 = __toESM(require_react(), 1);
 import { createInterface } from "node:readline/promises";
 import { execFileSync as execFileSync4, spawnSync } from "node:child_process";
 import { resolve as resolve11 } from "node:path";
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 
 // src/ui/App.tsx
 var import_react26 = __toESM(require_react(), 1);
@@ -132189,6 +132189,70 @@ async function runShellStream(command, opts = {}) {
 
 // src/tools.ts
 init_proc();
+
+// src/fetch.ts
+var MAX_FETCH_CHARS = 80000;
+var MAX_RETURN_CHARS = 20000;
+var ENTITY = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " "
+};
+function urlsInText(text2, limit = 2) {
+  const out = [];
+  const re = /\bhttps?:\/\/[^\s<>"')\]]+/gi;
+  for (const m2 of text2.matchAll(re)) {
+    const url2 = m2[0].replace(/[.,;:!?]+$/, "");
+    if (!out.includes(url2))
+      out.push(url2);
+    if (out.length >= limit)
+      break;
+  }
+  return out;
+}
+function decodeEntities(text2) {
+  return text2.replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (_, raw) => {
+    const key = raw.toLowerCase();
+    if (key[0] === "#") {
+      const n = key[1] === "x" ? Number.parseInt(key.slice(2), 16) : Number.parseInt(key.slice(1), 10);
+      return Number.isFinite(n) ? String.fromCodePoint(n) : "";
+    }
+    return ENTITY[key] ?? "";
+  });
+}
+function stripHtml(html2) {
+  return decodeEntities(html2.replace(/<script\b[\s\S]*?<\/script>/gi, " ").replace(/<style\b[\s\S]*?<\/style>/gi, " ").replace(/<noscript\b[\s\S]*?<\/noscript>/gi, " ").replace(/<\/(p|div|section|article|header|footer|li|tr|h[1-6])>/gi, `
+`).replace(/<br\s*\/?>/gi, `
+`).replace(/<[^>]+>/g, " ").replace(/[ \t]+\n/g, `
+`).replace(/\n{3,}/g, `
+
+`).replace(/[ \t]{2,}/g, " ").trim());
+}
+async function fetchUrlText(url2) {
+  const u = new URL(url2);
+  if (u.protocol !== "http:" && u.protocol !== "https:")
+    throw new Error("only http(s) URLs are supported");
+  const res = await fetch(u, {
+    headers: {
+      "user-agent": "Gearbox/0.1 (+https://github.com/AnayGarodia/gearbox)",
+      accept: "text/html,text/plain,application/json;q=0.8,*/*;q=0.2"
+    }
+  });
+  if (!res.ok)
+    throw new Error(`fetch failed: HTTP ${res.status}`);
+  const raw = (await res.text()).slice(0, MAX_FETCH_CHARS);
+  const contentType = res.headers.get("content-type") ?? "";
+  const title = raw.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1]?.replace(/\s+/g, " ").trim();
+  const text2 = (/html/i.test(contentType) || /<html|<body|<p\b|<div\b/i.test(raw) ? stripHtml(raw) : raw.trim()).slice(0, MAX_RETURN_CHARS);
+  if (!text2)
+    throw new Error("fetched URL had no readable text");
+  return { url: u.toString(), title: title ? decodeEntities(title) : undefined, text: text2, chars: text2.length };
+}
+
+// src/tools.ts
 var ROOT = process.cwd();
 var CAP2 = 60000;
 var DENIED = "Permission denied by the user — they declined this action.";
@@ -132202,6 +132266,44 @@ function safe(path) {
 }
 var clip2 = (s2) => s2.length > CAP2 ? s2.slice(0, CAP2) + `
 … [clipped ${s2.length - CAP2} chars]` : s2;
+function countOccurrences(text2, find2) {
+  if (!find2)
+    return 0;
+  let count = 0;
+  let at3 = 0;
+  while ((at3 = text2.indexOf(find2, at3)) >= 0) {
+    count++;
+    at3 += find2.length;
+  }
+  return count;
+}
+function replaceOccurrence(text2, find2, replace2, occurrence) {
+  let at3 = -1;
+  let from = 0;
+  for (let i2 = 0;i2 < occurrence; i2++) {
+    at3 = text2.indexOf(find2, from);
+    if (at3 < 0)
+      return text2;
+    from = at3 + find2.length;
+  }
+  return text2.slice(0, at3) + replace2 + text2.slice(at3 + find2.length);
+}
+function notFoundHint(path, before2, find2) {
+  const needle = find2.trim().split(/\s+/).filter((w) => w.length >= 3)[0]?.toLowerCase();
+  if (!needle)
+    return `text not found in ${path}`;
+  const lines = before2.split(`
+`);
+  const hit = lines.findIndex((l) => l.toLowerCase().includes(needle));
+  if (hit < 0)
+    return `text not found in ${path}`;
+  const start = Math.max(0, hit - 2);
+  const end = Math.min(lines.length, hit + 3);
+  const snippet = lines.slice(start, end).map((l, i2) => `${start + i2 + 1}: ${l}`).join(`
+`);
+  return `text not found in ${path}. Nearby match for "${needle}":
+${snippet}`;
+}
 function createTools(onEvent) {
   return {
     read_file: tool5({
@@ -132224,19 +132326,38 @@ function createTools(onEvent) {
       }
     }),
     edit_file: tool5({
-      description: "Replace the first exact occurrence of `find` with `replace` in a file.",
-      inputSchema: exports_external2.object({ path: exports_external2.string(), find: exports_external2.string(), replace: exports_external2.string() }),
-      execute: async ({ path, find: find2, replace: replace2 }) => {
+      description: "Edit a file by exact text replacement. Use occurrence for a specific match, or replaceAll for every exact match.",
+      inputSchema: exports_external2.object({
+        path: exports_external2.string(),
+        find: exports_external2.string().min(1),
+        replace: exports_external2.string(),
+        occurrence: exports_external2.number().int().positive().default(1).describe("1-based match to replace when replaceAll is false"),
+        replaceAll: exports_external2.boolean().default(false).describe("replace every exact occurrence")
+      }),
+      execute: async ({ path, find: find2, replace: replace2, occurrence, replaceAll }) => {
         const abs = safe(path);
         const before2 = await readFile(abs, "utf8");
-        if (!before2.includes(find2))
-          throw new Error(`text not found in ${path}`);
+        const matches2 = countOccurrences(before2, find2);
+        if (matches2 === 0)
+          throw new Error(notFoundHint(path, before2, find2));
+        if (!replaceAll && occurrence > matches2)
+          throw new Error(`only found ${matches2} occurrence${matches2 === 1 ? "" : "s"} in ${path}; requested occurrence ${occurrence}`);
         if (!await requestPermission({ kind: "edit", title: "Edit a file", detail: path }))
           throw new Error(DENIED);
-        const after2 = before2.replace(find2, replace2);
+        const after2 = replaceAll ? before2.split(find2).join(replace2) : replaceOccurrence(before2, find2, replace2, occurrence);
         await writeFile2(abs, after2, "utf8");
         const diff2 = computeDiff(before2, after2);
-        return { summary: `edited ${path} (${diffStat(diff2)})`, diff: diff2 };
+        const changed = replaceAll ? matches2 : 1;
+        return { summary: `edited ${path} · ${changed} replacement${changed === 1 ? "" : "s"} (${diffStat(diff2)})`, diff: diff2 };
+      }
+    }),
+    fetch_url: tool5({
+      description: "Fetch a public http(s) URL and return readable text. Use this for docs, release notes, issue pages, or pasted links.",
+      inputSchema: exports_external2.object({ url: exports_external2.string().url() }),
+      execute: async ({ url: url2 }) => {
+        const page = await fetchUrlText(url2);
+        return clip2([`URL: ${page.url}`, page.title ? `Title: ${page.title}` : "", "", page.text].filter(Boolean).join(`
+`));
       }
     }),
     search: tool5({
@@ -132342,7 +132463,8 @@ var readOnlyTools = {
   read_file: tools.read_file,
   list_dir: tools.list_dir,
   search: tools.search,
-  glob: tools.glob
+  glob: tools.glob,
+  fetch_url: tools.fetch_url
 };
 
 // node_modules/js-tiktoken/dist/chunk-VL2OQCWN.js
@@ -132799,6 +132921,42 @@ function retrieveFiles(query, cwd2 = process.cwd(), k = 6, budget = 8000, modelI
   return out;
 }
 
+// src/context/git.ts
+init_proc();
+function git(args, cwd2) {
+  const r2 = spawnSyncProc(["git", ...args], { cwd: cwd2, stdout: "pipe", stderr: "ignore" });
+  return r2.exitCode === 0 ? r2.stdout.toString().trim() : "";
+}
+function gitContext(cwd2 = process.cwd()) {
+  if (!git(["rev-parse", "--is-inside-work-tree"], cwd2))
+    return "";
+  const branch = git(["branch", "--show-current"], cwd2) || git(["rev-parse", "--short", "HEAD"], cwd2);
+  const status = git(["status", "--short"], cwd2);
+  const staged = git(["diff", "--cached", "--stat"], cwd2);
+  const unstaged = git(["diff", "--stat"], cwd2);
+  const commits = git(["log", "--oneline", "-5"], cwd2);
+  const parts = [];
+  if (branch)
+    parts.push(`branch: ${branch}`);
+  if (status)
+    parts.push(`dirty files:
+${status}`);
+  else
+    parts.push("working tree: clean");
+  if (staged)
+    parts.push(`staged diff stat:
+${staged}`);
+  if (unstaged)
+    parts.push(`unstaged diff stat:
+${unstaged}`);
+  if (commits)
+    parts.push(`recent commits:
+${commits}`);
+  return parts.join(`
+
+`);
+}
+
 // src/context/builder.ts
 var BASE_SYSTEM = `You are Gearbox, a precise terminal coding agent.
 Work in small, verifiable steps. Use the tools to read before you write, and
@@ -132910,6 +133068,14 @@ function buildContext(opts) {
 ${memory}`;
     sections.push({ name: "memory", tokens: countTokens(memory, modelId) });
   }
+  const git2 = safe2(() => gitContext(cwd2), "");
+  if (git2) {
+    system += `
+
+# GIT CONTEXT (current repository state; do not overwrite unrelated user changes)
+${git2}`;
+    sections.push({ name: "git", tokens: countTokens(git2, modelId) });
+  }
   const mapBudget = Math.min(4000, Math.floor(inputBudget * 0.05));
   const map3 = safe2(() => repoMap(cwd2, mapBudget), "");
   if (map3) {
@@ -133379,6 +133545,171 @@ ${summary}` },
   return { messages, summarizedTurns: old.length, before: before2, after: after2 };
 }
 
+// src/init.ts
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join12 } from "node:path";
+
+// src/verify.ts
+import { existsSync as existsSync7, readFileSync as readFileSync12 } from "node:fs";
+import { join as join11 } from "node:path";
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync12(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function packageManager(cwd2) {
+  if (existsSync7(join11(cwd2, "bun.lock")) || existsSync7(join11(cwd2, "bun.lockb")))
+    return "bun";
+  if (existsSync7(join11(cwd2, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (existsSync7(join11(cwd2, "yarn.lock")))
+    return "yarn";
+  return "npm";
+}
+function packageCommands(cwd2) {
+  const pkg = readJson(join11(cwd2, "package.json"));
+  const scripts = pkg?.scripts ?? {};
+  if (!scripts || typeof scripts !== "object")
+    return [];
+  const pm = packageManager(cwd2);
+  const run = (name31) => pm === "npm" ? `npm run ${name31}` : `${pm} run ${name31}`;
+  const cmds = [];
+  if (scripts.typecheck)
+    cmds.push({ command: run("typecheck"), reason: "typecheck script" });
+  if (scripts.test)
+    cmds.push({ command: pm === "npm" ? "npm test" : pm === "bun" ? "bun test" : `${pm} test`, reason: "test script" });
+  if (scripts.build)
+    cmds.push({ command: run("build"), reason: "build script" });
+  return cmds;
+}
+function detectVerificationCommands(cwd2 = process.cwd(), changedFiles = []) {
+  const cmds = packageCommands(cwd2);
+  const hasPython = changedFiles.some((f3) => /\.py$/.test(f3)) || existsSync7(join11(cwd2, "pyproject.toml")) || existsSync7(join11(cwd2, "pytest.ini"));
+  const hasRust = changedFiles.some((f3) => /\.rs$/.test(f3)) || existsSync7(join11(cwd2, "Cargo.toml"));
+  const hasGo = changedFiles.some((f3) => /\.go$/.test(f3)) || existsSync7(join11(cwd2, "go.mod"));
+  if (hasPython && !cmds.some((c) => /\bpytest\b/.test(c.command)))
+    cmds.push({ command: "pytest", reason: "python project" });
+  if (hasRust && !cmds.some((c) => /\bcargo\s+test\b/.test(c.command)))
+    cmds.push({ command: "cargo test", reason: "rust project" });
+  if (hasGo && !cmds.some((c) => /\bgo\s+test\b/.test(c.command)))
+    cmds.push({ command: "go test ./...", reason: "go project" });
+  return cmds.slice(0, 3);
+}
+function summarize(output) {
+  const lines = output.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  const fail = lines.find((l) => /\b(error|failed|failures?|exception|panic)\b/i.test(l));
+  return (fail ?? lines[0] ?? "(no output)").slice(0, 160);
+}
+async function runVerification(commands, opts) {
+  const results = [];
+  for (const c of commands) {
+    opts.onEvent({ type: "phase", label: "verifying", detail: `${c.command} · ${c.reason}`, state: "running" });
+    const r2 = await runShellStream(c.command, { signal: opts.signal, timeoutMs: opts.timeoutMs ?? 120000 });
+    results.push(r2);
+    opts.onEvent({ type: "verification", command: c.command, ok: r2.ok, summary: r2.ok ? "passed" : summarize(r2.output) });
+    opts.onEvent({ type: "phase", label: "verification", detail: c.command, state: r2.ok ? "ok" : "err" });
+    if (!r2.ok)
+      break;
+  }
+  return results;
+}
+
+// src/init.ts
+function readJson2(path) {
+  try {
+    return JSON.parse(readFileSync13(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function rootEntries(cwd2) {
+  try {
+    return readdirSync4(cwd2, { withFileTypes: true }).filter((e2) => ![".git", "node_modules", "dist", "build", ".next", "coverage"].includes(e2.name)).map((e2) => e2.name + (e2.isDirectory() ? "/" : "")).sort().slice(0, 80);
+  } catch {
+    return [];
+  }
+}
+function detectStack(cwd2) {
+  const out = [];
+  const pkg = readJson2(join12(cwd2, "package.json"));
+  if (pkg) {
+    const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    out.push("JavaScript/TypeScript");
+    if (deps.react || deps.ink)
+      out.push(deps.ink ? "Ink terminal UI" : "React");
+    if (existsSync8(join12(cwd2, "bun.lock")) || existsSync8(join12(cwd2, "bun.lockb")))
+      out.push("Bun");
+  }
+  if (existsSync8(join12(cwd2, "pyproject.toml")))
+    out.push("Python");
+  if (existsSync8(join12(cwd2, "Cargo.toml")))
+    out.push("Rust");
+  if (existsSync8(join12(cwd2, "go.mod")))
+    out.push("Go");
+  return [...new Set(out)];
+}
+function packageScripts(cwd2) {
+  const pkg = readJson2(join12(cwd2, "package.json"));
+  const scripts = pkg?.scripts ?? {};
+  return Object.keys(scripts).sort().map((k) => `${k}: ${scripts[k]}`).slice(0, 20);
+}
+function existingDocs(cwd2) {
+  return ["README.md", "DESIGN.md", "ROADMAP.md", "VISION.md", "AGENTS.md", "CLAUDE.md"].filter((name31) => existsSync8(join12(cwd2, name31)));
+}
+function buildProjectGuide(cwd2 = process.cwd()) {
+  const name31 = readJson2(join12(cwd2, "package.json"))?.name ?? cwd2.split(/[\\/]/).filter(Boolean).at(-1) ?? "project";
+  const stack = detectStack(cwd2);
+  const checks3 = detectVerificationCommands(cwd2).map((c) => c.command);
+  const scripts = packageScripts(cwd2);
+  const entries = rootEntries(cwd2);
+  const docs = existingDocs(cwd2);
+  return `# ${name31} - Gearbox Guide
+
+## What This Project Is
+
+This file was generated from the repository structure so Gearbox has project context before editing.
+${stack.length ? `Detected stack: ${stack.join(", ")}.` : "Detected stack: unknown from root files."}
+
+## Run And Verify
+
+${checks3.length ? checks3.map((c) => `- \`${c}\``).join(`
+`) : "- No standard verification command was detected. Add one here when known."}
+
+## Layout
+
+${entries.length ? entries.map((e2) => `- \`${e2}\``).join(`
+`) : "- Root layout could not be read."}
+
+${scripts.length ? `## Package Scripts
+
+${scripts.map((s2) => `- \`${s2}\``).join(`
+`)}
+
+` : ""}## Existing Project Docs
+
+${docs.length ? docs.map((d) => `- \`${d}\``).join(`
+`) : "- No common docs detected."}
+
+## Agent Conventions
+
+- Read relevant files before editing.
+- Keep changes scoped to the user request.
+- Do not overwrite unrelated dirty work.
+- Run the verification commands above after edits when practical.
+`;
+}
+function writeProjectGuide(cwd2 = process.cwd()) {
+  const path = join12(cwd2, "GEARBOX.md");
+  const before2 = existsSync8(path) ? readFileSync13(path, "utf8") : "";
+  const after2 = buildProjectGuide(cwd2);
+  writeFileSync7(path, after2, "utf8");
+  const diff2 = computeDiff(before2, after2);
+  return { path, summary: `wrote GEARBOX.md (${diffStat(diff2)})`, diff: diff2 };
+}
+
 // src/ui/clipboard.ts
 init_proc();
 function osc52(text2) {
@@ -133582,7 +133913,7 @@ function gitBranch() {
 init_proc();
 var jsx_dev_runtime12 = __toESM(require_jsx_dev_runtime(), 1);
 import { basename as basename2, extname } from "node:path";
-import { existsSync as existsSync7, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync14, statSync as statSync4 } from "node:fs";
 import { writeFile as fsWriteFile } from "node:fs/promises";
 import { spawnSync as nodeSpawnSync2 } from "node:child_process";
 var accountResolver = new AccountResolver;
@@ -133686,12 +134017,12 @@ function previewLang(path) {
 }
 function filePreview(path) {
   try {
-    if (!path || !existsSync7(path))
+    if (!path || !existsSync9(path))
       return null;
     const st = statSync4(path);
     if (!st.isFile() || st.size > 400000)
       return null;
-    const raw = readFileSync12(path, "utf8").replace(/\r\n?/g, `
+    const raw = readFileSync14(path, "utf8").replace(/\r\n?/g, `
 `);
     const lines = raw.split(`
 `);
@@ -134754,9 +135085,32 @@ function App2({ selector: initialSelector, runner, fullscreen = false, resumeId
     echo(prompt);
     lastPromptRef.current = prompt;
     setVerb(nextVerb());
-    const { text: modelPrompt, attached } = expandMentions(prompt);
+    let { text: modelPrompt, attached } = expandMentions(prompt);
     if (attached.length)
       notice(`attached ${attached.length} file${attached.length > 1 ? "s" : ""}: ${attached.join(", ")}`);
+    const urls = urlsInText(modelPrompt);
+    if (urls.length) {
+      const fetched = [];
+      for (const url2 of urls) {
+        try {
+          const page = await fetchUrlText(url2);
+          fetched.push(`=== ${page.url}${page.title ? ` · ${page.title}` : ""} ===
+${page.text}`);
+        } catch (e2) {
+          notice(`couldn't fetch ${url2}: ${(e2?.message ?? String(e2)).split(`
+`)[0]}`);
+        }
+      }
+      if (fetched.length) {
+        notice(`fetched ${fetched.length} URL${fetched.length === 1 ? "" : "s"} for context`);
+        modelPrompt += `
+
+# FETCHED URL CONTEXT
+${fetched.join(`
+
+`)}`;
+      }
+    }
     setBusy(true);
     setSuggestion(null);
     const turnStart = Date.now();
@@ -134915,6 +135269,16 @@ function App2({ selector: initialSelector, runner, fullscreen = false, resumeId
     try {
       const r2 = await (runner ?? defaultRunner)({ prompt: modelPrompt, messages: msgRef.current, onEvent, selector: selectorRef.current, signal: ac.signal });
       msgRef.current = r2.messages;
+      if (!hadError && !ac.signal.aborted && changedFiles.size && checks3.length === 0) {
+        const commands = detectVerificationCommands(process.cwd(), [...changedFiles]);
+        if (commands.length) {
+          const results = await runVerification(commands, { onEvent, signal: ac.signal });
+          if (results.some((res) => !res.ok))
+            hadError = true;
+        } else {
+          onEvent({ type: "phase", label: "verification skipped", detail: "no test/build/typecheck command detected", state: "err" });
+        }
+      }
       let modelId = activeCliRef.current?.id ?? routedRef.current?.model.id;
       if (!modelId) {
         try {
@@ -135619,7 +135983,31 @@ function App2({ selector: initialSelector, runner, fullscreen = false, resumeId
             notice("busy — try /init again once the current turn finishes");
             return;
           }
-          runTurn("Initialize project memory: survey this repository (use the repo map and read the key entry points, config, and docs) and write a concise GEARBOX.md at the repo root covering what the project is, how to build/test/run it, the layout, and any conventions a new contributor must know. Keep it tight and accurate.");
+          echo(text2);
+          setBusy(true);
+          setSuggestion(null);
+          (async () => {
+            const id = idRef.current++;
+            try {
+              push({ kind: "tool", id, callId: `init:${id}`, name: "write_file", arg: "GEARBOX.md", status: "running", summary: "", startedAt: Date.now() });
+              const res = writeProjectGuide(process.cwd());
+              setItems((prev) => prev.map((i2) => i2.id === id && i2.kind === "tool" ? { ...i2, status: "ok", summary: res.summary, diff: res.diff, endedAt: Date.now() } : i2));
+              const commands = detectVerificationCommands(process.cwd(), ["GEARBOX.md"]);
+              if (commands.length)
+                await runVerification(commands.slice(0, 1), { onEvent: (e2) => {
+                  if (e2.type === "verification")
+                    push({ kind: "verification", id: idRef.current++, command: e2.command, ok: e2.ok, summary: e2.summary });
+                  else if (e2.type === "phase")
+                    push({ kind: "phase", id: idRef.current++, label: e2.label, detail: e2.detail, state: e2.state ?? "running" });
+                } });
+              notice("initialized GEARBOX.md");
+              persist();
+            } catch (e2) {
+              setItems((prev) => prev.map((i2) => i2.id === id && i2.kind === "tool" ? { ...i2, status: "err", summary: e2?.message ?? String(e2), endedAt: Date.now() } : i2));
+            } finally {
+              setBusy(false);
+            }
+          })();
           return;
         default: {
           echo(text2);
@@ -135897,7 +136285,7 @@ function App2({ selector: initialSelector, runner, fullscreen = false, resumeId
     if (!busyRef.current && input.length > 3 && !input.includes(`
 `)) {
       const p = sanitizeInputText(input).trim().replace(/^'|'$/g, "").replace(/\\ /g, " ");
-      if (/[/\\.]/.test(p) && p.length < 1024 && existsSync7(p)) {
+      if (/[/\\.]/.test(p) && p.length < 1024 && existsSync9(p)) {
         const e2 = editRef.current;
         const ins = `@${p} `;
         setEdit({ value: e2.value.slice(0, e2.cursor) + ins + e2.value.slice(e2.cursor), cursor: e2.cursor + ins.length });
@@ -136307,7 +136695,7 @@ function App2({ selector: initialSelector, runner, fullscreen = false, resumeId
 var jsx_dev_runtime13 = __toESM(require_jsx_dev_runtime(), 1);
 process.env.LANG = process.env.LANG || "en_US.UTF-8";
 process.env.LC_ALL = process.env.LC_ALL || "en_US.UTF-8";
-var VERSION16 = "0.1.10";
+var VERSION16 = "0.1.11";
 var args = process.argv.slice(2);
 var supportsAnsi = process.env.NO_COLOR !== "1" && process.env.TERM !== "dumb" && (process.stdout.isTTY || process.env.FORCE_COLOR === "1");
 var ansi = (code) => supportsAnsi ? `\x1B[${code}m` : "";
@@ -136525,7 +136913,7 @@ async function readStdin() {
 }
 if (args[0] === "upgrade" || args[0] === "update") {
   const root2 = resolve11(import.meta.dir, "..");
-  if (!existsSync8(resolve11(root2, ".git"))) {
+  if (!existsSync10(resolve11(root2, ".git"))) {
     console.log("This build can't self-update (not a git checkout).");
     console.log("Update by pulling the repo and reinstalling:  git pull && bun install");
     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gearbox-code",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "A beautiful multi-provider coding harness for the terminal. (Intelligent model routing lands on top of this soon.)",
   "type": "module",
   "license": "MIT",