@austinthesing/magic-shell 0.1.2 → 0.2.0

package/dist/index.js

@@ -518,22 +518,128 @@ function getPlatformPaths(platform) {
 }
 var init_shell = () => {};
 
+// src/lib/repo-context.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function detectRepoContext(cwd) {
+  const context = {
+    type: "unknown"
+  };
+  let detected = false;
+  if (existsSync3(join2(cwd, ".git"))) {
+    context.hasGit = true;
+    detected = true;
+  }
+  if (existsSync3(join2(cwd, "Dockerfile")) || existsSync3(join2(cwd, "docker-compose.yml")) || existsSync3(join2(cwd, "docker-compose.yaml"))) {
+    context.hasDocker = true;
+    detected = true;
+  }
+  const packageJsonPath = join2(cwd, "package.json");
+  if (existsSync3(packageJsonPath)) {
+    detected = true;
+    context.type = "node";
+    try {
+      const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+      if (existsSync3(join2(cwd, "bun.lockb")) || existsSync3(join2(cwd, "bun.lock"))) {
+        context.packageManager = "bun";
+      } else if (existsSync3(join2(cwd, "pnpm-lock.yaml"))) {
+        context.packageManager = "pnpm";
+      } else if (existsSync3(join2(cwd, "yarn.lock"))) {
+        context.packageManager = "yarn";
+      } else if (existsSync3(join2(cwd, "package-lock.json"))) {
+        context.packageManager = "npm";
+      } else if (packageJson.packageManager) {
+        const pm = packageJson.packageManager.split("@")[0];
+        context.packageManager = pm;
+      }
+      if (packageJson.scripts && typeof packageJson.scripts === "object") {
+        context.scripts = Object.keys(packageJson.scripts);
+      }
+    } catch {}
+  }
+  const makefilePath = join2(cwd, "Makefile");
+  if (existsSync3(makefilePath)) {
+    detected = true;
+    if (context.type === "unknown")
+      context.type = "make";
+    try {
+      const makefile = readFileSync2(makefilePath, "utf-8");
+      const targetRegex = /^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:/gm;
+      const targets = [];
+      let match;
+      while ((match = targetRegex.exec(makefile)) !== null) {
+        if (!match[1].startsWith(".") && !match[1].startsWith("_")) {
+          targets.push(match[1]);
+        }
+      }
+      if (targets.length > 0) {
+        context.makeTargets = [...new Set(targets)];
+      }
+    } catch {}
+  }
+  if (existsSync3(join2(cwd, "Cargo.toml"))) {
+    detected = true;
+    context.type = "rust";
+    context.cargoCommands = ["build", "run", "test", "check", "clippy", "fmt", "doc"];
+  }
+  if (existsSync3(join2(cwd, "pyproject.toml")) || existsSync3(join2(cwd, "setup.py")) || existsSync3(join2(cwd, "requirements.txt"))) {
+    detected = true;
+    if (context.type === "unknown")
+      context.type = "python";
+  }
+  if (existsSync3(join2(cwd, "go.mod"))) {
+    detected = true;
+    if (context.type === "unknown")
+      context.type = "go";
+  }
+  return detected ? context : null;
+}
+function formatRepoContext(context) {
+  const lines = [];
+  lines.push(`Project type: ${context.type}`);
+  if (context.packageManager) {
+    lines.push(`Package manager: ${context.packageManager}`);
+  }
+  if (context.scripts && context.scripts.length > 0) {
+    const displayScripts = context.scripts.slice(0, 15);
+    const suffix = context.scripts.length > 15 ? ` (+${context.scripts.length - 15} more)` : "";
+    lines.push(`Available scripts: ${displayScripts.join(", ")}${suffix}`);
+  }
+  if (context.makeTargets && context.makeTargets.length > 0) {
+    const displayTargets = context.makeTargets.slice(0, 15);
+    const suffix = context.makeTargets.length > 15 ? ` (+${context.makeTargets.length - 15} more)` : "";
+    lines.push(`Make targets: ${displayTargets.join(", ")}${suffix}`);
+  }
+  if (context.cargoCommands) {
+    lines.push(`Cargo commands: ${context.cargoCommands.join(", ")}`);
+  }
+  if (context.hasDocker) {
+    lines.push(`Docker: available`);
+  }
+  if (context.hasGit) {
+    lines.push(`Git: initialized`);
+  }
+  return lines.join(`
+`);
+}
+var init_repo_context = () => {};
+
 // src/lib/config.ts
 import { homedir as homedir3 } from "os";
-import { join as join2 } from "path";
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
 function ensureConfigDir2() {
-  if (!existsSync3(CONFIG_DIR2)) {
+  if (!existsSync4(CONFIG_DIR2)) {
     mkdirSync2(CONFIG_DIR2, { recursive: true });
   }
 }
 function loadConfig2() {
   ensureConfigDir2();
-  if (!existsSync3(CONFIG_FILE2)) {
+  if (!existsSync4(CONFIG_FILE2)) {
     return { ...DEFAULT_CONFIG2 };
   }
   try {
-    const data = readFileSync2(CONFIG_FILE2, "utf-8");
+    const data = readFileSync3(CONFIG_FILE2, "utf-8");
     const loaded = JSON.parse(data);
     return { ...DEFAULT_CONFIG2, ...loaded };
   } catch {
@@ -582,11 +688,11 @@ async function setApiKey2(provider, key) {
 }
 function loadHistory2() {
   ensureConfigDir2();
-  if (!existsSync3(HISTORY_FILE2)) {
+  if (!existsSync4(HISTORY_FILE2)) {
     return [];
   }
   try {
-    const data = readFileSync2(HISTORY_FILE2, "utf-8");
+    const data = readFileSync3(HISTORY_FILE2, "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
@@ -605,14 +711,14 @@ function addToHistory(entry) {
 var CONFIG_DIR2, CONFIG_FILE2, HISTORY_FILE2, KEYCHAIN_OPENROUTER2 = "openrouter-api-key", KEYCHAIN_OPENCODE_ZEN2 = "opencode-zen-api-key", DEFAULT_CONFIG2;
 var init_config = __esm(() => {
   init_keychain();
-  CONFIG_DIR2 = join2(homedir3(), ".magic-shell");
-  CONFIG_FILE2 = join2(CONFIG_DIR2, "config.json");
-  HISTORY_FILE2 = join2(CONFIG_DIR2, "history.json");
+  CONFIG_DIR2 = join3(homedir3(), ".magic-shell");
+  CONFIG_FILE2 = join3(CONFIG_DIR2, "config.json");
+  HISTORY_FILE2 = join3(CONFIG_DIR2, "history.json");
   DEFAULT_CONFIG2 = {
     provider: "opencode-zen",
     openrouterApiKey: "",
     opencodeZenApiKey: "",
-    defaultModel: "gpt-5-nano",
+    defaultModel: "gemini-3-flash",
     safetyLevel: "moderate",
     dryRunByDefault: false,
     blockedCommands: [
@@ -623,7 +729,8 @@ var init_config = __esm(() => {
       "chmod -R 777 /",
       "chown -R"
     ],
-    confirmedDangerousPatterns: []
+    confirmedDangerousPatterns: [],
+    repoContext: false
   };
 });
 
@@ -679,8 +786,8 @@ import { EventEmitter as EventEmitter3 } from "events";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { resolve as resolve2, isAbsolute, parse } from "path";
-import { existsSync as existsSync4 } from "fs";
-import { basename, join as join3 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { basename, join as join5 } from "path";
 import os from "os";
 import path from "path";
 import { EventEmitter as EventEmitter4 } from "events";
@@ -1430,6 +1537,13 @@ function t(strings, ...values) {
   }
   return new StyledText(chunks);
 }
+
+class LinearScrollAccel {
+  tick(_now) {
+    return 1;
+  }
+  reset() {}
+}
 function isCompleteSequence(data) {
   if (!data.startsWith(ESC)) {
     return "not-escape";
@@ -2035,7 +2149,7 @@ function getBunfsRootPath() {
   return process.platform === "win32" ? "B:\\~BUN\\root" : "/$bunfs/root";
 }
 function normalizeBunfsPath(fileName) {
-  return join3(getBunfsRootPath(), basename(fileName));
+  return join5(getBunfsRootPath(), basename(fileName));
 }
 function isValidDirectoryName(name) {
   if (!name || typeof name !== "string") {
@@ -11894,7 +12008,7 @@ var init_index_93qf6w1k = __esm(async () => {
         worker_path = this.options.workerPath;
       } else {
         worker_path = new URL("./parser.worker.js", import.meta.url).href;
-        if (!existsSync4(resolve2(import.meta.dirname, "parser.worker.js"))) {
+        if (!existsSync6(resolve2(import.meta.dirname, "parser.worker.js"))) {
           worker_path = new URL("./parser.worker.ts", import.meta.url).href;
         }
       }
@@ -17249,7 +17363,7 @@ function canonicalize(obj, stack, replacementStack, replacer, key) {
   }
   return canonicalizedObj;
 }
-var EditBuffer, engine, BoxRenderable, TextBufferRenderable, BrandedTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, CharacterDiff, characterDiff, extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}", tokenizeIncludingWhitespace, WordDiff, wordDiff, WordsWithSpaceDiff, wordsWithSpaceDiff, LineDiff, lineDiff, SentenceDiff, sentenceDiff, CssDiff, cssDiff, JsonDiff, jsonDiff, ArrayDiff, arrayDiff, TextRenderable, defaultInputKeybindings, InputRenderableEvents, InputRenderable, defaultThumbBackgroundColor, defaultTrackBackgroundColor, defaultSelectKeybindings, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, EditBufferRenderable;
+var EditBuffer, engine, BoxRenderable, TextBufferRenderable, BrandedTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, CharacterDiff, characterDiff, extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}", tokenizeIncludingWhitespace, WordDiff, wordDiff, WordsWithSpaceDiff, wordsWithSpaceDiff, LineDiff, lineDiff, SentenceDiff, sentenceDiff, CssDiff, cssDiff, JsonDiff, jsonDiff, ArrayDiff, arrayDiff, TextRenderable, defaultInputKeybindings, InputRenderableEvents, InputRenderable, defaultThumbBackgroundColor, defaultTrackBackgroundColor, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ContentRenderable, ScrollBoxRenderable, defaultSelectKeybindings, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, EditBufferRenderable;
 var init_core = __esm(async () => {
   await init_index_93qf6w1k();
   EditBuffer = class EditBuffer extends EventEmitter10 {
@@ -18968,220 +19082,1360 @@ var init_core = __esm(async () => {
   };
   defaultThumbBackgroundColor = RGBA.fromHex("#9a9ea3");
   defaultTrackBackgroundColor = RGBA.fromHex("#252527");
-  defaultSelectKeybindings = [
-    { name: "up", action: "move-up" },
-    { name: "k", action: "move-up" },
-    { name: "down", action: "move-down" },
-    { name: "j", action: "move-down" },
-    { name: "up", shift: true, action: "move-up-fast" },
-    { name: "down", shift: true, action: "move-down-fast" },
-    { name: "return", action: "select-current" },
-    { name: "linefeed", action: "select-current" }
-  ];
-  ((SelectRenderableEvents2) => {
-    SelectRenderableEvents2["SELECTION_CHANGED"] = "selectionChanged";
-    SelectRenderableEvents2["ITEM_SELECTED"] = "itemSelected";
-  })(SelectRenderableEvents ||= {});
-  SelectRenderable = class SelectRenderable extends Renderable {
-    _focusable = true;
-    _options = [];
-    _selectedIndex = 0;
-    scrollOffset = 0;
-    maxVisibleItems;
+  SliderRenderable = class SliderRenderable extends Renderable {
+    orientation;
+    _value;
+    _min;
+    _max;
+    _viewPortSize;
     _backgroundColor;
-    _textColor;
-    _focusedBackgroundColor;
-    _focusedTextColor;
-    _selectedBackgroundColor;
-    _selectedTextColor;
-    _descriptionColor;
-    _selectedDescriptionColor;
-    _showScrollIndicator;
-    _wrapSelection;
-    _showDescription;
-    _font;
-    _itemSpacing;
-    linesPerItem;
-    fontHeight;
-    _fastScrollStep;
-    _keyBindingsMap;
-    _keyAliasMap;
-    _keyBindings;
-    _defaultOptions = {
-      backgroundColor: "transparent",
-      textColor: "#FFFFFF",
-      focusedBackgroundColor: "#1a1a1a",
-      focusedTextColor: "#FFFFFF",
-      selectedBackgroundColor: "#334455",
-      selectedTextColor: "#FFFF00",
-      selectedIndex: 0,
-      descriptionColor: "#888888",
-      selectedDescriptionColor: "#CCCCCC",
-      showScrollIndicator: false,
-      wrapSelection: false,
-      showDescription: true,
-      itemSpacing: 0,
-      fastScrollStep: 5
-    };
+    _foregroundColor;
+    _onChange;
     constructor(ctx, options) {
-      super(ctx, { ...options, buffered: true });
-      this._options = options.options || [];
-      const requestedIndex = options.selectedIndex ?? this._defaultOptions.selectedIndex;
-      this._selectedIndex = this._options.length > 0 ? Math.min(requestedIndex, this._options.length - 1) : 0;
-      this._backgroundColor = parseColor(options.backgroundColor || this._defaultOptions.backgroundColor);
-      this._textColor = parseColor(options.textColor || this._defaultOptions.textColor);
-      this._focusedBackgroundColor = parseColor(options.focusedBackgroundColor || this._defaultOptions.focusedBackgroundColor);
-      this._focusedTextColor = parseColor(options.focusedTextColor || this._defaultOptions.focusedTextColor);
-      this._showScrollIndicator = options.showScrollIndicator ?? this._defaultOptions.showScrollIndicator;
-      this._wrapSelection = options.wrapSelection ?? this._defaultOptions.wrapSelection;
-      this._showDescription = options.showDescription ?? this._defaultOptions.showDescription;
-      this._font = options.font;
-      this._itemSpacing = options.itemSpacing || this._defaultOptions.itemSpacing;
-      this.fontHeight = this._font ? measureText({ text: "A", font: this._font }).height : 1;
-      this.linesPerItem = this._showDescription ? this._font ? this.fontHeight + 1 : 2 : this._font ? this.fontHeight : 1;
-      this.linesPerItem += this._itemSpacing;
-      this.maxVisibleItems = Math.max(1, Math.floor(this.height / this.linesPerItem));
-      this._selectedBackgroundColor = parseColor(options.selectedBackgroundColor || this._defaultOptions.selectedBackgroundColor);
-      this._selectedTextColor = parseColor(options.selectedTextColor || this._defaultOptions.selectedTextColor);
-      this._descriptionColor = parseColor(options.descriptionColor || this._defaultOptions.descriptionColor);
-      this._selectedDescriptionColor = parseColor(options.selectedDescriptionColor || this._defaultOptions.selectedDescriptionColor);
-      this._fastScrollStep = options.fastScrollStep || this._defaultOptions.fastScrollStep;
-      this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
-      this._keyBindings = options.keyBindings || [];
-      const mergedBindings = mergeKeyBindings(defaultSelectKeybindings, this._keyBindings);
-      this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
-      this.requestRender();
+      super(ctx, { flexShrink: 0, ...options });
+      this.orientation = options.orientation;
+      this._min = options.min ?? 0;
+      this._max = options.max ?? 100;
+      this._value = options.value ?? this._min;
+      this._viewPortSize = options.viewPortSize ?? Math.max(1, (this._max - this._min) * 0.1);
+      this._onChange = options.onChange;
+      this._backgroundColor = options.backgroundColor ? parseColor(options.backgroundColor) : defaultTrackBackgroundColor;
+      this._foregroundColor = options.foregroundColor ? parseColor(options.foregroundColor) : defaultThumbBackgroundColor;
+      this.setupMouseHandling();
     }
-    renderSelf(buffer, deltaTime) {
-      if (!this.visible || !this.frameBuffer)
-        return;
-      if (this.isDirty) {
-        this.refreshFrameBuffer();
+    get value() {
+      return this._value;
+    }
+    set value(newValue) {
+      const clamped = Math.max(this._min, Math.min(this._max, newValue));
+      if (clamped !== this._value) {
+        this._value = clamped;
+        this._onChange?.(clamped);
+        this.emit("change", { value: clamped });
+        this.requestRender();
       }
     }
-    refreshFrameBuffer() {
-      if (!this.frameBuffer || this._options.length === 0)
-        return;
-      const bgColor = this._focused ? this._focusedBackgroundColor : this._backgroundColor;
-      this.frameBuffer.clear(bgColor);
-      const contentX = 0;
-      const contentY = 0;
-      const contentWidth = this.width;
-      const contentHeight = this.height;
-      const visibleOptions = this._options.slice(this.scrollOffset, this.scrollOffset + this.maxVisibleItems);
-      for (let i = 0;i < visibleOptions.length; i++) {
-        const actualIndex = this.scrollOffset + i;
-        const option = visibleOptions[i];
-        const isSelected = actualIndex === this._selectedIndex;
-        const itemY = contentY + i * this.linesPerItem;
-        if (itemY + this.linesPerItem - 1 >= contentY + contentHeight)
-          break;
-        if (isSelected) {
-          const contentHeight2 = this.linesPerItem - this._itemSpacing;
-          this.frameBuffer.fillRect(contentX, itemY, contentWidth, contentHeight2, this._selectedBackgroundColor);
-        }
-        const nameContent = `${isSelected ? "▶ " : "  "}${option.name}`;
-        const baseTextColor = this._focused ? this._focusedTextColor : this._textColor;
-        const nameColor = isSelected ? this._selectedTextColor : baseTextColor;
-        let descX = contentX + 3;
-        if (this._font) {
-          const indicator = isSelected ? "▶ " : "  ";
-          this.frameBuffer.drawText(indicator, contentX + 1, itemY, nameColor);
-          const indicatorWidth = 2;
-          renderFontToFrameBuffer(this.frameBuffer, {
-            text: option.name,
-            x: contentX + 1 + indicatorWidth,
-            y: itemY,
-            color: nameColor,
-            backgroundColor: isSelected ? this._selectedBackgroundColor : bgColor,
-            font: this._font
-          });
-          descX = contentX + 1 + indicatorWidth;
-        } else {
-          this.frameBuffer.drawText(nameContent, contentX + 1, itemY, nameColor);
+    get min() {
+      return this._min;
+    }
+    set min(newMin) {
+      if (newMin !== this._min) {
+        this._min = newMin;
+        if (this._value < newMin) {
+          this.value = newMin;
         }
-        if (this._showDescription && itemY + this.fontHeight < contentY + contentHeight) {
-          const descColor = isSelected ? this._selectedDescriptionColor : this._descriptionColor;
-          this.frameBuffer.drawText(option.description, descX, itemY + this.fontHeight, descColor);
+        this.requestRender();
+      }
+    }
+    get max() {
+      return this._max;
+    }
+    set max(newMax) {
+      if (newMax !== this._max) {
+        this._max = newMax;
+        if (this._value > newMax) {
+          this.value = newMax;
         }
+        this.requestRender();
       }
-      if (this._showScrollIndicator && this._options.length > this.maxVisibleItems) {
-        this.renderScrollIndicatorToFrameBuffer(contentX, contentY, contentWidth, contentHeight);
+    }
+    set viewPortSize(size) {
+      const clampedSize = Math.max(0.01, Math.min(size, this._max - this._min));
+      if (clampedSize !== this._viewPortSize) {
+        this._viewPortSize = clampedSize;
+        this.requestRender();
       }
     }
-    renderScrollIndicatorToFrameBuffer(contentX, contentY, contentWidth, contentHeight) {
-      if (!this.frameBuffer)
-        return;
-      const scrollPercent = this._selectedIndex / Math.max(1, this._options.length - 1);
-      const indicatorHeight = Math.max(1, contentHeight - 2);
-      const indicatorY = contentY + 1 + Math.floor(scrollPercent * indicatorHeight);
-      const indicatorX = contentX + contentWidth - 1;
-      this.frameBuffer.drawText("█", indicatorX, indicatorY, parseColor("#666666"));
+    get viewPortSize() {
+      return this._viewPortSize;
     }
-    get options() {
-      return this._options;
+    get backgroundColor() {
+      return this._backgroundColor;
     }
-    set options(options) {
-      this._options = options;
-      this._selectedIndex = Math.min(this._selectedIndex, Math.max(0, options.length - 1));
-      this.updateScrollOffset();
+    set backgroundColor(value) {
+      this._backgroundColor = parseColor(value);
       this.requestRender();
     }
-    getSelectedOption() {
-      return this._options[this._selectedIndex] || null;
+    get foregroundColor() {
+      return this._foregroundColor;
     }
-    getSelectedIndex() {
-      return this._selectedIndex;
+    set foregroundColor(value) {
+      this._foregroundColor = parseColor(value);
+      this.requestRender();
     }
-    moveUp(steps = 1) {
-      const newIndex = this._selectedIndex - steps;
-      if (newIndex >= 0) {
-        this._selectedIndex = newIndex;
-      } else if (this._wrapSelection && this._options.length > 0) {
-        this._selectedIndex = this._options.length - 1;
+    calculateDragOffsetVirtual(event) {
+      const trackStart = this.orientation === "vertical" ? this.y : this.x;
+      const mousePos = (this.orientation === "vertical" ? event.y : event.x) - trackStart;
+      const virtualMousePos = Math.max(0, Math.min((this.orientation === "vertical" ? this.height : this.width) * 2, mousePos * 2));
+      const virtualThumbStart = this.getVirtualThumbStart();
+      const virtualThumbSize = this.getVirtualThumbSize();
+      return Math.max(0, Math.min(virtualThumbSize, virtualMousePos - virtualThumbStart));
+    }
+    setupMouseHandling() {
+      let isDragging = false;
+      let dragOffsetVirtual = 0;
+      this.onMouseDown = (event) => {
+        event.stopPropagation();
+        event.preventDefault();
+        const thumb = this.getThumbRect();
+        const inThumb = event.x >= thumb.x && event.x < thumb.x + thumb.width && event.y >= thumb.y && event.y < thumb.y + thumb.height;
+        if (inThumb) {
+          isDragging = true;
+          dragOffsetVirtual = this.calculateDragOffsetVirtual(event);
+        } else {
+          this.updateValueFromMouseDirect(event);
+          isDragging = true;
+          dragOffsetVirtual = this.calculateDragOffsetVirtual(event);
+        }
+      };
+      this.onMouseDrag = (event) => {
+        if (!isDragging)
+          return;
+        event.stopPropagation();
+        this.updateValueFromMouseWithOffset(event, dragOffsetVirtual);
+      };
+      this.onMouseUp = (event) => {
+        if (isDragging) {
+          this.updateValueFromMouseWithOffset(event, dragOffsetVirtual);
+        }
+        isDragging = false;
+      };
+    }
+    updateValueFromMouseDirect(event) {
+      const trackStart = this.orientation === "vertical" ? this.y : this.x;
+      const trackSize = this.orientation === "vertical" ? this.height : this.width;
+      const mousePos = this.orientation === "vertical" ? event.y : event.x;
+      const relativeMousePos = mousePos - trackStart;
+      const clampedMousePos = Math.max(0, Math.min(trackSize, relativeMousePos));
+      const ratio = trackSize === 0 ? 0 : clampedMousePos / trackSize;
+      const range = this._max - this._min;
+      const newValue = this._min + ratio * range;
+      this.value = newValue;
+    }
+    updateValueFromMouseWithOffset(event, offsetVirtual) {
+      const trackStart = this.orientation === "vertical" ? this.y : this.x;
+      const trackSize = this.orientation === "vertical" ? this.height : this.width;
+      const mousePos = this.orientation === "vertical" ? event.y : event.x;
+      const virtualTrackSize = trackSize * 2;
+      const relativeMousePos = mousePos - trackStart;
+      const clampedMousePos = Math.max(0, Math.min(trackSize, relativeMousePos));
+      const virtualMousePos = clampedMousePos * 2;
+      const virtualThumbSize = this.getVirtualThumbSize();
+      const maxThumbStart = Math.max(0, virtualTrackSize - virtualThumbSize);
+      let desiredThumbStart = virtualMousePos - offsetVirtual;
+      desiredThumbStart = Math.max(0, Math.min(maxThumbStart, desiredThumbStart));
+      const ratio = maxThumbStart === 0 ? 0 : desiredThumbStart / maxThumbStart;
+      const range = this._max - this._min;
+      const newValue = this._min + ratio * range;
+      this.value = newValue;
+    }
+    getThumbRect() {
+      const virtualThumbSize = this.getVirtualThumbSize();
+      const virtualThumbStart = this.getVirtualThumbStart();
+      const realThumbStart = Math.floor(virtualThumbStart / 2);
+      const realThumbSize = Math.ceil((virtualThumbStart + virtualThumbSize) / 2) - realThumbStart;
+      if (this.orientation === "vertical") {
+        return {
+          x: this.x,
+          y: this.y + realThumbStart,
+          width: this.width,
+          height: Math.max(1, realThumbSize)
+        };
       } else {
-        this._selectedIndex = 0;
+        return {
+          x: this.x + realThumbStart,
+          y: this.y,
+          width: Math.max(1, realThumbSize),
+          height: this.height
+        };
       }
-      this.updateScrollOffset();
-      this.requestRender();
-      this.emit("selectionChanged", this._selectedIndex, this.getSelectedOption());
     }
-    moveDown(steps = 1) {
-      const newIndex = this._selectedIndex + steps;
-      if (newIndex < this._options.length) {
-        this._selectedIndex = newIndex;
-      } else if (this._wrapSelection && this._options.length > 0) {
-        this._selectedIndex = 0;
+    renderSelf(buffer) {
+      if (this.orientation === "horizontal") {
+        this.renderHorizontal(buffer);
       } else {
-        this._selectedIndex = this._options.length - 1;
+        this.renderVertical(buffer);
+      }
+    }
+    renderHorizontal(buffer) {
+      const virtualThumbSize = this.getVirtualThumbSize();
+      const virtualThumbStart = this.getVirtualThumbStart();
+      const virtualThumbEnd = virtualThumbStart + virtualThumbSize;
+      buffer.fillRect(this.x, this.y, this.width, this.height, this._backgroundColor);
+      const realStartCell = Math.floor(virtualThumbStart / 2);
+      const realEndCell = Math.ceil(virtualThumbEnd / 2) - 1;
+      const startX = Math.max(0, realStartCell);
+      const endX = Math.min(this.width - 1, realEndCell);
+      for (let realX = startX;realX <= endX; realX++) {
+        const virtualCellStart = realX * 2;
+        const virtualCellEnd = virtualCellStart + 2;
+        const thumbStartInCell = Math.max(virtualThumbStart, virtualCellStart);
+        const thumbEndInCell = Math.min(virtualThumbEnd, virtualCellEnd);
+        const coverage = thumbEndInCell - thumbStartInCell;
+        let char = " ";
+        if (coverage >= 2) {
+          char = "█";
+        } else {
+          const isLeftHalf = thumbStartInCell === virtualCellStart;
+          if (isLeftHalf) {
+            char = "▌";
+          } else {
+            char = "▐";
+          }
+        }
+        for (let y = 0;y < this.height; y++) {
+          buffer.setCellWithAlphaBlending(this.x + realX, this.y + y, char, this._foregroundColor, this._backgroundColor);
+        }
       }
-      this.updateScrollOffset();
-      this.requestRender();
-      this.emit("selectionChanged", this._selectedIndex, this.getSelectedOption());
     }
-    selectCurrent() {
-      const selected = this.getSelectedOption();
-      if (selected) {
-        this.emit("itemSelected", this._selectedIndex, selected);
+    renderVertical(buffer) {
+      const virtualThumbSize = this.getVirtualThumbSize();
+      const virtualThumbStart = this.getVirtualThumbStart();
+      const virtualThumbEnd = virtualThumbStart + virtualThumbSize;
+      buffer.fillRect(this.x, this.y, this.width, this.height, this._backgroundColor);
+      const realStartCell = Math.floor(virtualThumbStart / 2);
+      const realEndCell = Math.ceil(virtualThumbEnd / 2) - 1;
+      const startY = Math.max(0, realStartCell);
+      const endY = Math.min(this.height - 1, realEndCell);
+      for (let realY = startY;realY <= endY; realY++) {
+        const virtualCellStart = realY * 2;
+        const virtualCellEnd = virtualCellStart + 2;
+        const thumbStartInCell = Math.max(virtualThumbStart, virtualCellStart);
+        const thumbEndInCell = Math.min(virtualThumbEnd, virtualCellEnd);
+        const coverage = thumbEndInCell - thumbStartInCell;
+        let char = " ";
+        if (coverage >= 2) {
+          char = "█";
+        } else if (coverage > 0) {
+          const virtualPositionInCell = thumbStartInCell - virtualCellStart;
+          if (virtualPositionInCell === 0) {
+            char = "▀";
+          } else {
+            char = "▄";
+          }
+        }
+        for (let x = 0;x < this.width; x++) {
+          buffer.setCellWithAlphaBlending(this.x + x, this.y + realY, char, this._foregroundColor, this._backgroundColor);
+        }
       }
     }
-    setSelectedIndex(index) {
-      if (index >= 0 && index < this._options.length) {
-        this._selectedIndex = index;
-        this.updateScrollOffset();
-        this.requestRender();
-        this.emit("selectionChanged", this._selectedIndex, this.getSelectedOption());
-      }
+    getVirtualThumbSize() {
+      const virtualTrackSize = this.orientation === "vertical" ? this.height * 2 : this.width * 2;
+      const range = this._max - this._min;
+      if (range === 0)
+        return virtualTrackSize;
+      const viewportSize = Math.max(1, this._viewPortSize);
+      const contentSize = range + viewportSize;
+      if (contentSize <= viewportSize)
+        return virtualTrackSize;
+      const thumbRatio = viewportSize / contentSize;
+      const calculatedSize = Math.floor(virtualTrackSize * thumbRatio);
+      return Math.max(1, Math.min(calculatedSize, virtualTrackSize));
+    }
+    getVirtualThumbStart() {
+      const virtualTrackSize = this.orientation === "vertical" ? this.height * 2 : this.width * 2;
+      const range = this._max - this._min;
+      if (range === 0)
+        return 0;
+      const valueRatio = (this._value - this._min) / range;
+      const virtualThumbSize = this.getVirtualThumbSize();
+      return Math.round(valueRatio * (virtualTrackSize - virtualThumbSize));
     }
-    updateScrollOffset() {
-      if (!this._options)
-        return;
-      const halfVisible = Math.floor(this.maxVisibleItems / 2);
-      const newScrollOffset = Math.max(0, Math.min(this._selectedIndex - halfVisible, this._options.length - this.maxVisibleItems));
-      if (newScrollOffset !== this.scrollOffset) {
-        this.scrollOffset = newScrollOffset;
-        this.requestRender();
-      }
+  };
+  ScrollBarRenderable = class ScrollBarRenderable extends Renderable {
+    slider;
+    startArrow;
+    endArrow;
+    orientation;
+    _focusable = true;
+    _scrollSize = 0;
+    _scrollPosition = 0;
+    _viewportSize = 0;
+    _showArrows = false;
+    _manualVisibility = false;
+    _onChange;
+    scrollStep = null;
+    get visible() {
+      return super.visible;
+    }
+    set visible(value) {
+      this._manualVisibility = true;
+      super.visible = value;
+    }
+    resetVisibilityControl() {
+      this._manualVisibility = false;
+      this.recalculateVisibility();
+    }
+    get scrollSize() {
+      return this._scrollSize;
+    }
+    get scrollPosition() {
+      return this._scrollPosition;
+    }
+    get viewportSize() {
+      return this._viewportSize;
+    }
+    set scrollSize(value) {
+      if (value === this.scrollSize)
+        return;
+      this._scrollSize = value;
+      this.recalculateVisibility();
+      this.updateSliderFromScrollState();
+      this.scrollPosition = this.scrollPosition;
+    }
+    set scrollPosition(value) {
+      const newPosition = Math.round(Math.min(Math.max(0, value), this.scrollSize - this.viewportSize));
+      if (newPosition !== this._scrollPosition) {
+        this._scrollPosition = newPosition;
+        this.updateSliderFromScrollState();
+      }
+    }
+    set viewportSize(value) {
+      if (value === this.viewportSize)
+        return;
+      this._viewportSize = value;
+      this.slider.viewPortSize = Math.max(1, this._viewportSize);
+      this.recalculateVisibility();
+      this.updateSliderFromScrollState();
+      this.scrollPosition = this.scrollPosition;
+    }
+    get showArrows() {
+      return this._showArrows;
+    }
+    set showArrows(value) {
+      if (value === this._showArrows)
+        return;
+      this._showArrows = value;
+      this.startArrow.visible = value;
+      this.endArrow.visible = value;
+    }
+    constructor(ctx, { trackOptions, arrowOptions, orientation, showArrows = false, ...options }) {
+      super(ctx, {
+        flexDirection: orientation === "vertical" ? "column" : "row",
+        alignSelf: "stretch",
+        alignItems: "stretch",
+        ...options
+      });
+      this._onChange = options.onChange;
+      this.orientation = orientation;
+      this._showArrows = showArrows;
+      const scrollRange = Math.max(0, this._scrollSize - this._viewportSize);
+      const defaultStepSize = Math.max(1, this._viewportSize);
+      const stepSize = trackOptions?.viewPortSize ?? defaultStepSize;
+      this.slider = new SliderRenderable(ctx, {
+        orientation,
+        min: 0,
+        max: scrollRange,
+        value: this._scrollPosition,
+        viewPortSize: stepSize,
+        onChange: (value) => {
+          this._scrollPosition = Math.round(value);
+          this._onChange?.(this._scrollPosition);
+          this.emit("change", { position: this._scrollPosition });
+        },
+        ...orientation === "vertical" ? {
+          width: Math.max(1, Math.min(2, this.width)),
+          height: "100%",
+          marginLeft: "auto"
+        } : {
+          width: "100%",
+          height: 1,
+          marginTop: "auto"
+        },
+        flexGrow: 1,
+        flexShrink: 1,
+        ...trackOptions
+      });
+      this.updateSliderFromScrollState();
+      const arrowOpts = arrowOptions ? {
+        foregroundColor: arrowOptions.backgroundColor,
+        backgroundColor: arrowOptions.backgroundColor,
+        attributes: arrowOptions.attributes,
+        ...arrowOptions
+      } : {};
+      this.startArrow = new ArrowRenderable(ctx, {
+        alignSelf: "center",
+        visible: this.showArrows,
+        direction: this.orientation === "vertical" ? "up" : "left",
+        height: this.orientation === "vertical" ? 1 : 1,
+        ...arrowOpts
+      });
+      this.endArrow = new ArrowRenderable(ctx, {
+        alignSelf: "center",
+        visible: this.showArrows,
+        direction: this.orientation === "vertical" ? "down" : "right",
+        height: this.orientation === "vertical" ? 1 : 1,
+        ...arrowOpts
+      });
+      this.add(this.startArrow);
+      this.add(this.slider);
+      this.add(this.endArrow);
+      let startArrowMouseTimeout = undefined;
+      let endArrowMouseTimeout = undefined;
+      this.startArrow.onMouseDown = (event) => {
+        event.stopPropagation();
+        event.preventDefault();
+        this.scrollBy(-0.5, "viewport");
+        startArrowMouseTimeout = setTimeout(() => {
+          this.scrollBy(-0.5, "viewport");
+          startArrowMouseTimeout = setInterval(() => {
+            this.scrollBy(-0.2, "viewport");
+          }, 200);
+        }, 500);
+      };
+      this.startArrow.onMouseUp = (event) => {
+        event.stopPropagation();
+        clearInterval(startArrowMouseTimeout);
+      };
+      this.endArrow.onMouseDown = (event) => {
+        event.stopPropagation();
+        event.preventDefault();
+        this.scrollBy(0.5, "viewport");
+        endArrowMouseTimeout = setTimeout(() => {
+          this.scrollBy(0.5, "viewport");
+          endArrowMouseTimeout = setInterval(() => {
+            this.scrollBy(0.2, "viewport");
+          }, 200);
+        }, 500);
+      };
+      this.endArrow.onMouseUp = (event) => {
+        event.stopPropagation();
+        clearInterval(endArrowMouseTimeout);
+      };
+    }
+    set arrowOptions(options) {
+      Object.assign(this.startArrow, options);
+      Object.assign(this.endArrow, options);
+      this.requestRender();
+    }
+    set trackOptions(options) {
+      Object.assign(this.slider, options);
+      this.requestRender();
+    }
+    updateSliderFromScrollState() {
+      const scrollRange = Math.max(0, this._scrollSize - this._viewportSize);
+      this.slider.min = 0;
+      this.slider.max = scrollRange;
+      this.slider.value = Math.min(this._scrollPosition, scrollRange);
+    }
+    scrollBy(delta, unit = "absolute") {
+      const multiplier = unit === "viewport" ? this.viewportSize : unit === "content" ? this.scrollSize : unit === "step" ? this.scrollStep ?? 1 : 1;
+      const resolvedDelta = multiplier * delta;
+      this.scrollPosition += resolvedDelta;
+    }
+    recalculateVisibility() {
+      if (!this._manualVisibility) {
+        const sizeRatio = this.scrollSize <= this.viewportSize ? 1 : this.viewportSize / this.scrollSize;
+        super.visible = sizeRatio < 1;
+      }
+    }
+    handleKeyPress(key) {
+      switch (key.name) {
+        case "left":
+        case "h":
+          if (this.orientation !== "horizontal")
+            return false;
+          this.scrollBy(-1 / 5, "viewport");
+          return true;
+        case "right":
+        case "l":
+          if (this.orientation !== "horizontal")
+            return false;
+          this.scrollBy(1 / 5, "viewport");
+          return true;
+        case "up":
+        case "k":
+          if (this.orientation !== "vertical")
+            return false;
+          this.scrollBy(-1 / 5, "viewport");
+          return true;
+        case "down":
+        case "j":
+          if (this.orientation !== "vertical")
+            return false;
+          this.scrollBy(1 / 5, "viewport");
+          return true;
+        case "pageup":
+          this.scrollBy(-1 / 2, "viewport");
+          return true;
+        case "pagedown":
+          this.scrollBy(1 / 2, "viewport");
+          return true;
+        case "home":
+          this.scrollBy(-1, "content");
+          return true;
+        case "end":
+          this.scrollBy(1, "content");
+          return true;
+      }
+      return false;
+    }
+  };
+  ArrowRenderable = class ArrowRenderable extends Renderable {
+    _direction;
+    _foregroundColor;
+    _backgroundColor;
+    _attributes;
+    _arrowChars;
+    constructor(ctx, options) {
+      super(ctx, options);
+      this._direction = options.direction;
+      this._foregroundColor = options.foregroundColor ? parseColor(options.foregroundColor) : RGBA.fromValues(1, 1, 1, 1);
+      this._backgroundColor = options.backgroundColor ? parseColor(options.backgroundColor) : RGBA.fromValues(0, 0, 0, 0);
+      this._attributes = options.attributes ?? 0;
+      this._arrowChars = {
+        up: "▲",
+        down: "▼",
+        left: "◀",
+        right: "▶",
+        ...options.arrowChars
+      };
+      if (!options.width) {
+        this.width = Bun.stringWidth(this.getArrowChar());
+      }
+    }
+    get direction() {
+      return this._direction;
+    }
+    set direction(value) {
+      if (this._direction !== value) {
+        this._direction = value;
+        this.requestRender();
+      }
+    }
+    get foregroundColor() {
+      return this._foregroundColor;
+    }
+    set foregroundColor(value) {
+      if (this._foregroundColor !== value) {
+        this._foregroundColor = parseColor(value);
+        this.requestRender();
+      }
+    }
+    get backgroundColor() {
+      return this._backgroundColor;
+    }
+    set backgroundColor(value) {
+      if (this._backgroundColor !== value) {
+        this._backgroundColor = parseColor(value);
+        this.requestRender();
+      }
+    }
+    get attributes() {
+      return this._attributes;
+    }
+    set attributes(value) {
+      if (this._attributes !== value) {
+        this._attributes = value;
+        this.requestRender();
+      }
+    }
+    set arrowChars(value) {
+      this._arrowChars = {
+        ...this._arrowChars,
+        ...value
+      };
+      this.requestRender();
+    }
+    renderSelf(buffer) {
+      const char = this.getArrowChar();
+      buffer.drawText(char, this.x, this.y, this._foregroundColor, this._backgroundColor, this._attributes);
+    }
+    getArrowChar() {
+      switch (this._direction) {
+        case "up":
+          return this._arrowChars.up;
+        case "down":
+          return this._arrowChars.down;
+        case "left":
+          return this._arrowChars.left;
+        case "right":
+          return this._arrowChars.right;
+        default:
+          return "?";
+      }
+    }
+  };
+  ContentRenderable = class ContentRenderable extends BoxRenderable {
+    viewport;
+    _viewportCulling;
+    constructor(ctx, viewport, viewportCulling, options) {
+      super(ctx, options);
+      this.viewport = viewport;
+      this._viewportCulling = viewportCulling;
+    }
+    get viewportCulling() {
+      return this._viewportCulling;
+    }
+    set viewportCulling(value) {
+      this._viewportCulling = value;
+    }
+    _getVisibleChildren() {
+      if (this._viewportCulling) {
+        return getObjectsInViewport(this.viewport, this.getChildrenSortedByPrimaryAxis(), this.primaryAxis, 0).map((child) => child.num);
+      }
+      return this.getChildrenSortedByPrimaryAxis().map((child) => child.num);
+    }
+  };
+  ScrollBoxRenderable = class ScrollBoxRenderable extends BoxRenderable {
+    static idCounter = 0;
+    internalId = 0;
+    wrapper;
+    viewport;
+    content;
+    horizontalScrollBar;
+    verticalScrollBar;
+    _focusable = true;
+    selectionListener;
+    autoScrollMouseX = 0;
+    autoScrollMouseY = 0;
+    autoScrollThresholdVertical = 3;
+    autoScrollThresholdHorizontal = 3;
+    autoScrollSpeedSlow = 6;
+    autoScrollSpeedMedium = 36;
+    autoScrollSpeedFast = 72;
+    isAutoScrolling = false;
+    cachedAutoScrollSpeed = 3;
+    autoScrollAccumulatorX = 0;
+    autoScrollAccumulatorY = 0;
+    scrollAccumulatorX = 0;
+    scrollAccumulatorY = 0;
+    _stickyScroll;
+    _stickyScrollTop = false;
+    _stickyScrollBottom = false;
+    _stickyScrollLeft = false;
+    _stickyScrollRight = false;
+    _stickyStart;
+    _hasManualScroll = false;
+    _isApplyingStickyScroll = false;
+    scrollAccel;
+    get stickyScroll() {
+      return this._stickyScroll;
+    }
+    set stickyScroll(value) {
+      this._stickyScroll = value;
+      this.updateStickyState();
+    }
+    get stickyStart() {
+      return this._stickyStart;
+    }
+    set stickyStart(value) {
+      this._stickyStart = value;
+      this.updateStickyState();
+    }
+    get scrollTop() {
+      return this.verticalScrollBar.scrollPosition;
+    }
+    set scrollTop(value) {
+      this.verticalScrollBar.scrollPosition = value;
+      if (!this._isApplyingStickyScroll) {
+        const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+        if (!this.isAtStickyPosition() && maxScrollTop > 1) {
+          this._hasManualScroll = true;
+        }
+      }
+      this.updateStickyState();
+    }
+    get scrollLeft() {
+      return this.horizontalScrollBar.scrollPosition;
+    }
+    set scrollLeft(value) {
+      this.horizontalScrollBar.scrollPosition = value;
+      if (!this._isApplyingStickyScroll) {
+        const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+        if (!this.isAtStickyPosition() && maxScrollLeft > 1) {
+          this._hasManualScroll = true;
+        }
+      }
+      this.updateStickyState();
+    }
+    get scrollWidth() {
+      return this.horizontalScrollBar.scrollSize;
+    }
+    get scrollHeight() {
+      return this.verticalScrollBar.scrollSize;
+    }
+    updateStickyState() {
+      if (!this._stickyScroll)
+        return;
+      const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+      const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+      if (this.scrollTop <= 0) {
+        this._stickyScrollTop = true;
+        this._stickyScrollBottom = false;
+      } else if (this.scrollTop >= maxScrollTop) {
+        this._stickyScrollTop = false;
+        this._stickyScrollBottom = true;
+      } else {
+        this._stickyScrollTop = false;
+        this._stickyScrollBottom = false;
+      }
+      if (this.scrollLeft <= 0) {
+        this._stickyScrollLeft = true;
+        this._stickyScrollRight = false;
+      } else if (this.scrollLeft >= maxScrollLeft) {
+        this._stickyScrollLeft = false;
+        this._stickyScrollRight = true;
+      } else {
+        this._stickyScrollLeft = false;
+        this._stickyScrollRight = false;
+      }
+    }
+    applyStickyStart(stickyStart) {
+      this._isApplyingStickyScroll = true;
+      switch (stickyStart) {
+        case "top":
+          this._stickyScrollTop = true;
+          this._stickyScrollBottom = false;
+          this.verticalScrollBar.scrollPosition = 0;
+          break;
+        case "bottom":
+          this._stickyScrollTop = false;
+          this._stickyScrollBottom = true;
+          this.verticalScrollBar.scrollPosition = Math.max(0, this.scrollHeight - this.viewport.height);
+          break;
+        case "left":
+          this._stickyScrollLeft = true;
+          this._stickyScrollRight = false;
+          this.horizontalScrollBar.scrollPosition = 0;
+          break;
+        case "right":
+          this._stickyScrollLeft = false;
+          this._stickyScrollRight = true;
+          this.horizontalScrollBar.scrollPosition = Math.max(0, this.scrollWidth - this.viewport.width);
+          break;
+      }
+      this._isApplyingStickyScroll = false;
+    }
+    constructor(ctx, {
+      wrapperOptions,
+      viewportOptions,
+      contentOptions,
+      rootOptions,
+      scrollbarOptions,
+      verticalScrollbarOptions,
+      horizontalScrollbarOptions,
+      stickyScroll = false,
+      stickyStart,
+      scrollX = false,
+      scrollY = true,
+      scrollAcceleration,
+      viewportCulling = true,
+      ...options
+    }) {
+      super(ctx, {
+        flexDirection: "row",
+        alignItems: "stretch",
+        ...options,
+        ...rootOptions
+      });
+      this.internalId = ScrollBoxRenderable.idCounter++;
+      this._stickyScroll = stickyScroll;
+      this._stickyStart = stickyStart;
+      this.scrollAccel = scrollAcceleration ?? new LinearScrollAccel;
+      this.wrapper = new BoxRenderable(ctx, {
+        flexDirection: "column",
+        flexGrow: 1,
+        ...wrapperOptions,
+        id: `scroll-box-wrapper-${this.internalId}`
+      });
+      super.add(this.wrapper);
+      this.viewport = new BoxRenderable(ctx, {
+        flexDirection: "column",
+        flexGrow: 1,
+        overflow: "hidden",
+        onSizeChange: () => {
+          this.recalculateBarProps();
+        },
+        ...viewportOptions,
+        id: `scroll-box-viewport-${this.internalId}`
+      });
+      this.wrapper.add(this.viewport);
+      this.content = new ContentRenderable(ctx, this.viewport, viewportCulling, {
+        alignSelf: "flex-start",
+        flexShrink: 0,
+        ...scrollX ? { minWidth: "100%" } : { minWidth: "100%", maxWidth: "100%" },
+        ...scrollY ? { minHeight: "100%" } : { minHeight: "100%", maxHeight: "100%" },
+        onSizeChange: () => {
+          this.recalculateBarProps();
+        },
+        ...contentOptions,
+        id: `scroll-box-content-${this.internalId}`
+      });
+      this.viewport.add(this.content);
+      this.verticalScrollBar = new ScrollBarRenderable(ctx, {
+        ...scrollbarOptions,
+        ...verticalScrollbarOptions,
+        arrowOptions: {
+          ...scrollbarOptions?.arrowOptions,
+          ...verticalScrollbarOptions?.arrowOptions
+        },
+        id: `scroll-box-vertical-scrollbar-${this.internalId}`,
+        orientation: "vertical",
+        onChange: (position) => {
+          this.content.translateY = -position;
+          if (!this._isApplyingStickyScroll) {
+            const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+            if (!this.isAtStickyPosition() && maxScrollTop > 1) {
+              this._hasManualScroll = true;
+            }
+          }
+          this.updateStickyState();
+        }
+      });
+      super.add(this.verticalScrollBar);
+      this.horizontalScrollBar = new ScrollBarRenderable(ctx, {
+        ...scrollbarOptions,
+        ...horizontalScrollbarOptions,
+        arrowOptions: {
+          ...scrollbarOptions?.arrowOptions,
+          ...horizontalScrollbarOptions?.arrowOptions
+        },
+        id: `scroll-box-horizontal-scrollbar-${this.internalId}`,
+        orientation: "horizontal",
+        onChange: (position) => {
+          this.content.translateX = -position;
+          if (!this._isApplyingStickyScroll) {
+            const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+            if (!this.isAtStickyPosition() && maxScrollLeft > 1) {
+              this._hasManualScroll = true;
+            }
+          }
+          this.updateStickyState();
+        }
+      });
+      this.wrapper.add(this.horizontalScrollBar);
+      this.recalculateBarProps();
+      if (stickyStart && stickyScroll) {
+        this.applyStickyStart(stickyStart);
+      }
+      this.selectionListener = () => {
+        const selection = this._ctx.getSelection();
+        if (!selection || !selection.isSelecting) {
+          this.stopAutoScroll();
+        }
+      };
+      this._ctx.on("selection", this.selectionListener);
+    }
+    onUpdate(deltaTime) {
+      this.handleAutoScroll(deltaTime);
+    }
+    scrollBy(delta, unit = "absolute") {
+      if (typeof delta === "number") {
+        this.verticalScrollBar.scrollBy(delta, unit);
+      } else {
+        this.verticalScrollBar.scrollBy(delta.y, unit);
+        this.horizontalScrollBar.scrollBy(delta.x, unit);
+      }
+    }
+    scrollTo(position) {
+      if (typeof position === "number") {
+        this.scrollTop = position;
+      } else {
+        this.scrollTop = position.y;
+        this.scrollLeft = position.x;
+      }
+    }
+    isAtStickyPosition() {
+      if (!this._stickyScroll || !this._stickyStart) {
+        return false;
+      }
+      const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+      const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+      switch (this._stickyStart) {
+        case "top":
+          return this.scrollTop === 0;
+        case "bottom":
+          return this.scrollTop >= maxScrollTop;
+        case "left":
+          return this.scrollLeft === 0;
+        case "right":
+          return this.scrollLeft >= maxScrollLeft;
+        default:
+          return false;
+      }
+    }
+    add(obj, index) {
+      return this.content.add(obj, index);
+    }
+    insertBefore(obj, anchor) {
+      return this.content.insertBefore(obj, anchor);
+    }
+    remove(id) {
+      this.content.remove(id);
+    }
+    getChildren() {
+      return this.content.getChildren();
+    }
+    onMouseEvent(event) {
+      if (event.type === "scroll") {
+        let dir = event.scroll?.direction;
+        if (event.modifiers.shift)
+          dir = dir === "up" ? "left" : dir === "down" ? "right" : dir === "right" ? "down" : "up";
+        const baseDelta = event.scroll?.delta ?? 0;
+        const now = Date.now();
+        const multiplier = this.scrollAccel.tick(now);
+        const scrollAmount = baseDelta * multiplier;
+        if (dir === "up") {
+          this.scrollAccumulatorY -= scrollAmount;
+          const integerScroll = Math.trunc(this.scrollAccumulatorY);
+          if (integerScroll !== 0) {
+            this.scrollTop += integerScroll;
+            this.scrollAccumulatorY -= integerScroll;
+          }
+        } else if (dir === "down") {
+          this.scrollAccumulatorY += scrollAmount;
+          const integerScroll = Math.trunc(this.scrollAccumulatorY);
+          if (integerScroll !== 0) {
+            this.scrollTop += integerScroll;
+            this.scrollAccumulatorY -= integerScroll;
+          }
+        } else if (dir === "left") {
+          this.scrollAccumulatorX -= scrollAmount;
+          const integerScroll = Math.trunc(this.scrollAccumulatorX);
+          if (integerScroll !== 0) {
+            this.scrollLeft += integerScroll;
+            this.scrollAccumulatorX -= integerScroll;
+          }
+        } else if (dir === "right") {
+          this.scrollAccumulatorX += scrollAmount;
+          const integerScroll = Math.trunc(this.scrollAccumulatorX);
+          if (integerScroll !== 0) {
+            this.scrollLeft += integerScroll;
+            this.scrollAccumulatorX -= integerScroll;
+          }
+        }
+        const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+        const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+        if (maxScrollTop > 1 || maxScrollLeft > 1) {
+          this._hasManualScroll = true;
+        }
+      }
+      if (event.type === "drag" && event.isSelecting) {
+        this.updateAutoScroll(event.x, event.y);
+      } else if (event.type === "up") {
+        this.stopAutoScroll();
+      }
+    }
+    handleKeyPress(key) {
+      if (this.verticalScrollBar.handleKeyPress(key)) {
+        this._hasManualScroll = true;
+        this.scrollAccel.reset();
+        this.resetScrollAccumulators();
+        return true;
+      }
+      if (this.horizontalScrollBar.handleKeyPress(key)) {
+        this._hasManualScroll = true;
+        this.scrollAccel.reset();
+        this.resetScrollAccumulators();
+        return true;
+      }
+      return false;
+    }
+    resetScrollAccumulators() {
+      this.scrollAccumulatorX = 0;
+      this.scrollAccumulatorY = 0;
+    }
+    startAutoScroll(mouseX, mouseY) {
+      this.stopAutoScroll();
+      this.autoScrollMouseX = mouseX;
+      this.autoScrollMouseY = mouseY;
+      this.cachedAutoScrollSpeed = this.getAutoScrollSpeed(mouseX, mouseY);
+      this.isAutoScrolling = true;
+      if (!this.live) {
+        this.live = true;
+      }
+    }
+    updateAutoScroll(mouseX, mouseY) {
+      this.autoScrollMouseX = mouseX;
+      this.autoScrollMouseY = mouseY;
+      this.cachedAutoScrollSpeed = this.getAutoScrollSpeed(mouseX, mouseY);
+      const scrollX = this.getAutoScrollDirectionX(mouseX);
+      const scrollY = this.getAutoScrollDirectionY(mouseY);
+      if (scrollX === 0 && scrollY === 0) {
+        this.stopAutoScroll();
+      } else if (!this.isAutoScrolling) {
+        this.startAutoScroll(mouseX, mouseY);
+      }
+    }
+    stopAutoScroll() {
+      const wasAutoScrolling = this.isAutoScrolling;
+      this.isAutoScrolling = false;
+      this.autoScrollAccumulatorX = 0;
+      this.autoScrollAccumulatorY = 0;
+      if (wasAutoScrolling && !this.hasOtherLiveReasons()) {
+        this.live = false;
+      }
+    }
+    hasOtherLiveReasons() {
+      return false;
+    }
+    handleAutoScroll(deltaTime) {
+      if (!this.isAutoScrolling)
+        return;
+      const scrollX = this.getAutoScrollDirectionX(this.autoScrollMouseX);
+      const scrollY = this.getAutoScrollDirectionY(this.autoScrollMouseY);
+      const scrollAmount = this.cachedAutoScrollSpeed * (deltaTime / 1000);
+      let scrolled = false;
+      if (scrollX !== 0) {
+        this.autoScrollAccumulatorX += scrollX * scrollAmount;
+        const integerScrollX = Math.trunc(this.autoScrollAccumulatorX);
+        if (integerScrollX !== 0) {
+          this.scrollLeft += integerScrollX;
+          this.autoScrollAccumulatorX -= integerScrollX;
+          scrolled = true;
+        }
+      }
+      if (scrollY !== 0) {
+        this.autoScrollAccumulatorY += scrollY * scrollAmount;
+        const integerScrollY = Math.trunc(this.autoScrollAccumulatorY);
+        if (integerScrollY !== 0) {
+          this.scrollTop += integerScrollY;
+          this.autoScrollAccumulatorY -= integerScrollY;
+          scrolled = true;
+        }
+      }
+      if (scrolled) {
+        this._ctx.requestSelectionUpdate();
+      }
+      if (scrollX === 0 && scrollY === 0) {
+        this.stopAutoScroll();
+      }
+    }
+    getAutoScrollDirectionX(mouseX) {
+      const relativeX = mouseX - this.x;
+      const distToLeft = relativeX;
+      const distToRight = this.width - relativeX;
+      if (distToLeft <= this.autoScrollThresholdHorizontal) {
+        return this.scrollLeft > 0 ? -1 : 0;
+      } else if (distToRight <= this.autoScrollThresholdHorizontal) {
+        const maxScrollLeft = this.scrollWidth - this.viewport.width;
+        return this.scrollLeft < maxScrollLeft ? 1 : 0;
+      }
+      return 0;
+    }
+    getAutoScrollDirectionY(mouseY) {
+      const relativeY = mouseY - this.y;
+      const distToTop = relativeY;
+      const distToBottom = this.height - relativeY;
+      if (distToTop <= this.autoScrollThresholdVertical) {
+        return this.scrollTop > 0 ? -1 : 0;
+      } else if (distToBottom <= this.autoScrollThresholdVertical) {
+        const maxScrollTop = this.scrollHeight - this.viewport.height;
+        return this.scrollTop < maxScrollTop ? 1 : 0;
+      }
+      return 0;
+    }
+    getAutoScrollSpeed(mouseX, mouseY) {
+      const relativeX = mouseX - this.x;
+      const relativeY = mouseY - this.y;
+      const distToLeft = relativeX;
+      const distToRight = this.width - relativeX;
+      const distToTop = relativeY;
+      const distToBottom = this.height - relativeY;
+      const minDistance = Math.min(distToLeft, distToRight, distToTop, distToBottom);
+      if (minDistance <= 1) {
+        return this.autoScrollSpeedFast;
+      } else if (minDistance <= 2) {
+        return this.autoScrollSpeedMedium;
+      } else {
+        return this.autoScrollSpeedSlow;
+      }
+    }
+    recalculateBarProps() {
+      const wasApplyingStickyScroll = this._isApplyingStickyScroll;
+      this._isApplyingStickyScroll = true;
+      this.verticalScrollBar.scrollSize = this.content.height;
+      this.verticalScrollBar.viewportSize = this.viewport.height;
+      this.horizontalScrollBar.scrollSize = this.content.width;
+      this.horizontalScrollBar.viewportSize = this.viewport.width;
+      if (this._stickyScroll) {
+        const newMaxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+        const newMaxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+        if (this._stickyStart && !this._hasManualScroll) {
+          this.applyStickyStart(this._stickyStart);
+        } else {
+          if (this._stickyScrollTop) {
+            this.scrollTop = 0;
+          } else if (this._stickyScrollBottom && newMaxScrollTop > 0) {
+            this.scrollTop = newMaxScrollTop;
+          }
+          if (this._stickyScrollLeft) {
+            this.scrollLeft = 0;
+          } else if (this._stickyScrollRight && newMaxScrollLeft > 0) {
+            this.scrollLeft = newMaxScrollLeft;
+          }
+        }
+      }
+      this._isApplyingStickyScroll = wasApplyingStickyScroll;
+      process.nextTick(() => {
+        this.requestRender();
+      });
+    }
+    set rootOptions(options) {
+      Object.assign(this, options);
+      this.requestRender();
+    }
+    set wrapperOptions(options) {
+      Object.assign(this.wrapper, options);
+      this.requestRender();
+    }
+    set viewportOptions(options) {
+      Object.assign(this.viewport, options);
+      this.requestRender();
+    }
+    set contentOptions(options) {
+      Object.assign(this.content, options);
+      this.requestRender();
+    }
+    set scrollbarOptions(options) {
+      Object.assign(this.verticalScrollBar, options);
+      Object.assign(this.horizontalScrollBar, options);
+      this.requestRender();
+    }
+    set verticalScrollbarOptions(options) {
+      Object.assign(this.verticalScrollBar, options);
+      this.requestRender();
+    }
+    set horizontalScrollbarOptions(options) {
+      Object.assign(this.horizontalScrollBar, options);
+      this.requestRender();
+    }
+    get scrollAcceleration() {
+      return this.scrollAccel;
+    }
+    set scrollAcceleration(value) {
+      this.scrollAccel = value;
+    }
+    get viewportCulling() {
+      return this.content.viewportCulling;
+    }
+    set viewportCulling(value) {
+      this.content.viewportCulling = value;
+      this.requestRender();
+    }
+    destroySelf() {
+      if (this.selectionListener) {
+        this._ctx.off("selection", this.selectionListener);
+        this.selectionListener = undefined;
+      }
+      super.destroySelf();
+    }
+  };
+  defaultSelectKeybindings = [
+    { name: "up", action: "move-up" },
+    { name: "k", action: "move-up" },
+    { name: "down", action: "move-down" },
+    { name: "j", action: "move-down" },
+    { name: "up", shift: true, action: "move-up-fast" },
+    { name: "down", shift: true, action: "move-down-fast" },
+    { name: "return", action: "select-current" },
+    { name: "linefeed", action: "select-current" }
+  ];
+  ((SelectRenderableEvents2) => {
+    SelectRenderableEvents2["SELECTION_CHANGED"] = "selectionChanged";
+    SelectRenderableEvents2["ITEM_SELECTED"] = "itemSelected";
+  })(SelectRenderableEvents ||= {});
+  SelectRenderable = class SelectRenderable extends Renderable {
+    _focusable = true;
+    _options = [];
+    _selectedIndex = 0;
+    scrollOffset = 0;
+    maxVisibleItems;
+    _backgroundColor;
+    _textColor;
+    _focusedBackgroundColor;
+    _focusedTextColor;
+    _selectedBackgroundColor;
+    _selectedTextColor;
+    _descriptionColor;
+    _selectedDescriptionColor;
+    _showScrollIndicator;
+    _wrapSelection;
+    _showDescription;
+    _font;
+    _itemSpacing;
+    linesPerItem;
+    fontHeight;
+    _fastScrollStep;
+    _keyBindingsMap;
+    _keyAliasMap;
+    _keyBindings;
+    _defaultOptions = {
+      backgroundColor: "transparent",
+      textColor: "#FFFFFF",
+      focusedBackgroundColor: "#1a1a1a",
+      focusedTextColor: "#FFFFFF",
+      selectedBackgroundColor: "#334455",
+      selectedTextColor: "#FFFF00",
+      selectedIndex: 0,
+      descriptionColor: "#888888",
+      selectedDescriptionColor: "#CCCCCC",
+      showScrollIndicator: false,
+      wrapSelection: false,
+      showDescription: true,
+      itemSpacing: 0,
+      fastScrollStep: 5
+    };
+    constructor(ctx, options) {
+      super(ctx, { ...options, buffered: true });
+      this._options = options.options || [];
+      const requestedIndex = options.selectedIndex ?? this._defaultOptions.selectedIndex;
+      this._selectedIndex = this._options.length > 0 ? Math.min(requestedIndex, this._options.length - 1) : 0;
+      this._backgroundColor = parseColor(options.backgroundColor || this._defaultOptions.backgroundColor);
+      this._textColor = parseColor(options.textColor || this._defaultOptions.textColor);
+      this._focusedBackgroundColor = parseColor(options.focusedBackgroundColor || this._defaultOptions.focusedBackgroundColor);
+      this._focusedTextColor = parseColor(options.focusedTextColor || this._defaultOptions.focusedTextColor);
+      this._showScrollIndicator = options.showScrollIndicator ?? this._defaultOptions.showScrollIndicator;
+      this._wrapSelection = options.wrapSelection ?? this._defaultOptions.wrapSelection;
+      this._showDescription = options.showDescription ?? this._defaultOptions.showDescription;
+      this._font = options.font;
+      this._itemSpacing = options.itemSpacing || this._defaultOptions.itemSpacing;
+      this.fontHeight = this._font ? measureText({ text: "A", font: this._font }).height : 1;
+      this.linesPerItem = this._showDescription ? this._font ? this.fontHeight + 1 : 2 : this._font ? this.fontHeight : 1;
+      this.linesPerItem += this._itemSpacing;
+      this.maxVisibleItems = Math.max(1, Math.floor(this.height / this.linesPerItem));
+      this._selectedBackgroundColor = parseColor(options.selectedBackgroundColor || this._defaultOptions.selectedBackgroundColor);
+      this._selectedTextColor = parseColor(options.selectedTextColor || this._defaultOptions.selectedTextColor);
+      this._descriptionColor = parseColor(options.descriptionColor || this._defaultOptions.descriptionColor);
+      this._selectedDescriptionColor = parseColor(options.selectedDescriptionColor || this._defaultOptions.selectedDescriptionColor);
+      this._fastScrollStep = options.fastScrollStep || this._defaultOptions.fastScrollStep;
+      this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
+      this._keyBindings = options.keyBindings || [];
+      const mergedBindings = mergeKeyBindings(defaultSelectKeybindings, this._keyBindings);
+      this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
+      this.requestRender();
+    }
+    renderSelf(buffer, deltaTime) {
+      if (!this.visible || !this.frameBuffer)
+        return;
+      if (this.isDirty) {
+        this.refreshFrameBuffer();
+      }
+    }
+    refreshFrameBuffer() {
+      if (!this.frameBuffer || this._options.length === 0)
+        return;
+      const bgColor = this._focused ? this._focusedBackgroundColor : this._backgroundColor;
+      this.frameBuffer.clear(bgColor);
+      const contentX = 0;
+      const contentY = 0;
+      const contentWidth = this.width;
+      const contentHeight = this.height;
+      const visibleOptions = this._options.slice(this.scrollOffset, this.scrollOffset + this.maxVisibleItems);
+      for (let i = 0;i < visibleOptions.length; i++) {
+        const actualIndex = this.scrollOffset + i;
+        const option = visibleOptions[i];
+        const isSelected = actualIndex === this._selectedIndex;
+        const itemY = contentY + i * this.linesPerItem;
+        if (itemY + this.linesPerItem - 1 >= contentY + contentHeight)
+          break;
+        if (isSelected) {
+          const contentHeight2 = this.linesPerItem - this._itemSpacing;
+          this.frameBuffer.fillRect(contentX, itemY, contentWidth, contentHeight2, this._selectedBackgroundColor);
+        }
+        const nameContent = `${isSelected ? "▶ " : "  "}${option.name}`;
+        const baseTextColor = this._focused ? this._focusedTextColor : this._textColor;
+        const nameColor = isSelected ? this._selectedTextColor : baseTextColor;
+        let descX = contentX + 3;
+        if (this._font) {
+          const indicator = isSelected ? "▶ " : "  ";
+          this.frameBuffer.drawText(indicator, contentX + 1, itemY, nameColor);
+          const indicatorWidth = 2;
+          renderFontToFrameBuffer(this.frameBuffer, {
+            text: option.name,
+            x: contentX + 1 + indicatorWidth,
+            y: itemY,
+            color: nameColor,
+            backgroundColor: isSelected ? this._selectedBackgroundColor : bgColor,
+            font: this._font
+          });
+          descX = contentX + 1 + indicatorWidth;
+        } else {
+          this.frameBuffer.drawText(nameContent, contentX + 1, itemY, nameColor);
+        }
+        if (this._showDescription && itemY + this.fontHeight < contentY + contentHeight) {
+          const descColor = isSelected ? this._selectedDescriptionColor : this._descriptionColor;
+          this.frameBuffer.drawText(option.description, descX, itemY + this.fontHeight, descColor);
+        }
+      }
+      if (this._showScrollIndicator && this._options.length > this.maxVisibleItems) {
+        this.renderScrollIndicatorToFrameBuffer(contentX, contentY, contentWidth, contentHeight);
+      }
+    }
+    renderScrollIndicatorToFrameBuffer(contentX, contentY, contentWidth, contentHeight) {
+      if (!this.frameBuffer)
+        return;
+      const scrollPercent = this._selectedIndex / Math.max(1, this._options.length - 1);
+      const indicatorHeight = Math.max(1, contentHeight - 2);
+      const indicatorY = contentY + 1 + Math.floor(scrollPercent * indicatorHeight);
+      const indicatorX = contentX + contentWidth - 1;
+      this.frameBuffer.drawText("█", indicatorX, indicatorY, parseColor("#666666"));
+    }
+    get options() {
+      return this._options;
+    }
+    set options(options) {
+      this._options = options;
+      this._selectedIndex = Math.min(this._selectedIndex, Math.max(0, options.length - 1));
+      this.updateScrollOffset();
+      this.requestRender();
+    }
+    getSelectedOption() {
+      return this._options[this._selectedIndex] || null;
+    }
+    getSelectedIndex() {
+      return this._selectedIndex;
+    }
+    moveUp(steps = 1) {
+      const newIndex = this._selectedIndex - steps;
+      if (newIndex >= 0) {
+        this._selectedIndex = newIndex;
+      } else if (this._wrapSelection && this._options.length > 0) {
+        this._selectedIndex = this._options.length - 1;
+      } else {
+        this._selectedIndex = 0;
+      }
+      this.updateScrollOffset();
+      this.requestRender();
+      this.emit("selectionChanged", this._selectedIndex, this.getSelectedOption());
+    }
+    moveDown(steps = 1) {
+      const newIndex = this._selectedIndex + steps;
+      if (newIndex < this._options.length) {
+        this._selectedIndex = newIndex;
+      } else if (this._wrapSelection && this._options.length > 0) {
+        this._selectedIndex = 0;
+      } else {
+        this._selectedIndex = this._options.length - 1;
+      }
+      this.updateScrollOffset();
+      this.requestRender();
+      this.emit("selectionChanged", this._selectedIndex, this.getSelectedOption());
+    }
+    selectCurrent() {
+      const selected = this.getSelectedOption();
+      if (selected) {
+        this.emit("itemSelected", this._selectedIndex, selected);
+      }
+    }
+    setSelectedIndex(index) {
+      if (index >= 0 && index < this._options.length) {
+        this._selectedIndex = index;
+        this.updateScrollOffset();
+        this.requestRender();
+        this.emit("selectionChanged", this._selectedIndex, this.getSelectedOption());
+      }
+    }
+    updateScrollOffset() {
+      if (!this._options)
+        return;
+      const halfVisible = Math.floor(this.maxVisibleItems / 2);
+      const newScrollOffset = Math.max(0, Math.min(this._selectedIndex - halfVisible, this._options.length - this.maxVisibleItems));
+      if (newScrollOffset !== this.scrollOffset) {
+        this.scrollOffset = newScrollOffset;
+        this.requestRender();
+      }
     }
     onResize(width, height) {
       this.maxVisibleItems = Math.max(1, Math.floor(height / this.linesPerItem));
@@ -20339,11 +21593,21 @@ function getZenApiType2(modelId) {
   }
   return "openai-compatible";
 }
-function buildSystemPrompt2(cwd, history, shellInfo) {
+function buildSystemPrompt2(cwd, history, shellInfo, repoContextEnabled) {
   const historyContext = formatHistory2(history);
   const platformPaths = getPlatformPaths(shellInfo.platform);
   const shellHints = getShellSyntaxHints(shellInfo.shell);
   const platformName = shellInfo.platform === "macos" ? "macOS" : shellInfo.platform === "windows" ? "Windows" : shellInfo.platform === "linux" ? shellInfo.isWSL ? "Linux (WSL)" : "Linux" : "Unknown";
+  let projectContextSection = "";
+  if (repoContextEnabled) {
+    const repoContext = detectRepoContext(cwd);
+    if (repoContext) {
+      projectContextSection = `
+Project context:
+${formatRepoContext(repoContext)}
+`;
+    }
+  }
   return `You are a shell command translator. Convert the user's natural language request into a shell command.
 
 Current environment:
@@ -20352,7 +21616,7 @@ Current environment:
 - Working directory: ${cwd}
 - Home directory: ${shellInfo.homeDir}
 ${shellInfo.terminalEmulator ? `- Terminal: ${shellInfo.terminalEmulator}` : ""}
-
+${projectContextSection}
 ${shellHints}
 
 Recent command history:
@@ -20363,7 +21627,8 @@ Rules:
 - No explanations, no markdown, no backticks, no code blocks
 - Use the correct syntax for the detected shell (${shellInfo.shell})
 - If the request is unclear, make a reasonable assumption
-- Prefer simple, common commands over complex one-liners
+- Prefer simple, common commands over complex one-liners${repoContextEnabled ? `
+- Use project-specific commands when relevant (e.g., use the detected package manager and available scripts)` : ""}
 - Use the command history for context (e.g., "do that again", "undo", "delete the file I just created")
 - If the user asks something that can't be done with a shell command, output a command that prints a helpful message
 - For file operations, prefer safer alternatives when possible
@@ -20635,9 +21900,9 @@ function getShellInfo2() {
   }
   return cachedShellInfo2;
 }
-async function translateToCommand2(apiKey, model, userInput, cwd, history = []) {
+async function translateToCommand2(apiKey, model, userInput, cwd, history = [], repoContextEnabled) {
   const shellInfo = getShellInfo2();
-  const systemPrompt = buildSystemPrompt2(cwd, history, shellInfo);
+  const systemPrompt = buildSystemPrompt2(cwd, history, shellInfo, repoContextEnabled);
   let rawCommand;
   if (model.provider === "openrouter") {
     rawCommand = await callOpenRouter2(apiKey, model.id, systemPrompt, userInput);
@@ -20663,6 +21928,7 @@ async function translateToCommand2(apiKey, model, userInput, cwd, history = [])
 var DEBUG_API2, cachedShellInfo2 = null;
 var init_api = __esm(() => {
   init_shell();
+  init_repo_context();
   DEBUG_API2 = process.env.DEBUG_API === "1";
 });
 
@@ -20870,6 +22136,9 @@ __export(exports_cli, {
 });
 import { spawn } from "child_process";
 import { cwd as getCwd } from "process";
+function generateMessageId() {
+  return `msg-${++messageIdCounter}`;
+}
 async function main2() {
   config = loadConfig2();
   history = loadHistory2();
@@ -21047,44 +22316,65 @@ function createMainUI() {
     id: "header-row",
     flexDirection: "row",
     width: "100%",
+    alignItems: "center",
     marginBottom: 1
   });
   mainContainer.add(headerRow);
   headerText = new TextRenderable(renderer, {
     id: "header-text",
-    content: t`${bold(fg(theme.colors.primary)("magic-shell"))} ${fg(theme.colors.textMuted)("- natural language to terminal commands")}`,
+    content: t`${bold(fg(theme.colors.primary)("magic-shell"))}`,
     flexGrow: 1
   });
   headerRow.add(headerText);
-  const statusRow = new BoxRenderable(renderer, {
-    id: "status-row",
-    flexDirection: "row",
-    width: "100%",
-    marginBottom: 1
+  const modelBadge = new TextRenderable(renderer, {
+    id: "model-badge",
+    content: getModelDisplay()
   });
-  mainContainer.add(statusRow);
-  cwdText = new TextRenderable(renderer, {
-    id: "cwd-text",
-    content: t`${fg(theme.colors.textMuted)("cwd:")} ${fg(theme.colors.success)(currentCwd)}`,
-    flexGrow: 1
+  headerRow.add(modelBadge);
+  statusBarText = new TextRenderable(renderer, {
+    id: "status-bar-text",
+    content: getStatusBarContent(),
+    marginBottom: 1
   });
-  statusRow.add(cwdText);
-  modelText = new TextRenderable(renderer, {
-    id: "model-text",
-    content: getModelDisplay()
+  mainContainer.add(statusBarText);
+  chatScrollBox = new ScrollBoxRenderable(renderer, {
+    id: "chat-scroll-box",
+    flexGrow: 1,
+    width: "100%",
+    scrollY: true,
+    scrollX: false,
+    stickyScroll: true,
+    stickyStart: "bottom",
+    rootOptions: {
+      border: true,
+      borderColor: theme.colors.border,
+      borderStyle: "single"
+    },
+    viewportOptions: {
+      backgroundColor: theme.colors.background,
+      paddingLeft: 1,
+      paddingRight: 1,
+      paddingTop: 1
+    },
+    contentOptions: {
+      flexDirection: "column",
+      gap: 1
+    }
   });
-  statusRow.add(modelText);
+  mainContainer.add(chatScrollBox);
+  addSystemMessage(getWelcomeMessage());
   const inputRow = new BoxRenderable(renderer, {
     id: "input-row",
     flexDirection: "row",
     width: "100%",
-    marginBottom: 1
+    marginTop: 1,
+    alignItems: "center"
   });
   mainContainer.add(inputRow);
   const promptText = new TextRenderable(renderer, {
     id: "prompt-text",
-    content: t`${fg(theme.colors.success)(">")} `,
-    width: 2
+    content: t`${fg(theme.colors.primary)("~>")} `,
+    width: 3
   });
   inputRow.add(promptText);
   inputField = new InputRenderable(renderer, {
@@ -21102,58 +22392,269 @@ function createMainUI() {
     }
   });
   inputRow.add(inputField);
-  commandPreview = new TextRenderable(renderer, {
-    id: "command-preview",
-    content: "",
-    marginBottom: 1
-  });
-  mainContainer.add(commandPreview);
-  safetyWarning = new TextRenderable(renderer, {
-    id: "safety-warning",
-    content: ""
+  helpBarText = new TextRenderable(renderer, {
+    id: "help-bar-text",
+    content: getHelpBarContent(),
+    marginTop: 1
   });
-  mainContainer.add(safetyWarning);
-  confirmPrompt = new BoxRenderable(renderer, {
-    id: "confirm-prompt",
+  mainContainer.add(helpBarText);
+  inputField.on(InputRenderableEvents.ENTER, handleInput);
+  renderer.keyInput.on("keypress", handleKeypress);
+  inputField.focus();
+}
+function getStatusBarContent() {
+  const theme = getTheme2();
+  const providerName = config.provider === "opencode-zen" ? "OpenCode Zen" : "OpenRouter";
+  const safeModeIndicator = dryRunMode ? fg(theme.colors.warning)("[DRY RUN]") : fg(theme.colors.success)("Safe");
+  const repoContextIndicator = config.repoContext ? fg(theme.colors.info)("[Repo]") : "";
+  return t`${fg(theme.colors.textMuted)("Provider:")} ${fg(theme.colors.text)(providerName)}  ${fg(theme.colors.textMuted)("Model:")} ${fg(theme.colors.text)(currentModel.name)}  ${safeModeIndicator}${repoContextIndicator ? " " : ""}${repoContextIndicator}`;
+}
+function getHelpBarContent() {
+  const theme = getTheme2();
+  if (awaitingConfirmation) {
+    return t`${fg(theme.colors.warning)("[Enter] Run")} ${fg(theme.colors.textMuted)("|")} ${fg(theme.colors.error)("[Esc] Cancel")} ${fg(theme.colors.textMuted)("|")} ${fg(theme.colors.primary)("[e] Edit")}`;
+  }
+  return t`${fg(theme.colors.textMuted)("Ctrl+X")} ${fg(theme.colors.primary)("P")}${fg(theme.colors.textMuted)(" Palette")}  ${fg(theme.colors.primary)("M")}${fg(theme.colors.textMuted)(" Model")}  ${fg(theme.colors.primary)("T")}${fg(theme.colors.textMuted)(" Theme")}  ${fg(theme.colors.primary)("D")}${fg(theme.colors.textMuted)(" Dry-run")}  ${fg(theme.colors.primary)("?")}${fg(theme.colors.textMuted)(" Help")}`;
+}
+function getWelcomeMessage() {
+  const providerName = config.provider === "opencode-zen" ? "OpenCode Zen" : "OpenRouter";
+  const freeNote = config.provider === "opencode-zen" ? `
+Free models: grok-code, glm-4.7-free` : "";
+  return `Ready. Using ${providerName}.${freeNote}
+Type what you want to do, or press Ctrl+X P for command palette.`;
+}
+function addSystemMessage(content) {
+  const msg = {
+    id: generateMessageId(),
+    type: "system",
+    content,
+    timestamp: Date.now()
+  };
+  chatMessages.push(msg);
+  renderMessage(msg);
+  return msg;
+}
+function addUserMessage(content) {
+  const msg = {
+    id: generateMessageId(),
+    type: "user",
+    content,
+    timestamp: Date.now()
+  };
+  chatMessages.push(msg);
+  renderMessage(msg);
+  return msg;
+}
+function addAssistantMessage(content, command, safety) {
+  const msg = {
+    id: generateMessageId(),
+    type: "assistant",
+    content,
+    command,
+    safety,
+    timestamp: Date.now(),
+    executed: false
+  };
+  chatMessages.push(msg);
+  renderMessage(msg);
+  return msg;
+}
+function addResultMessage(content, exitCode) {
+  const msg = {
+    id: generateMessageId(),
+    type: "result",
+    content,
+    timestamp: Date.now(),
+    exitCode
+  };
+  chatMessages.push(msg);
+  renderMessage(msg);
+  return msg;
+}
+function renderMessage(msg) {
+  const theme = getTheme2();
+  const msgBox = createMessageRenderable(msg, theme);
+  chatScrollBox.add(msgBox);
+}
+function createMessageRenderable(msg, theme) {
+  switch (msg.type) {
+    case "user":
+      return createUserMessageRenderable(msg, theme);
+    case "assistant":
+      return createAssistantMessageRenderable(msg, theme);
+    case "result":
+      return createResultMessageRenderable(msg, theme);
+    case "system":
+    default:
+      return createSystemMessageRenderable(msg, theme);
+  }
+}
+function createUserMessageRenderable(msg, theme) {
+  const box = new BoxRenderable(renderer, {
+    id: `msg-${msg.id}`,
     flexDirection: "row",
-    visible: false,
-    marginBottom: 1
+    width: "100%"
   });
-  mainContainer.add(confirmPrompt);
-  const confirmText = new TextRenderable(renderer, {
-    id: "confirm-text",
-    content: t`${fg(theme.colors.warning)("[Enter] Execute")} ${fg(theme.colors.textMuted)("|")} ${fg(theme.colors.error)("[Esc] Cancel")} ${fg(theme.colors.textMuted)("|")} ${fg(theme.colors.primary)("[e] Edit")}`
+  const text = new TextRenderable(renderer, {
+    id: `msg-${msg.id}-text`,
+    content: t`${fg(theme.colors.success)(">")} ${fg(theme.colors.text)(msg.content)}`
   });
-  confirmPrompt.add(confirmText);
-  outputContainer = new BoxRenderable(renderer, {
-    id: "output-container",
-    flexGrow: 1,
+  box.add(text);
+  return box;
+}
+function createAssistantMessageRenderable(msg, theme) {
+  const isSelected = pendingMessageId === msg.id;
+  const card = new BoxRenderable(renderer, {
+    id: `msg-${msg.id}`,
+    flexDirection: "column",
+    width: "100%",
     border: true,
-    borderColor: theme.colors.border,
+    borderColor: isSelected ? theme.colors.primary : theme.colors.border,
     borderStyle: "single",
-    title: "Output",
-    padding: 1
+    paddingLeft: 1,
+    paddingRight: 1,
+    paddingTop: 0,
+    paddingBottom: 0,
+    backgroundColor: theme.colors.backgroundPanel
   });
-  mainContainer.add(outputContainer);
-  const providerName = config.provider === "opencode-zen" ? "OpenCode Zen" : "OpenRouter";
-  const freeModelsNote = config.provider === "opencode-zen" ? `
-${fg(theme.colors.success)("Free models available!")} Try: grok-code, glm-4.7-free` : "";
-  outputText = new TextRenderable(renderer, {
-    id: "output-text",
-    content: t`${fg(theme.colors.textMuted)(`Ready. Using ${providerName}.`)}${freeModelsNote}
-
-${fg(theme.colors.textMuted)("Type what you want to do, or press")} ${fg(theme.colors.primary)("Ctrl+X P")} ${fg(theme.colors.textMuted)("for command palette.")}`
+  const commandText = new TextRenderable(renderer, {
+    id: `msg-${msg.id}-cmd`,
+    content: t`${fg(theme.colors.textMuted)("Command:")} ${fg(theme.colors.text)(msg.command || "")}`
   });
-  outputContainer.add(outputText);
-  statusText = new TextRenderable(renderer, {
-    id: "status-text",
-    content: getDryRunStatus(),
-    marginTop: 1
+  card.add(commandText);
+  if (msg.safety) {
+    const severityColor = getSeverityColor(msg.safety.severity);
+    const severityText = msg.safety.isDangerous ? `${msg.safety.severity.toUpperCase()} risk${msg.safety.reason ? ` - ${msg.safety.reason}` : ""}` : "Low risk";
+    const safetyText = new TextRenderable(renderer, {
+      id: `msg-${msg.id}-safety`,
+      content: t`${fg(severityColor)("●")} ${fg(theme.colors.textMuted)(severityText)}`
+    });
+    card.add(safetyText);
+  }
+  if (isSelected && !msg.executed) {
+    const actionsText = new TextRenderable(renderer, {
+      id: `msg-${msg.id}-actions`,
+      content: t`${fg(theme.colors.warning)("[Enter]")} ${fg(theme.colors.textMuted)("Run")}  ${fg(theme.colors.primary)("[c]")} ${fg(theme.colors.textMuted)("Copy")}  ${fg(theme.colors.primary)("[e]")} ${fg(theme.colors.textMuted)("Edit")}`
+    });
+    card.add(actionsText);
+  }
+  if (msg.executed) {
+    const execText = new TextRenderable(renderer, {
+      id: `msg-${msg.id}-exec`,
+      content: t`${fg(theme.colors.success)("Executed")}`
+    });
+    card.add(execText);
+  }
+  return card;
+}
+function createResultMessageRenderable(msg, theme) {
+  const isSuccess = msg.exitCode === undefined || msg.exitCode === 0;
+  const isExpanded = msg.expanded ?? false;
+  const hasOutput = msg.content && msg.content.trim().length > 0;
+  const outputLines = hasOutput ? msg.content.trim().split(`
+`) : [];
+  const isLongOutput = outputLines.length > 5;
+  const PREVIEW_LINES = 3;
+  const card = new BoxRenderable(renderer, {
+    id: `msg-${msg.id}`,
+    flexDirection: "column",
+    width: "100%",
+    border: true,
+    borderColor: isSuccess ? theme.colors.success : theme.colors.error,
+    borderStyle: "single",
+    paddingLeft: 1,
+    paddingRight: 1,
+    backgroundColor: theme.colors.backgroundPanel,
+    onMouseDown: isLongOutput ? () => {
+      toggleResultExpand(msg.id);
+    } : undefined
   });
-  mainContainer.add(statusText);
-  inputField.on(InputRenderableEvents.ENTER, handleInput);
-  renderer.keyInput.on("keypress", handleKeypress);
-  inputField.focus();
+  const statusIcon = isSuccess ? "✓" : "✗";
+  const statusColor = isSuccess ? theme.colors.success : theme.colors.error;
+  const statusLabel = isSuccess ? "Executed successfully" : `Exit code: ${msg.exitCode}`;
+  const expandIcon = isLongOutput ? isExpanded ? "▼" : "▶" : "";
+  const lineCount = isLongOutput ? ` (${outputLines.length} lines)` : "";
+  const statusText = new TextRenderable(renderer, {
+    id: `msg-${msg.id}-status`,
+    content: t`${fg(statusColor)(statusIcon)} ${fg(theme.colors.text)(statusLabel)}${fg(theme.colors.textMuted)(lineCount)} ${fg(theme.colors.primary)(expandIcon)}`
+  });
+  card.add(statusText);
+  if (hasOutput) {
+    let displayContent;
+    if (isExpanded || !isLongOutput) {
+      displayContent = msg.content.trim();
+    } else {
+      const previewLines = outputLines.slice(0, PREVIEW_LINES);
+      displayContent = previewLines.join(`
+`) + `
+... ${outputLines.length - PREVIEW_LINES} more lines`;
+    }
+    const outputText = new TextRenderable(renderer, {
+      id: `msg-${msg.id}-output`,
+      content: t`${fg(theme.colors.textMuted)(displayContent)}`
+    });
+    card.add(outputText);
+    if (isLongOutput) {
+      const hintText = new TextRenderable(renderer, {
+        id: `msg-${msg.id}-hint`,
+        content: t`${fg(theme.colors.primary)("[o]")} ${fg(theme.colors.textMuted)(isExpanded ? "Collapse" : "Expand output")}`
+      });
+      card.add(hintText);
+    }
+  }
+  return card;
+}
+function createSystemMessageRenderable(msg, theme) {
+  const box = new BoxRenderable(renderer, {
+    id: `msg-${msg.id}`,
+    flexDirection: "column",
+    width: "100%"
+  });
+  const text = new TextRenderable(renderer, {
+    id: `msg-${msg.id}-text`,
+    content: t`${fg(theme.colors.textMuted)(msg.content)}`
+  });
+  box.add(text);
+  return box;
+}
+function updateAssistantMessage(msgId, updates) {
+  const msgIndex = chatMessages.findIndex((m) => m.id === msgId);
+  if (msgIndex === -1)
+    return;
+  const msg = chatMessages[msgIndex];
+  Object.assign(msg, updates);
+  chatScrollBox.remove(`msg-${msgId}`);
+  const theme = getTheme2();
+  const newBox = createMessageRenderable(msg, theme);
+  chatScrollBox.add(newBox);
+}
+function updateResultMessage(msgId, updates) {
+  const msgIndex = chatMessages.findIndex((m) => m.id === msgId);
+  if (msgIndex === -1)
+    return;
+  const msg = chatMessages[msgIndex];
+  Object.assign(msg, updates);
+  chatScrollBox.remove(`msg-${msgId}`);
+  const theme = getTheme2();
+  const newBox = createMessageRenderable(msg, theme);
+  chatScrollBox.add(newBox);
+}
+function toggleResultExpand(msgId) {
+  const msg = chatMessages.find((m) => m.id === msgId);
+  if (!msg || msg.type !== "result")
+    return;
+  const outputLines = msg.content?.trim().split(`
+`) || [];
+  if (outputLines.length <= 5)
+    return;
+  updateResultMessage(msgId, { expanded: !msg.expanded });
+}
+function toggleLastResultExpand() {
+  const resultMessages = chatMessages.filter((m) => m.type === "result");
+  if (resultMessages.length === 0)
+    return;
+  const lastResult = resultMessages[resultMessages.length - 1];
+  toggleResultExpand(lastResult.id);
 }
 function getModelDisplay() {
   const theme = getTheme2();
@@ -21162,30 +22663,22 @@ function getModelDisplay() {
   const freeBadge = currentModel.free ? fg(theme.colors.success)(" FREE") : "";
   return t`${providerBadge} ${fg(categoryColor)(currentModel.name)}${freeBadge}`;
 }
-function getDryRunStatus() {
-  const theme = getTheme2();
-  if (dryRunMode) {
-    return t`${fg(theme.colors.warning)("[DRY RUN]")} ${fg(theme.colors.textMuted)("Ctrl+X P palette | Ctrl+X M model | Ctrl+X D dry-run")}`;
-  }
-  return t`${fg(theme.colors.textMuted)("Ctrl+X P palette | Ctrl+X M model | Ctrl+X ? help")}`;
-}
 function refreshThemeColors() {
   const theme = getTheme2();
   renderer.setBackgroundColor(theme.colors.background);
   if (headerText) {
-    headerText.content = t`${bold(fg(theme.colors.primary)("magic-shell"))} ${fg(theme.colors.textMuted)("- natural language to terminal commands")}`;
+    headerText.content = t`${bold(fg(theme.colors.primary)("magic-shell"))}`;
   }
-  if (cwdText) {
-    cwdText.content = t`${fg(theme.colors.textMuted)("cwd:")} ${fg(theme.colors.success)(currentCwd)}`;
+  if (statusBarText) {
+    statusBarText.content = getStatusBarContent();
   }
-  if (modelText) {
-    modelText.content = getModelDisplay();
+  if (helpBarText) {
+    helpBarText.content = getHelpBarContent();
   }
-  if (statusText) {
-    statusText.content = getDryRunStatus();
-  }
-  if (outputContainer) {
-    outputContainer.borderColor = theme.colors.border;
+  if (chatScrollBox) {
+    chatScrollBox.rootOptions = {
+      borderColor: theme.colors.border
+    };
   }
   if (inputField) {
     inputField.focusedBackgroundColor = theme.colors.backgroundPanel;
@@ -21193,14 +22686,6 @@ function refreshThemeColors() {
     inputField.placeholderColor = theme.colors.textMuted;
     inputField.cursorColor = theme.colors.primary;
   }
-  const providerName = config.provider === "opencode-zen" ? "OpenCode Zen" : "OpenRouter";
-  const freeModelsNote = config.provider === "opencode-zen" ? `
-${fg(theme.colors.success)("Free models available!")} Try: grok-code, glm-4.7-free` : "";
-  if (outputText) {
-    outputText.content = t`${fg(theme.colors.textMuted)(`Ready. Using ${providerName}.`)}${freeModelsNote}
-
-${fg(theme.colors.textMuted)("Type what you want to do, or press")} ${fg(theme.colors.primary)("Ctrl+X P")} ${fg(theme.colors.textMuted)("for command palette.")}`;
-  }
 }
 async function handleInput(value) {
   const input = value.trim();
@@ -21211,8 +22696,9 @@ async function handleInput(value) {
     await handleSpecialCommand(input);
     return;
   }
+  addUserMessage(input);
   if (isDirectCommand(input)) {
-    await processCommand(input, input);
+    await processDirectCommand(input, input);
     return;
   }
   await translateAndProcess(input);
@@ -21246,38 +22732,50 @@ function isDirectCommand(input) {
 async function translateAndProcess(input) {
   const apiKey = await getApiKey2(config.provider);
   if (!apiKey) {
-    setOutput(t`${fg("#ef4444")("Error: No API key configured. Run !provider to set up.")}`);
+    addSystemMessage("Error: No API key configured. Run !provider to set up.");
     return;
   }
-  setOutput(t`${fg("#64748b")("Translating...")}`);
+  const loadingMsg = addSystemMessage("Translating...");
   try {
-    const command = await translateToCommand2(apiKey, currentModel, input, currentCwd, history);
-    commandPreview.content = t`${fg("#64748b")("Command:")} ${fg("#f8fafc")(command)}`;
+    const command = await translateToCommand2(apiKey, currentModel, input, currentCwd, history, config.repoContext);
+    chatScrollBox.remove(`msg-${loadingMsg.id}`);
+    chatMessages = chatMessages.filter((m) => m.id !== loadingMsg.id);
     const safety = analyzeCommand2(command, config);
+    const assistantMsg = addAssistantMessage(input, command, safety);
     if (safety.isDangerous) {
-      safetyWarning.content = t`${fg(getSeverityColor(safety.severity))(`[${safety.severity.toUpperCase()}] ${safety.reason}`)}`;
-      pendingCommand = command;
+      pendingMessageId = assistantMsg.id;
       awaitingConfirmation = true;
-      confirmPrompt.visible = true;
-      setOutput(t`${fg("#fbbf24")("Command requires confirmation. Press Enter to execute or Esc to cancel.")}`);
+      helpBarText.content = getHelpBarContent();
     } else {
-      safetyWarning.content = "";
-      await processCommand(input, command);
+      await executeAndShowResult(input, command, assistantMsg.id);
     }
   } catch (error) {
+    chatScrollBox.remove(`msg-${loadingMsg.id}`);
+    chatMessages = chatMessages.filter((m) => m.id !== loadingMsg.id);
     const message = error instanceof Error ? error.message : String(error);
-    setOutput(t`${fg("#ef4444")(`Error: ${message}`)}`);
+    addSystemMessage(`Error: ${message}`);
+  }
+}
+async function processDirectCommand(input, command) {
+  const safety = analyzeCommand2(command, config);
+  const assistantMsg = addAssistantMessage(input, command, safety);
+  if (safety.isDangerous) {
+    pendingMessageId = assistantMsg.id;
+    awaitingConfirmation = true;
+    helpBarText.content = getHelpBarContent();
+  } else {
+    await executeAndShowResult(input, command, assistantMsg.id);
   }
 }
-async function processCommand(input, command) {
+async function executeAndShowResult(input, command, assistantMsgId) {
   if (command.startsWith("cd ")) {
     const path2 = command.slice(3).trim().replace(/^["']|["']$/g, "");
     try {
       const expandedPath = path2.startsWith("~") ? path2.replace("~", process.env.HOME || "") : path2;
       process.chdir(expandedPath);
       currentCwd = getCwd();
-      cwdText.content = t`${fg("#64748b")("cwd:")} ${fg("#22c55e")(currentCwd)}`;
-      setOutput(t`${fg("#22c55e")(`Changed directory to ${currentCwd}`)}`);
+      statusBarText.content = getStatusBarContent();
+      addResultMessage(`Changed directory to ${currentCwd}`, 0);
       addToHistory({
         input,
         command,
@@ -21285,35 +22783,37 @@ async function processCommand(input, command) {
         timestamp: Date.now()
       });
       history = loadHistory2();
+      updateAssistantMessage(assistantMsgId, { executed: true });
     } catch (err) {
-      setOutput(t`${fg("#ef4444")(`cd: ${err instanceof Error ? err.message : String(err)}`)}`);
+      addResultMessage(`cd: ${err instanceof Error ? err.message : String(err)}`, 1);
     }
     clearCommandState();
     return;
   }
   if (dryRunMode) {
-    setOutput(t`${fg("#fbbf24")("[DRY RUN]")} Would execute: ${fg("#f8fafc")(command)}`);
+    addResultMessage(`[DRY RUN] Would execute: ${command}`, 0);
+    updateAssistantMessage(assistantMsgId, { executed: true });
     clearCommandState();
     return;
   }
-  setOutput(t`${fg("#64748b")("Executing...")}`);
   try {
-    const result = await executeCommand(command);
-    setOutput(result || t`${fg("#22c55e")("Command completed successfully")}`);
+    const { output, exitCode } = await executeCommandWithCode(command);
+    addResultMessage(output || "Command completed successfully", exitCode);
     addToHistory({
       input,
       command,
-      output: result.slice(0, 500),
+      output: output.slice(0, 500),
       timestamp: Date.now()
     });
     history = loadHistory2();
+    updateAssistantMessage(assistantMsgId, { executed: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    setOutput(t`${fg("#ef4444")(`Error: ${message}`)}`);
+    addResultMessage(`Error: ${message}`, 1);
   }
   clearCommandState();
 }
-function executeCommand(command) {
+function executeCommandWithCode(command) {
   return new Promise((resolve3, reject) => {
     const child = spawn(command, {
       shell: true,
@@ -21332,23 +22832,16 @@ function executeCommand(command) {
       reject(error);
     });
     child.on("close", (code) => {
-      if (code === 0) {
-        resolve3(stdout || stderr);
-      } else {
-        resolve3(stderr || stdout || `Command exited with code ${code}`);
-      }
+      const exitCode = code ?? 0;
+      const output = stdout || stderr || (exitCode === 0 ? "" : `Command exited with code ${exitCode}`);
+      resolve3({ output, exitCode });
     });
   });
 }
 function clearCommandState() {
-  pendingCommand = null;
+  pendingMessageId = null;
   awaitingConfirmation = false;
-  confirmPrompt.visible = false;
-  commandPreview.content = "";
-  safetyWarning.content = "";
-}
-function setOutput(content) {
-  outputText.content = content;
+  helpBarText.content = getHelpBarContent();
 }
 async function handleSpecialCommand(input) {
   const cmd = input.slice(1).toLowerCase().trim();
@@ -21364,8 +22857,8 @@ async function handleSpecialCommand(input) {
       break;
     case "dry":
       dryRunMode = !dryRunMode;
-      statusText.content = getDryRunStatus();
-      setOutput(t`${fg("#22c55e")(`Dry-run mode: ${dryRunMode ? "ON" : "OFF"}`)}`);
+      statusBarText.content = getStatusBarContent();
+      addSystemMessage(`Dry-run mode: ${dryRunMode ? "ON" : "OFF"}`);
       break;
     case "config":
       await showConfig();
@@ -21374,65 +22867,74 @@ async function handleSpecialCommand(input) {
       showHistory();
       break;
     case "clear":
-      setOutput("");
+      clearChat();
       break;
     default:
       if (cmd) {
-        await processCommand(input, cmd);
+        addUserMessage(cmd);
+        await processDirectCommand(input, cmd);
       }
   }
 }
+function clearChat() {
+  for (const msg of chatMessages) {
+    chatScrollBox.remove(`msg-${msg.id}`);
+  }
+  chatMessages = [];
+  addSystemMessage(getWelcomeMessage());
+}
 function showHelp() {
-  const theme = getTheme2();
-  setOutput(t`${bold(fg(theme.colors.primary)("Magic Shell"))}
-
-${bold(fg(theme.colors.textMuted)("Keyboard Shortcuts (Ctrl+X then...):"))}
-${fg(theme.colors.primary)("P")}  ${fg(theme.colors.textMuted)("Command palette")}    ${fg(theme.colors.primary)("M")}  ${fg(theme.colors.textMuted)("Change model")}
-${fg(theme.colors.primary)("S")}  ${fg(theme.colors.textMuted)("Switch provider")}    ${fg(theme.colors.primary)("D")}  ${fg(theme.colors.textMuted)("Toggle dry-run")}
-${fg(theme.colors.primary)("T")}  ${fg(theme.colors.textMuted)("Change theme")}       ${fg(theme.colors.primary)("H")}  ${fg(theme.colors.textMuted)("Show history")}
-${fg(theme.colors.primary)("C")}  ${fg(theme.colors.textMuted)("Show config")}        ${fg(theme.colors.primary)("L")}  ${fg(theme.colors.textMuted)("Clear output")}
-${fg(theme.colors.primary)("?")}  ${fg(theme.colors.textMuted)("This help")}          ${fg(theme.colors.primary)("Q")}  ${fg(theme.colors.textMuted)("Exit")}
+  const helpText = `Keyboard Shortcuts (Ctrl+X then...):
+P  Command palette    M  Change model
+S  Switch provider    D  Toggle dry-run
+T  Change theme       R  Toggle repo context
+H  Show history       L  Clear chat
+C  Show config        ?  This help
+Q  Exit
 
-${bold(fg(theme.colors.textMuted)("Other:"))}
-${fg(theme.colors.primary)("Ctrl+C")}  ${fg(theme.colors.textMuted)("Exit / Cancel")}     ${fg(theme.colors.primary)("Esc")}  ${fg(theme.colors.textMuted)("Close palette")}
+Other:
+Ctrl+C  Exit / Cancel     Esc  Close palette
 
-${bold(fg(theme.colors.textMuted)("Tips:"))}
+Tips:
 - Type naturally: "list all files" -> ls -la
 - Reference history: "do that again", "undo"
-- ${fg(theme.colors.success)("Free models:")} gpt-5-nano, grok-code, glm-4.7-free`);
+- Enable repo context to use project scripts (Ctrl+X R)`;
+  addSystemMessage(helpText);
 }
 async function showConfig() {
   const theme = getTheme2();
   const providerName = config.provider === "opencode-zen" ? "OpenCode Zen" : "OpenRouter";
   const apiKey = await getApiKey2(config.provider);
-  const apiKeyStatus = apiKey ? fg(theme.colors.success)("configured") : fg(theme.colors.error)("not set");
-  const freeBadge = currentModel.free ? fg(theme.colors.success)(" (FREE)") : "";
+  const apiKeyStatus = apiKey ? "configured" : "not set";
+  const freeBadge = currentModel.free ? " (FREE)" : "";
   const shellInfo = getShellInfo2();
-  setOutput(t`${bold(fg(theme.colors.primary)("Current Configuration"))}
+  const configText = `Current Configuration
 
-${fg(theme.colors.textMuted)("Provider:")}     ${fg(theme.colors.text)(providerName)}
-${fg(theme.colors.textMuted)("Model:")}        ${fg(theme.colors.text)(currentModel.name)}${freeBadge}
-${fg(theme.colors.textMuted)("Model ID:")}     ${fg(theme.colors.textMuted)(currentModel.id)}
-${fg(theme.colors.textMuted)("Category:")}     ${fg(theme.colors.text)(currentModel.category)}
-${fg(theme.colors.textMuted)("Theme:")}        ${fg(theme.colors.text)(theme.name)}
-${fg(theme.colors.textMuted)("Shell:")}        ${fg(theme.colors.text)(shellInfo.shell)} ${fg(theme.colors.textMuted)(`(${shellInfo.shellPath})`)}
-${fg(theme.colors.textMuted)("Platform:")}     ${fg(theme.colors.text)(shellInfo.platform)}${shellInfo.isWSL ? fg(theme.colors.textMuted)(" (WSL)") : ""}
-${fg(theme.colors.textMuted)("Safety:")}       ${fg(theme.colors.text)(config.safetyLevel)}
-${fg(theme.colors.textMuted)("Dry-run:")}      ${fg(theme.colors.text)(dryRunMode ? "ON" : "OFF")}
-${fg(theme.colors.textMuted)("API Key:")}      ${apiKeyStatus}
-${fg(theme.colors.textMuted)("History:")}      ${fg(theme.colors.text)(`${history.length} commands`)}`);
+Provider:     ${providerName}
+Model:        ${currentModel.name}${freeBadge}
+Model ID:     ${currentModel.id}
+Category:     ${currentModel.category}
+Theme:        ${theme.name}
+Shell:        ${shellInfo.shell} (${shellInfo.shellPath})
+Platform:     ${shellInfo.platform}${shellInfo.isWSL ? " (WSL)" : ""}
+Safety:       ${config.safetyLevel}
+Dry-run:      ${dryRunMode ? "ON" : "OFF"}
+Repo context: ${config.repoContext ? "ON" : "OFF"}
+API Key:      ${apiKeyStatus}
+History:      ${history.length} commands`;
+  addSystemMessage(configText);
 }
 function showHistory() {
   if (history.length === 0) {
-    setOutput(t`${fg("#64748b")("No command history yet.")}`);
+    addSystemMessage("No command history yet.");
     return;
   }
   const recent = history.slice(-10);
   const lines = recent.map((entry, i) => {
     const date = new Date(entry.timestamp).toLocaleTimeString();
-    return t`${fg("#64748b")(`${i + 1}.`)} ${fg("#94a3b8")(`[${date}]`)} ${fg("#f8fafc")(entry.command)}`;
+    return `${i + 1}. [${date}] ${entry.command}`;
   });
-  setOutput(t`${bold(fg("#60a5fa")("Recent Command History"))}
+  addSystemMessage(`Recent Command History
 
 ${lines.join(`
 `)}`);
@@ -21498,10 +23000,10 @@ async function switchProvider() {
       currentModel = models.find((m) => m.id === config.defaultModel) || models[0];
       config.defaultModel = currentModel.id;
       saveConfig2(config);
-      modelText.content = getModelDisplay();
+      statusBarText.content = getStatusBarContent();
       closeSelector();
       const providerName = newProvider === "opencode-zen" ? "OpenCode Zen" : "OpenRouter";
-      setOutput(t`${fg("#22c55e")(`Switched to ${providerName}. Model: ${currentModel.name}`)}`);
+      addSystemMessage(`Switched to ${providerName}. Model: ${currentModel.name}`);
     } else {
       closeSelector();
       renderer.root.remove("main-container");
@@ -21567,12 +23069,12 @@ function showModelSelector() {
     currentModel = option.value;
     config.defaultModel = currentModel.id;
     saveConfig2(config);
-    modelText.content = getModelDisplay();
+    statusBarText.content = getStatusBarContent();
     renderer.root.remove("model-selector-container");
     modelSelector = null;
     inputField.focus();
     const freeBadge = currentModel.free ? " (FREE)" : "";
-    setOutput(t`${fg("#22c55e")(`Model changed to ${currentModel.name}${freeBadge}`)}`);
+    addSystemMessage(`Model changed to ${currentModel.name}${freeBadge}`);
   });
   modelSelector.focus();
 }
@@ -21629,8 +23131,7 @@ function showThemeSelector() {
     renderer.root.remove("theme-selector-container");
     themeSelector = null;
     refreshThemeColors();
-    const newTheme = getTheme2();
-    setOutput(t`${fg(newTheme.colors.success)(`Theme changed to ${themeName}`)}`);
+    addSystemMessage(`Theme changed to ${themeName}`);
     inputField.focus();
   });
   const escHandler = (key) => {
@@ -21674,8 +23175,20 @@ function getCommandPaletteOptions() {
       chord: "d",
       action: () => {
         dryRunMode = !dryRunMode;
-        statusText.content = getDryRunStatus();
-        setOutput(t`${fg("#22c55e")(`Dry-run mode: ${dryRunMode ? "ON" : "OFF"}`)}`);
+        statusBarText.content = getStatusBarContent();
+        addSystemMessage(`Dry-run mode: ${dryRunMode ? "ON" : "OFF"}`);
+      }
+    },
+    {
+      name: "Toggle Project Context",
+      description: config.repoContext ? "Currently ON (sends script names to AI)" : "Currently OFF",
+      key: "r",
+      chord: "r",
+      action: () => {
+        config.repoContext = !config.repoContext;
+        saveConfig2(config);
+        statusBarText.content = getStatusBarContent();
+        addSystemMessage(`Project context: ${config.repoContext ? "ON - AI can see your package.json scripts, Makefile targets, etc." : "OFF"}`);
       }
     },
     {
@@ -21700,11 +23213,11 @@ function getCommandPaletteOptions() {
       action: () => showThemeSelector()
     },
     {
-      name: "Clear Output",
-      description: "Clear the output area",
+      name: "Clear Chat",
+      description: "Clear the chat history",
       key: "l",
       chord: "l",
-      action: () => setOutput("")
+      action: () => clearChat()
     },
     {
       name: "Show Help",
@@ -21845,24 +23358,44 @@ function handleKeypress(key) {
       inputField.focus();
       return;
     }
-    if (awaitingConfirmation) {
+    if (awaitingConfirmation && pendingMessageId) {
       clearCommandState();
-      setOutput(t`${fg("#64748b")("Command cancelled.")}`);
+      addSystemMessage("Command cancelled.");
       inputField.focus();
     }
   }
-  if (key.name === "return" && awaitingConfirmation && pendingCommand) {
-    const cmd = pendingCommand;
-    clearCommandState();
-    processCommand("", cmd);
+  if (key.name === "return" && awaitingConfirmation && pendingMessageId) {
+    const msg = chatMessages.find((m) => m.id === pendingMessageId);
+    if (msg && msg.command) {
+      const command = msg.command;
+      const msgId = pendingMessageId;
+      clearCommandState();
+      executeAndShowResult(msg.content, command, msgId);
+    }
   }
-  if (key.name === "e" && awaitingConfirmation && pendingCommand) {
-    inputField.value = pendingCommand;
-    clearCommandState();
-    inputField.focus();
+  if (key.name === "e" && awaitingConfirmation && pendingMessageId) {
+    const msg = chatMessages.find((m) => m.id === pendingMessageId);
+    if (msg && msg.command) {
+      inputField.value = msg.command;
+      clearCommandState();
+      inputField.focus();
+    }
+  }
+  if (key.name === "c" && awaitingConfirmation && pendingMessageId) {
+    const msg = chatMessages.find((m) => m.id === pendingMessageId);
+    if (msg && msg.command) {
+      const copyCmd = process.platform === "darwin" ? "pbcopy" : "xclip -selection clipboard";
+      const child = spawn(copyCmd, { shell: true });
+      child.stdin?.write(msg.command);
+      child.stdin?.end();
+      addSystemMessage(`Copied to clipboard: ${msg.command}`);
+    }
+  }
+  if (key.name === "o" && !awaitingConfirmation && !commandPalette && !modelSelector) {
+    toggleLastResultExpand();
   }
 }
-var renderer, currentModel, config, history, currentCwd, dryRunMode = false, mainContainer, headerText, cwdText, modelText, inputField, outputContainer, outputText, statusText, commandPreview, safetyWarning, confirmPrompt, modelSelector = null, providerSelector = null, pendingCommand = null, awaitingConfirmation = false, themeSelector = null, commandPalette = null, chordMode = "none", cli_default;
+var renderer, currentModel, config, history, currentCwd, dryRunMode = false, chatMessages, messageIdCounter = 0, mainContainer, headerText, statusBarText, chatScrollBox, inputField, helpBarText, modelSelector = null, providerSelector = null, pendingMessageId = null, awaitingConfirmation = false, themeSelector = null, commandPalette = null, chordMode = "none", cli_default;
 var init_cli = __esm(async () => {
   init_types();
   init_config();
@@ -21873,6 +23406,7 @@ var init_cli = __esm(async () => {
   currentModel = OPENCODE_ZEN_MODELS2[0];
   history = [];
   currentCwd = getCwd();
+  chatMessages = [];
   if (false) {}
   cli_default = main2;
 });
@@ -22182,7 +23716,7 @@ var DEFAULT_CONFIG = {
   provider: "opencode-zen",
   openrouterApiKey: "",
   opencodeZenApiKey: "",
-  defaultModel: "gpt-5-nano",
+  defaultModel: "gemini-3-flash",
   safetyLevel: "moderate",
   dryRunByDefault: false,
   blockedCommands: [
@@ -22193,7 +23727,8 @@ var DEFAULT_CONFIG = {
     "chmod -R 777 /",
     "chown -R"
   ],
-  confirmedDangerousPatterns: []
+  confirmedDangerousPatterns: [],
+  repoContext: false
 };
 function ensureConfigDir() {
   if (!existsSync(CONFIG_DIR)) {
@@ -22394,6 +23929,7 @@ function getSeverityMessage(severity) {
 
 // src/lib/api.ts
 init_shell();
+init_repo_context();
 function getZenApiType(modelId) {
   if (modelId.startsWith("gpt-")) {
     return "openai-responses";
@@ -22406,11 +23942,21 @@ function getZenApiType(modelId) {
   }
   return "openai-compatible";
 }
-function buildSystemPrompt(cwd, history, shellInfo) {
+function buildSystemPrompt(cwd, history, shellInfo, repoContextEnabled) {
   const historyContext = formatHistory(history);
   const platformPaths = getPlatformPaths(shellInfo.platform);
   const shellHints = getShellSyntaxHints(shellInfo.shell);
   const platformName = shellInfo.platform === "macos" ? "macOS" : shellInfo.platform === "windows" ? "Windows" : shellInfo.platform === "linux" ? shellInfo.isWSL ? "Linux (WSL)" : "Linux" : "Unknown";
+  let projectContextSection = "";
+  if (repoContextEnabled) {
+    const repoContext = detectRepoContext(cwd);
+    if (repoContext) {
+      projectContextSection = `
+Project context:
+${formatRepoContext(repoContext)}
+`;
+    }
+  }
   return `You are a shell command translator. Convert the user's natural language request into a shell command.
 
 Current environment:
@@ -22419,7 +23965,7 @@ Current environment:
 - Working directory: ${cwd}
 - Home directory: ${shellInfo.homeDir}
 ${shellInfo.terminalEmulator ? `- Terminal: ${shellInfo.terminalEmulator}` : ""}
-
+${projectContextSection}
 ${shellHints}
 
 Recent command history:
@@ -22430,7 +23976,8 @@ Rules:
 - No explanations, no markdown, no backticks, no code blocks
 - Use the correct syntax for the detected shell (${shellInfo.shell})
 - If the request is unclear, make a reasonable assumption
-- Prefer simple, common commands over complex one-liners
+- Prefer simple, common commands over complex one-liners${repoContextEnabled ? `
+- Use project-specific commands when relevant (e.g., use the detected package manager and available scripts)` : ""}
 - Use the command history for context (e.g., "do that again", "undo", "delete the file I just created")
 - If the user asks something that can't be done with a shell command, output a command that prints a helpful message
 - For file operations, prefer safer alternatives when possible
@@ -22704,9 +24251,9 @@ function getShellInfo() {
   }
   return cachedShellInfo;
 }
-async function translateToCommand(apiKey, model, userInput, cwd, history = []) {
+async function translateToCommand(apiKey, model, userInput, cwd, history = [], repoContextEnabled) {
   const shellInfo = getShellInfo();
-  const systemPrompt = buildSystemPrompt(cwd, history, shellInfo);
+  const systemPrompt = buildSystemPrompt(cwd, history, shellInfo, repoContextEnabled);
   let rawCommand;
   if (model.provider === "openrouter") {
     rawCommand = await callOpenRouter(apiKey, model.id, systemPrompt, userInput);
@@ -22947,6 +24494,128 @@ function getAnsiColors() {
 }
 loadTheme();
 
+// src/lib/update-checker.ts
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+var __dirname = "/Users/austin/code/dxd/magic-shell/src/lib";
+var PACKAGE_NAME = "@austinthesing/magic-shell";
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+var CONFIG_DIR3 = join4(homedir4(), ".magic-shell");
+var UPDATE_CHECK_FILE = join4(CONFIG_DIR3, ".update-check");
+function ensureConfigDir3() {
+  if (!existsSync5(CONFIG_DIR3)) {
+    mkdirSync3(CONFIG_DIR3, { recursive: true });
+  }
+}
+function loadUpdateState() {
+  ensureConfigDir3();
+  try {
+    if (existsSync5(UPDATE_CHECK_FILE)) {
+      return JSON.parse(readFileSync4(UPDATE_CHECK_FILE, "utf-8"));
+    }
+  } catch {}
+  return { lastCheck: 0, latestVersion: null, dismissed: null };
+}
+function saveUpdateState(state) {
+  ensureConfigDir3();
+  try {
+    writeFileSync3(UPDATE_CHECK_FILE, JSON.stringify(state));
+  } catch {}
+}
+function getCurrentVersion() {
+  try {
+    const packagePaths = [
+      join4(__dirname, "../../package.json"),
+      join4(__dirname, "../../../package.json"),
+      join4(process.cwd(), "package.json")
+    ];
+    for (const path of packagePaths) {
+      if (existsSync5(path)) {
+        const pkg = JSON.parse(readFileSync4(path, "utf-8"));
+        if (pkg.name === PACKAGE_NAME || pkg.name === "magic-shell") {
+          return pkg.version;
+        }
+      }
+    }
+  } catch {}
+  return "0.0.0";
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0;i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA > numB)
+      return 1;
+    if (numA < numB)
+      return -1;
+  }
+  return 0;
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.version || null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdates() {
+  const state = loadUpdateState();
+  const currentVersion = getCurrentVersion();
+  const now = Date.now();
+  if (now - state.lastCheck < CHECK_INTERVAL_MS) {
+    if (state.latestVersion && compareVersions(state.latestVersion, currentVersion) > 0) {
+      if (state.dismissed === state.latestVersion) {
+        return null;
+      }
+      return {
+        hasUpdate: true,
+        currentVersion,
+        latestVersion: state.latestVersion,
+        updateCommand: `bun update -g ${PACKAGE_NAME}`
+      };
+    }
+    return null;
+  }
+  const latestVersion = await fetchLatestVersion();
+  state.lastCheck = now;
+  if (latestVersion) {
+    state.latestVersion = latestVersion;
+  }
+  saveUpdateState(state);
+  if (latestVersion && compareVersions(latestVersion, currentVersion) > 0) {
+    if (state.dismissed === latestVersion) {
+      return null;
+    }
+    return {
+      hasUpdate: true,
+      currentVersion,
+      latestVersion,
+      updateCommand: `bun update -g ${PACKAGE_NAME}`
+    };
+  }
+  return null;
+}
+async function forceCheckForUpdates() {
+  const state = loadUpdateState();
+  state.lastCheck = 0;
+  saveUpdateState(state);
+  return checkForUpdates();
+}
+
 // src/index.ts
 loadTheme();
 var getColors = () => {
@@ -22978,6 +24647,10 @@ ${colors.bold}USAGE${colors.reset}
   msh --provider <name>    Set provider (opencode-zen or openrouter)
   msh --themes             List available themes
   msh --theme <name>       Set color theme
+  msh --repo-context       Enable project context detection
+  msh --no-repo-context    Disable project context detection
+  msh --version            Show version
+  msh --check-update       Check for updates
   msh --help               Show this help
 
 ${colors.bold}EXAMPLES${colors.reset}
@@ -22990,6 +24663,9 @@ ${colors.bold}EXAMPLES${colors.reset}
   ${colors.dim}# Check what would run${colors.reset}
   msh -n "delete all log files"
   
+  ${colors.dim}# Use project context (knows your npm scripts, etc)${colors.reset}
+  msh --repo-context "run the dev server"
+  
   ${colors.dim}# Pipe to clipboard (macOS)${colors.reset}
   msh "find large files" | pbcopy
 
@@ -23165,7 +24841,7 @@ Try: ${colors.cyan}msh "list all files"${colors.reset}
 `);
   rl.close();
 }
-function executeCommand2(command) {
+function executeCommand(command) {
   return new Promise((resolve3) => {
     const child = spawn2(command, {
       shell: true,
@@ -23193,6 +24869,27 @@ function executeCommand2(command) {
     });
   });
 }
+function createSpinner(message) {
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0;
+  const isTTY = process.stderr.isTTY;
+  const interval = isTTY ? setInterval(() => {
+    process.stderr.write(`\r${colors.primary}${frames[i]}${colors.reset} ${colors.dim}${message}${colors.reset}`);
+    i = (i + 1) % frames.length;
+  }, 80) : null;
+  if (!isTTY) {
+    process.stderr.write(`${colors.dim}${message}...${colors.reset}
+`);
+  }
+  return {
+    stop: () => {
+      if (interval) {
+        clearInterval(interval);
+        process.stderr.write("\r\x1B[K");
+      }
+    }
+  };
+}
 async function translate(query, options) {
   const config2 = loadConfig();
   const apiKey = await getApiKey(config2.provider);
@@ -23204,12 +24901,18 @@ async function translate(query, options) {
   const model = ALL_MODELS.find((m) => m.id === config2.defaultModel) || (config2.provider === "opencode-zen" ? OPENCODE_ZEN_MODELS[0] : OPENROUTER_MODELS[0]);
   const history2 = loadHistory();
   const cwd = getCwd2();
+  const useRepoContext = options.repoContext ?? config2.repoContext ?? false;
+  const spinner = createSpinner(`Translating with ${model.name}`);
   try {
-    const command = await translateToCommand(apiKey, model, query, cwd, history2);
+    const command = await translateToCommand(apiKey, model, query, cwd, history2, useRepoContext);
+    spinner.stop();
     if (options.dryRun) {
       const safety = analyzeCommand(command, config2);
       console.log(`${colors.dim}Query:${colors.reset} ${query}`);
       console.log(`${colors.dim}Model:${colors.reset} ${model.name}`);
+      if (useRepoContext) {
+        console.log(`${colors.dim}Project context:${colors.reset} enabled`);
+      }
       console.log();
       console.log(`${colors.bold}Command:${colors.reset} ${command}`);
       if (safety.isDangerous) {
@@ -23228,33 +24931,64 @@ async function translate(query, options) {
         console.error(`${colors.yellow}Use -n to preview, or run the command manually.${colors.reset}`);
         process.exit(1);
       }
-      const result = await executeCommand2(command);
+      const result = await executeCommand(command);
       process.exit(result.code);
     } else {
       console.log(command);
     }
   } catch (error) {
+    spinner.stop();
     const message = error instanceof Error ? error.message : String(error);
     console.error(`${colors.red}Error: ${message}${colors.reset}`);
     process.exit(1);
   }
 }
+async function showUpdateNotification() {
+  try {
+    const update = await checkForUpdates();
+    if (update?.hasUpdate) {
+      console.error(`${colors.cyan}\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510${colors.reset}`);
+      console.error(`${colors.cyan}\u2502${colors.reset}  ${colors.bold}Update available!${colors.reset} ${colors.dim}${update.currentVersion}${colors.reset} \u2192 ${colors.green}${update.latestVersion}${colors.reset}          ${colors.cyan}\u2502${colors.reset}`);
+      console.error(`${colors.cyan}\u2502${colors.reset}  Run: ${colors.yellow}${update.updateCommand}${colors.reset}   ${colors.cyan}\u2502${colors.reset}`);
+      console.error(`${colors.cyan}\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518${colors.reset}`);
+      console.error();
+    }
+  } catch {}
+}
 async function main3() {
   const args = process.argv.slice(2);
+  const updatePromise = args.length > 0 && !args[0].startsWith("-i") ? showUpdateNotification() : Promise.resolve();
   if (args.length === 0 || args[0] === "-i" || args[0] === "--interactive") {
     const { default: runTui } = await init_cli().then(() => exports_cli);
     await runTui();
     return;
   }
   if (args[0] === "--help" || args[0] === "-h") {
+    await updatePromise;
     printHelp();
     return;
   }
+  if (args[0] === "--version" || args[0] === "-v") {
+    console.log(`magic-shell v${getCurrentVersion()}`);
+    return;
+  }
+  if (args[0] === "--check-update") {
+    const update = await forceCheckForUpdates();
+    if (update?.hasUpdate) {
+      console.log(`${colors.green}Update available!${colors.reset} ${update.currentVersion} \u2192 ${update.latestVersion}`);
+      console.log(`Run: ${colors.cyan}${update.updateCommand}${colors.reset}`);
+    } else {
+      console.log(`${colors.green}\u2713 You're running the latest version (${getCurrentVersion()})${colors.reset}`);
+    }
+    return;
+  }
   if (args[0] === "--setup") {
+    await updatePromise;
     await setup();
     return;
   }
   if (args[0] === "--models") {
+    await updatePromise;
     printModels();
     return;
   }
@@ -23320,8 +25054,24 @@ ${colors.bold}Available Themes${colors.reset}
     console.log(`${colors.success}\u2713 Theme set to ${themeName}${colors.reset}`);
     return;
   }
+  if (args[0] === "--repo-context") {
+    const config2 = loadConfig();
+    config2.repoContext = true;
+    saveConfig(config2);
+    console.log(`${colors.success}\u2713 Project context enabled${colors.reset}`);
+    console.log(`${colors.dim}Magic Shell will now detect package.json scripts, Makefile targets, etc.${colors.reset}`);
+    return;
+  }
+  if (args[0] === "--no-repo-context") {
+    const config2 = loadConfig();
+    config2.repoContext = false;
+    saveConfig(config2);
+    console.log(`${colors.success}\u2713 Project context disabled${colors.reset}`);
+    return;
+  }
   let execute = false;
   let dryRun = false;
+  let repoContext = undefined;
   let queryParts = [];
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
@@ -23329,6 +25079,10 @@ ${colors.bold}Available Themes${colors.reset}
       execute = true;
     } else if (arg === "-n" || arg === "--dry-run") {
       dryRun = true;
+    } else if (arg === "-r" || arg === "--repo-context") {
+      repoContext = true;
+    } else if (arg === "--no-repo-context") {
+      repoContext = false;
     } else if (!arg.startsWith("-")) {
       queryParts.push(arg);
     }
@@ -23339,7 +25093,7 @@ ${colors.bold}Available Themes${colors.reset}
     console.error(`Usage: msh "your query here"`);
     process.exit(1);
   }
-  await translate(query, { execute, dryRun });
+  await translate(query, { execute, dryRun, repoContext });
 }
 main3().catch((error) => {
   console.error(`${colors.red}Error: ${error.message}${colors.reset}`);