gloomberb 0.2.0 → 0.3.1

package/README.md

@@ -14,21 +14,28 @@
 
 - **Track portfolios & trade**
 - **Real-time quotes & fundamentals**
-- **Beautiful terminal charts**
-- **Keyboard-driven**
+- **Beautiful high-rez charts**
+- **Fast & keyboard-driven**
+- **Powerful layouts**
 - **Extensible**
 - **100% local**
 
+For the best experience, use a [Kitty](https://sw.kovidgoyal.net/kitty/)-compatible terminal such as Ghostty, Kitty or WezTerm.
+
 ## 🚀 Install
 
 ```bash
 bun install -g gloomberb
 # or
-npm install -g gloomberb
+curl -fsSL gloomberb.com/install | bash
 ```
 
 Then run `gloomberb` to start.
 
+When developing from source, launch with a real Bun runtime, for example `bun src/index.tsx`.
+If `bun --help` prints Gloomberb help instead of Bun help, your Bun binary has been overwritten and needs to be reinstalled.
+In-app self-updates are disabled while running from source so Gloomberb does not replace the Bun executable.
+
 ## 🧩 Plugins
 
 Gloomberb has a plugin architecture where everything, from the portfolio list to broker integrations, is a plugin. 
@@ -47,12 +54,18 @@ See **[PLUGINS.md](PLUGINS.md)** for the plugin API and the shared UI surface av
 | **SEC** | View recent SEC filings for supported US equities |
 | **Notes** | Write and save markdown notes, stored locally |
 | **Options** | View US equity options chains |
-| **Ask AI** | Chat with AI about tickers using local CLI tools |
+| **AI** | Keep an Ask AI detail tab for tickers and create prompt-driven AI screener panes |
 | **Compare Charts** | Compare multiple ticker charts overlaid on one shared chart |
 | **X Scanner** | WIP |
 | **Alerts** | WIP |
 | **Scanner** | WIP |
 
+#### AI plugin
+
+- The ticker detail pane keeps its `Ask AI` tab for per-company questions.
+- The `AI Screener` pane lets you create multiple prompt-based screening tabs, refresh them, force reruns, edit the prompt, and review the last run time.
+- Use the `AI <prompt>` shortcut from the command bar to open a new screener pane seeded with a prompt.
+
 ### Data providers
 
 | Provider | Description |
@@ -64,32 +77,20 @@ See **[PLUGINS.md](PLUGINS.md)** for the plugin API and the shared UI surface av
 
 | Plugin | Description |
 |--------|-------------|
-| **IBKR** | Import positions from Interactive Brokers (Flex Query or Gateway API) |
+| **IBKR** | Import positions from Flex Query or trade with Gateway API. |
 | **Manual Entry** | Manually add positions, saved locally |
 
 Toggleable plugins can be enabled/disabled from the command bar screen (`Ctrl+p`).
 
-### Plugin slots
-
-Plugins extend the UI through defined slots:
-
-- `detail:tab` / `detail:section` — tabs or sections in the detail pane
-- `list:column` — custom columns in the ticker list
-- `command:extra` / `command:preset` — extend the command bar
-- `status:widget` — status bar widgets
-- `config:section` — settings page sections
-- `data:post-refresh` / `data:enricher` — hook into the data lifecycle
-
 ## ⌨️ Keyboard Shortcuts
 
 | Key | Action |
 |-----|--------|
 | `Ctrl+P` or `` ` `` | Open command bar |
+| `Ctrl+x` | Close current window |
 | `Tab` | Switch between panels |
-| `j` / `k` | Navigate ticker list |
+ `j` / `k` | Navigate ticker list |
 | `h` / `l` | Switch tabs |
-| `r` | Refresh selected ticker |
-| `Shift+R` | Refresh all tickers |
 | `Ctrl+,` | Open settings |
 | `m` | Cycle chart mode in the chart tab |
 | `q` | Quit |

package/bin/gloomberb

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+
+import "../src/index.tsx"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Bloomberg-style stock portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",
@@ -9,15 +9,16 @@
   },
   "files": [
     "bin",
-    "install.mjs"
+    "src",
+    "patches"
   ],
   "scripts": {
     "dev": "bun run --watch src/index.tsx",
+    "start": "bun src/index.tsx",
     "build": "bun run scripts/build.ts",
     "build:all": "bun run scripts/build.ts --all",
     "test": "bun test",
-    "release": "./scripts/release.sh",
-    "postinstall": "node install.mjs"
+    "release": "./scripts/release.sh"
   },
   "license": "MIT",
   "repository": {

package/patches/@opentui%2Fcore@0.1.90.patch

@@ -0,0 +1,356 @@
+diff --git a/index-e89anq5x.js b/index-e89anq5x.js
+index e3b6cf9..14a46d7 100644
+--- a/index-e89anq5x.js
++++ b/index-e89anq5x.js
+@@ -6328,17 +6328,27 @@ class MouseParser {
+     const buf = Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+     return buf.toString("latin1");
+   }
+-  parseMouseEvent(data) {
++  projectPixelToCell(pixel, pixelExtent, cellCount) {
++    if (cellCount <= 1) {
++      return 0;
++    }
++    if (!(pixelExtent > 0)) {
++      return Math.max(Math.floor(pixel), 0);
++    }
++    const projected = Math.floor(Math.max(pixel, 0) * cellCount / pixelExtent);
++    return Math.max(0, Math.min(projected, cellCount - 1));
++  }
++  parseMouseEvent(data, context = void 0) {
+     const str = this.decodeInput(data);
+-    const parsed = this.parseMouseSequenceAt(str, 0);
++    const parsed = this.parseMouseSequenceAt(str, 0, context);
+     return parsed?.event ?? null;
+   }
+-  parseAllMouseEvents(data) {
++  parseAllMouseEvents(data, context = void 0) {
+     const str = this.decodeInput(data);
+     const events = [];
+     let offset = 0;
+     while (offset < str.length) {
+-      const parsed = this.parseMouseSequenceAt(str, offset);
++      const parsed = this.parseMouseSequenceAt(str, offset, context);
+       if (!parsed) {
+         break;
+       }
+@@ -6347,19 +6357,19 @@ class MouseParser {
+     }
+     return events;
+   }
+-  parseMouseSequenceAt(str, offset) {
++  parseMouseSequenceAt(str, offset, context = void 0) {
+     if (!str.startsWith("\x1B[", offset))
+       return null;
+     const introducer = str[offset + 2];
+     if (introducer === "<") {
+-      return this.parseSgrSequence(str, offset);
++      return this.parseSgrSequence(str, offset, context);
+     }
+     if (introducer === "M") {
+       return this.parseBasicSequence(str, offset);
+     }
+     return null;
+   }
+-  parseSgrSequence(str, offset) {
++  parseSgrSequence(str, offset, context = void 0) {
+     let index = offset + 3;
+     const values = [0, 0, 0];
+     let part = 0;
+@@ -6387,7 +6397,7 @@ class MouseParser {
+           if (!hasDigit || part !== 2)
+             return null;
+           return {
+-            event: this.decodeSgrEvent(values[0], values[1], values[2], char),
++            event: this.decodeSgrEvent(values[0], values[1], values[2], char, context),
+             consumed: index - offset + 1
+           };
+         }
+@@ -6408,7 +6418,7 @@ class MouseParser {
+       consumed: 6
+     };
+   }
+-  decodeSgrEvent(rawButtonCode, wireX, wireY, pressRelease) {
++  decodeSgrEvent(rawButtonCode, wireX, wireY, pressRelease, context = void 0) {
+     const button = rawButtonCode & 3;
+     const isScroll = (rawButtonCode & 64) !== 0;
+     const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
+@@ -6443,11 +6453,26 @@ class MouseParser {
+         this.mouseButtonsPressed.clear();
+       }
+     }
++    const pixelModeRequested = context?.mouseUsesPixels === true;
++    const pixelModeConfirmed = context?.mousePixelsConfirmed === true;
++    const pixelModeDetected = pixelModeRequested && (
++      pixelModeConfirmed ||
++      wireX > (context?.terminalWidth ?? Number.POSITIVE_INFINITY) ||
++      wireY > (context?.terminalHeight ?? Number.POSITIVE_INFINITY)
++    );
++    const pixelX = pixelModeDetected ? Math.max(wireX - 1, 0) : void 0;
++    const pixelY = pixelModeDetected ? Math.max(wireY - 1, 0) : void 0;
+     return {
+       type,
+       button: button === 3 ? 0 : button,
+-      x: wireX - 1,
+-      y: wireY - 1,
++      x: pixelModeDetected && pixelX !== void 0
++        ? this.projectPixelToCell(pixelX, context?.pixelWidth ?? 0, context?.terminalWidth ?? 0)
++        : wireX - 1,
++      y: pixelModeDetected && pixelY !== void 0
++        ? this.projectPixelToCell(pixelY, context?.pixelHeight ?? 0, context?.terminalHeight ?? 0)
++        : wireY - 1,
++      pixelX,
++      pixelY,
+       modifiers,
+       scroll: scrollInfo
+     };
+@@ -6856,7 +6881,13 @@ var DEFAULT_PROTOCOL_CONTEXT = {
+   kittyKeyboardEnabled: false,
+   privateCapabilityRepliesActive: false,
+   pixelResolutionQueryActive: false,
+-  explicitWidthCprActive: false
++  explicitWidthCprActive: false,
++  mouseUsesPixels: false,
++  mousePixelsConfirmed: false,
++  terminalWidth: 0,
++  terminalHeight: 0,
++  pixelWidth: 0,
++  pixelHeight: 0
+ };
+ var RXVT_DOLLAR_CSI_RE = /^\x1b\[\d+\$$/;
+ var SYSTEM_CLOCK = new SystemClock;
+@@ -7149,7 +7180,13 @@ class StdinParser {
+       kittyKeyboardEnabled: options.protocolContext?.kittyKeyboardEnabled ?? false,
+       privateCapabilityRepliesActive: options.protocolContext?.privateCapabilityRepliesActive ?? false,
+       pixelResolutionQueryActive: options.protocolContext?.pixelResolutionQueryActive ?? false,
+-      explicitWidthCprActive: options.protocolContext?.explicitWidthCprActive ?? false
++      explicitWidthCprActive: options.protocolContext?.explicitWidthCprActive ?? false,
++      mouseUsesPixels: options.protocolContext?.mouseUsesPixels ?? false,
++      mousePixelsConfirmed: options.protocolContext?.mousePixelsConfirmed ?? false,
++      terminalWidth: options.protocolContext?.terminalWidth ?? 0,
++      terminalHeight: options.protocolContext?.terminalHeight ?? 0,
++      pixelWidth: options.protocolContext?.pixelWidth ?? 0,
++      pixelHeight: options.protocolContext?.pixelHeight ?? 0
+     };
+   }
+   get bufferCapacity() {
+@@ -7952,11 +7989,14 @@ class StdinParser {
+     });
+   }
+   emitMouse(rawBytes, encoding) {
+-    const event = this.mouseParser.parseMouseEvent(rawBytes);
++    const event = this.mouseParser.parseMouseEvent(rawBytes, this.protocolContext);
+     if (!event) {
+       this.emitOpaqueResponse("unknown", rawBytes);
+       return;
+     }
++    if (event.pixelX !== void 0 && event.pixelY !== void 0 && !this.protocolContext.mousePixelsConfirmed) {
++      this.updateProtocolContext({ mousePixelsConfirmed: true });
++    }
+     this.events.push({
+       type: "mouse",
+       raw: decodeLatin1(rawBytes),
+@@ -17295,6 +17335,8 @@ class MouseEvent {
+   button;
+   x;
+   y;
++  pixelX;
++  pixelY;
+   source;
+   modifiers;
+   scroll;
+@@ -17314,6 +17356,8 @@ class MouseEvent {
+     this.button = attributes.button;
+     this.x = attributes.x;
+     this.y = attributes.y;
++    this.pixelX = attributes.pixelX;
++    this.pixelY = attributes.pixelY;
+     this.modifiers = attributes.modifiers;
+     this.scroll = attributes.scroll;
+     this.source = attributes.source;
+@@ -17479,6 +17523,8 @@ class CliRenderer extends EventEmitter8 {
+   resizeDebounceDelay = 100;
+   enableMouseMovement = false;
+   _useMouse = true;
++  _mouseProtocolSignature = "disabled";
++  _pixelMouseEnabled = false;
+   autoFocus = true;
+   _useAlternateScreen = env.OTUI_USE_ALTERNATE_SCREEN;
+   _suspendedMouseEnabled = false;
+@@ -17507,7 +17553,7 @@ class CliRenderer extends EventEmitter8 {
+     this.handleResize(width, height);
+   }).bind(this);
+   _capabilities = null;
+-  _latestPointer = { x: 0, y: 0 };
++  _latestPointer = { x: 0, y: 0, pixelX: void 0, pixelY: void 0 };
+   _hasPointer = false;
+   _lastPointerModifiers = { shift: false, alt: false, ctrl: false };
+   _currentMousePointerStyle = undefined;
+@@ -17661,7 +17707,13 @@ Captured output:
+         kittyKeyboardEnabled: useKittyForParsing,
+         privateCapabilityRepliesActive: false,
+         pixelResolutionQueryActive: false,
+-        explicitWidthCprActive: false
++        explicitWidthCprActive: false,
++        mouseUsesPixels: false,
++        mousePixelsConfirmed: false,
++        terminalWidth: this._terminalWidth,
++        terminalHeight: this._terminalHeight,
++        pixelWidth: 0,
++        pixelHeight: 0
+       },
+       clock: this.clock
+     });
+@@ -17983,12 +18035,14 @@ Captured output:
+   enableMouse() {
+     this._useMouse = true;
+     this.lib.enableMouse(this.rendererPtr, this.enableMouseMovement);
++    this.syncPixelMouseMode();
+   }
+   disableMouse() {
+     this._useMouse = false;
+     this.setCapturedRenderable(undefined);
+     this.stdinParser?.resetMouseState();
+     this.lib.disableMouse(this.rendererPtr);
++    this.disablePixelMouseMode();
+   }
+   enableKittyKeyboard(flags = 3) {
+     this.lib.enableKittyKeyboard(this.rendererPtr, flags);
+@@ -17998,6 +18052,64 @@ Captured output:
+     this.lib.disableKittyKeyboard(this.rendererPtr);
+     this.updateStdinParserProtocolContext({ kittyKeyboardEnabled: false }, true);
+   }
++  getMouseProtocolTrackingMode() {
++    return this.enableMouseMovement ? "any" : "press";
++  }
++  buildMouseProtocolSequence(pixelEnabled) {
++    const trackingSequence = this.enableMouseMovement
++      ? "\x1B[?1000l\x1B[?1002l\x1B[?1003h"
++      : "\x1B[?1003l\x1B[?1002l\x1B[?1000h";
++    return "\x1B[?1005l\x1B[?1015l\x1B[?1006h" + trackingSequence + (pixelEnabled ? "\x1B[?1016h" : "\x1B[?1016l");
++  }
++  syncPixelMouseMode(force = false) {
++    const nextEnabled = Boolean(this._useMouse);
++    const pixelMouseDisabled = typeof process !== "undefined" && process?.env?.GLOOMBERB_DISABLE_PIXEL_MOUSE === "1";
++    const hasPixelCapability = this._capabilities?.sgr_pixels === true;
++    const hasPixelResolution = (this._resolution?.width ?? 0) > 0 && (this._resolution?.height ?? 0) > 0;
++    const nextPixelEnabled = Boolean(
++      nextEnabled &&
++      !pixelMouseDisabled &&
++      hasPixelCapability &&
++      hasPixelResolution &&
++      this._terminalWidth > 0 &&
++      this._terminalHeight > 0
++    );
++    const nextSignature = nextEnabled
++      ? `${this.getMouseProtocolTrackingMode()}:${nextPixelEnabled ? "pixel" : "cell"}`
++      : "disabled";
++    if (nextEnabled) {
++      if (force || this._mouseProtocolSignature !== nextSignature) {
++        this.writeOut(this.buildMouseProtocolSequence(nextPixelEnabled));
++      }
++    } else if (force || this._mouseProtocolSignature !== "disabled") {
++      this.writeOut("\x1B[?1016l\x1B[?1006l\x1B[?1005l\x1B[?1015l\x1B[?1003l\x1B[?1002l\x1B[?1000l");
++    }
++    this._mouseProtocolSignature = nextSignature;
++    this._pixelMouseEnabled = nextPixelEnabled;
++    this.updateStdinParserProtocolContext({
++      mouseUsesPixels: nextPixelEnabled,
++      mousePixelsConfirmed: nextPixelEnabled,
++      terminalWidth: this._terminalWidth,
++      terminalHeight: this._terminalHeight,
++      pixelWidth: this._resolution?.width ?? 0,
++      pixelHeight: this._resolution?.height ?? 0
++    }, true);
++  }
++  disablePixelMouseMode() {
++    if (this._mouseProtocolSignature !== "disabled") {
++      this.writeOut("\x1B[?1016l\x1B[?1006l\x1B[?1005l\x1B[?1015l\x1B[?1003l\x1B[?1002l\x1B[?1000l");
++    }
++    this._mouseProtocolSignature = "disabled";
++    this._pixelMouseEnabled = false;
++    this.updateStdinParserProtocolContext({
++      mouseUsesPixels: false,
++      mousePixelsConfirmed: false,
++      terminalWidth: this._terminalWidth,
++      terminalHeight: this._terminalHeight,
++      pixelWidth: this._resolution?.width ?? 0,
++      pixelHeight: this._resolution?.height ?? 0
++    }, true);
++  }
+   set useThread(useThread) {
+     this._useThread = useThread;
+     this.lib.setUseThread(this.rendererPtr, useThread);
+@@ -18031,6 +18143,7 @@ Captured output:
+     if (this._useMouse) {
+       this.enableMouse();
+     }
++    this.syncPixelMouseMode();
+     this.queryPixelResolution();
+   }
+   stdinListener = ((chunk) => {
+@@ -18070,6 +18183,7 @@ Captured output:
+     if (isCapabilityResponse(sequence)) {
+       this.lib.processCapabilityResponse(this.rendererPtr, sequence);
+       this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
++      this.syncPixelMouseMode();
+       this.emit("capabilities" /* CAPABILITIES */, this._capabilities);
+       return true;
+     }
+@@ -18079,6 +18193,7 @@ Captured output:
+     if (sequence === "\x1B[I") {
+       if (this.shouldRestoreModesOnNextFocus) {
+         this.lib.restoreTerminalModes(this.rendererPtr);
++        this.syncPixelMouseMode(true);
+         this.shouldRestoreModesOnNextFocus = false;
+       }
+       if (this._terminalFocusState !== true) {
+@@ -18187,6 +18302,7 @@ Captured output:
+         }
+         this.waitingForPixelResolution = false;
+         this.updateStdinParserProtocolContext({ pixelResolutionQueryActive: false }, true);
++        this.syncPixelMouseMode();
+         return true;
+       }
+       return false;
+@@ -18221,9 +18337,15 @@ Captured output:
+         return false;
+       }
+       mouseEvent.y -= this.renderOffset;
++      if (mouseEvent.pixelY !== void 0 && this._resolution) {
++        const cellHeight = this._resolution.height / Math.max(this._terminalHeight, 1);
++        mouseEvent.pixelY = Math.max(mouseEvent.pixelY - this.renderOffset * cellHeight, 0);
++      }
+     }
+     this._latestPointer.x = mouseEvent.x;
+     this._latestPointer.y = mouseEvent.y;
++    this._latestPointer.pixelX = mouseEvent.pixelX;
++    this._latestPointer.pixelY = mouseEvent.pixelY;
+     this._hasPointer = true;
+     this._lastPointerModifiers = mouseEvent.modifiers;
+     if (this._console.visible) {
+@@ -18352,6 +18474,8 @@ Captured output:
+       button: 0,
+       x: this._latestPointer.x,
+       y: this._latestPointer.y,
++      pixelX: this._latestPointer.pixelX,
++      pixelY: this._latestPointer.pixelY,
+       modifiers: this._lastPointerModifiers
+     };
+     if (lastOver && !lastOver.isDestroyed) {
+@@ -18435,6 +18559,7 @@ Captured output:
+     const prevWidth = this._terminalWidth;
+     this._terminalWidth = width;
+     this._terminalHeight = height;
++    this.syncPixelMouseMode();
+     this.queryPixelResolution();
+     this.setCapturedRenderable(undefined);
+     this.stdinParser?.resetMouseState();
+@@ -18712,6 +18837,7 @@ Captured output:
+     }
+     this._isRunning = false;
+     this.waitingForPixelResolution = false;
++    this.disablePixelMouseMode();
+     this.updateStdinParserProtocolContext({
+       privateCapabilityRepliesActive: false,
+       pixelResolutionQueryActive: false,