gloomberb 0.1.0 → 0.3.1

package/src/plugins/builtin/help.tsx

@@ -0,0 +1,281 @@
+import { TextAttributes } from "@opentui/core";
+import { useKeyboard } from "@opentui/react";
+import { useState } from "react";
+import type { ReactNode } from "react";
+import type { GloomPlugin, PaneProps } from "../../types/plugin";
+import { colors, hoverBg } from "../../theme/colors";
+import { getSharedRegistry } from "../registry";
+
+function ShortcutBadge({ label }: { label: string }) {
+  return (
+    <box backgroundColor={colors.selected}>
+      <text fg={colors.selectedText} attributes={TextAttributes.BOLD}>
+        {` ${label} `}
+      </text>
+    </box>
+  );
+}
+
+function ShortcutRow({
+  badges,
+  description,
+  compact,
+}: {
+  badges: string[];
+  description: string;
+  compact: boolean;
+}) {
+  return (
+    <box flexDirection={compact ? "column" : "row"} gap={1}>
+      <box flexDirection="row" gap={1} flexShrink={0}>
+        {badges.map((badge) => <ShortcutBadge key={badge} label={badge} />)}
+      </box>
+      <box flexGrow={1}>
+        <text fg={colors.text}>{description}</text>
+      </box>
+    </box>
+  );
+}
+
+function HelpSection({ title, children }: { title: string; children: ReactNode }) {
+  return (
+    <box flexDirection="column">
+      <text fg={colors.textBright} attributes={TextAttributes.BOLD}>{title}</text>
+      <box height={1} />
+      {children}
+    </box>
+  );
+}
+
+function ActionButton({
+  id,
+  label,
+  hovered,
+  onHover,
+  onPress,
+}: {
+  id: string;
+  label: string;
+  hovered: boolean;
+  onHover: (id: string | null) => void;
+  onPress: () => void;
+}) {
+  return (
+    <box
+      backgroundColor={hovered ? hoverBg() : colors.panel}
+      onMouseMove={() => onHover(id)}
+      onMouseOut={() => onHover(null)}
+      onMouseDown={(event: any) => {
+        event.stopPropagation?.();
+        event.preventDefault?.();
+        onPress();
+      }}
+    >
+      <text fg={hovered ? colors.textBright : colors.text}>{` ${label} `}</text>
+    </box>
+  );
+}
+
+function resolveWindowTemplates(registry: ReturnType<typeof getSharedRegistry>) {
+  if (!registry || !registry.paneTemplates) return [];
+
+  const disabledPlugins = new Set(registry.getConfigFn?.().disabledPlugins ?? []);
+  const allPlugins = registry.allPlugins ?? new Map<string, { name?: string }>();
+
+  return [...registry.paneTemplates.values()]
+    .filter((template) => template.shortcut)
+    .filter((template) => {
+      const pluginId = registry.getPaneTemplatePluginId?.(template.id);
+      return !pluginId || !disabledPlugins.has(pluginId);
+    })
+    .map((template) => {
+      const shortcut = template.shortcut!;
+      const pluginId = registry.getPaneTemplatePluginId?.(template.id);
+      const pluginName = pluginId ? allPlugins.get(pluginId)?.name : null;
+      return {
+        id: template.id,
+        badges: [
+          shortcut.prefix,
+          shortcut.argPlaceholder ? `<${shortcut.argPlaceholder}>` : null,
+        ].filter((value): value is string => !!value),
+        description: pluginName ? `${template.label} (${pluginName})` : template.label,
+      };
+    })
+    .sort((left, right) => (
+      left.badges.join(" ").localeCompare(right.badges.join(" "))
+      || left.description.localeCompare(right.description)
+    ));
+}
+
+export function HelpPane({ focused, width, height, close }: PaneProps) {
+  const registry = getSharedRegistry();
+  const compact = width < 78;
+  const [hoveredAction, setHoveredAction] = useState<string | null>(null);
+  const windowTemplates = resolveWindowTemplates(registry);
+
+  useKeyboard((event) => {
+    if (!focused) return;
+    if (event.name === "escape") {
+      close?.();
+    }
+  });
+
+  const openDebugLog = () => {
+    close?.();
+    registry?.showWidget("debug");
+  };
+
+  const openLayoutActions = () => {
+    close?.();
+    registry?.openCommandBarFn("LAY ");
+  };
+
+  const openPluginManager = () => {
+    close?.();
+    registry?.openCommandBarFn("PL ");
+  };
+
+  return (
+    <box flexDirection="column" width={width} height={height}>
+      <scrollbox flexGrow={1} scrollY>
+        <box flexDirection="column" padding={1}>
+          <box flexDirection="column" gap={1}>
+            <text fg={colors.textBright} attributes={TextAttributes.BOLD}>How To Use Gloomberb</text>
+            <box flexDirection="column">
+              <text fg={colors.textDim}>Gloomberb is command-bar first.</text>
+              <text fg={colors.textDim}>Use the keyboard for speed, and the mouse for windows.</text>
+            </box>
+          </box>
+
+          <box flexDirection={compact ? "column" : "row"} gap={1}>
+            <ActionButton
+              id="debug"
+              label="Open Debug Log"
+              hovered={hoveredAction === "debug"}
+              onHover={setHoveredAction}
+              onPress={openDebugLog}
+            />
+            <ActionButton
+              id="layout"
+              label="Layout Actions"
+              hovered={hoveredAction === "layout"}
+              onHover={setHoveredAction}
+              onPress={openLayoutActions}
+            />
+            <ActionButton
+              id="plugins"
+              label="Manage Plugins"
+              hovered={hoveredAction === "plugins"}
+              onHover={setHoveredAction}
+              onPress={openPluginManager}
+            />
+          </box>
+
+          <HelpSection title="Command Bar">
+            <ShortcutRow
+              badges={["Ctrl+P", "`"]}
+              description="Open the command bar from anywhere."
+              compact={compact}
+            />
+            <ShortcutRow
+              badges={["help"]}
+              description="Open this help window directly."
+              compact={compact}
+            />
+            <ShortcutRow
+              badges={["T <ticker>"]}
+              description="Search for a ticker or company and open it."
+              compact={compact}
+            />
+            <ShortcutRow
+              badges={["NP", "PS", "PL"]}
+              description="Create panes, edit pane settings, and manage plugins."
+              compact={compact}
+            />
+          </HelpSection>
+
+          <HelpSection title="Window Templates">
+            {windowTemplates.length > 0 ? windowTemplates.map((template) => (
+              <ShortcutRow
+                key={template.id}
+                badges={template.badges}
+                description={template.description}
+                compact={compact}
+              />
+            )) : (
+              <text fg={colors.textDim}>No shortcut window templates are currently registered.</text>
+            )}
+          </HelpSection>
+
+          <HelpSection title="Move Around">
+            <ShortcutRow
+              badges={["Tab", "Shift+Tab"]}
+              description="Move focus between panes and floating windows."
+              compact={compact}
+            />
+            <ShortcutRow
+              badges={["Ctrl+W"]}
+              description="Close the focused pane, docked or floating."
+              compact={compact}
+            />
+            <ShortcutRow
+              badges={["j", "k"]}
+              description="Move through lists in most panes. Arrow keys also work."
+              compact={compact}
+            />
+            <ShortcutRow
+              badges={["r", "Shift+R"]}
+              description="Refresh the focused ticker or refresh everything."
+              compact={compact}
+            />
+          </HelpSection>
+
+          <HelpSection title="Layout System">
+            <ShortcutRow
+              badges={["LAY"]}
+              description="Open layout actions."
+              compact={compact}
+            />
+            <text fg={colors.text}>Docked panes stay in the saved layout.</text>
+            <box flexDirection="column">
+              <text fg={colors.text}>Floating panes can be dragged by the title bar</text>
+              <text fg={colors.text}>and resized from the lower-right corner.</text>
+            </box>
+            <text fg={colors.text}>Run Gridlock All Windows if the layout gets messy.</text>
+          </HelpSection>
+
+          <HelpSection title="If There Is A Bug">
+            <text fg={colors.text}>Open Debug Log, then run Export Debug Log from the command bar.</text>
+            <box flexDirection="column">
+              <text fg={colors.text}>The file lands in ~/Downloads. Include steps, ticker or layout, plugin,</text>
+              <text fg={colors.text}>and a screenshot if it is visual.</text>
+            </box>
+          </HelpSection>
+        </box>
+      </scrollbox>
+
+      <box height={1} paddingX={1}>
+        <text fg={colors.textMuted}>Esc closes this window. Ctrl+W closes the focused pane.</text>
+      </box>
+    </box>
+  );
+}
+
+export const helpPlugin: GloomPlugin = {
+  id: "help",
+  name: "Help",
+  version: "1.0.0",
+  description: "Shortcut and layout help",
+
+  panes: [
+    {
+      id: "help",
+      name: "Help",
+      icon: "?",
+      component: HelpPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 88, height: 32 },
+    },
+  ],
+};

package/src/plugins/builtin/layout-manager.tsx

@@ -0,0 +1,264 @@
+import { saveConfig } from "../../data/config-store";
+import { findPaneInstance, type LayoutConfig } from "../../types/config";
+import type { GloomPlugin, GloomPluginContext } from "../../types/plugin";
+import type { AppAction } from "../../state/app-context";
+import { getSharedRegistry } from "../registry";
+import {
+  dockPane,
+  floatPane,
+  getDockedPaneIds,
+  gridlockAllPanes,
+  isPaneInLayout,
+  isPaneDocked,
+  removePane,
+  swapPanes,
+} from "../pane-manager";
+
+let dispatchRef: ((action: AppAction) => void) | null = null;
+let getStateRef: (() => { layout: LayoutConfig; termWidth: number; termHeight: number; focusedPaneId: string | null }) | null = null;
+
+export function setLayoutManagerDispatch(
+  dispatch: (action: AppAction) => void,
+  getState: () => { layout: LayoutConfig; termWidth: number; termHeight: number; focusedPaneId: string | null },
+) {
+  dispatchRef = dispatch;
+  getStateRef = getState;
+}
+
+function persistLayout(layout: LayoutConfig) {
+  if (!dispatchRef) return;
+  dispatchRef({ type: "PUSH_LAYOUT_HISTORY" });
+  dispatchRef({ type: "UPDATE_LAYOUT", layout });
+  const registry = getSharedRegistry();
+  if (!registry) return;
+  const config = registry.getConfigFn();
+  const layouts = config.layouts.map((savedLayout, index) => (
+    index === config.activeLayoutIndex ? { ...savedLayout, layout } : savedLayout
+  ));
+  saveConfig({ ...config, layout, layouts }).catch(() => {});
+}
+
+function getFocusedPane(layout: LayoutConfig, focusedPaneId: string | null) {
+  return focusedPaneId ? findPaneInstance(layout, focusedPaneId) ?? null : null;
+}
+
+export const layoutManagerPlugin: GloomPlugin = {
+  id: "layout-manager",
+  name: "Layout Manager",
+  version: "1.0.0",
+  description: "Pane layout management commands",
+
+  setup(ctx) {
+    ctx.registerCommand({
+      id: "float-pane",
+      label: "Float Pane",
+      description: "Detach a docked pane into a floating window",
+      keywords: ["float", "detach", "undock", "window", "pane"],
+      category: "config",
+      execute: async () => {
+        if (!getStateRef) return;
+        const registry = getSharedRegistry();
+        if (!registry) return;
+
+        const { layout, termWidth, termHeight, focusedPaneId } = getStateRef();
+        const focusedPane = getFocusedPane(layout, focusedPaneId);
+        if (!focusedPane || !isPaneDocked(layout, focusedPane.instanceId)) {
+          ctx.showToast("Focus a docked pane to float it", { type: "info" });
+          return;
+        }
+
+        const def = registry.panes.get(focusedPane.paneId);
+        const nextLayout = floatPane(layout, focusedPane.instanceId, termWidth, termHeight, def);
+        persistLayout(nextLayout);
+        dispatchRef?.({ type: "FOCUS_PANE", paneId: focusedPane.instanceId });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "dock-pane",
+      label: "Dock Pane",
+      description: "Dock a floating pane back into the layout",
+      keywords: ["dock", "attach", "pin", "pane"],
+      category: "config",
+      execute: async () => {
+        if (!getStateRef) return;
+        const registry = getSharedRegistry();
+        if (!registry) return;
+
+        const { layout, focusedPaneId } = getStateRef();
+        const focusedPane = getFocusedPane(layout, focusedPaneId);
+        if (!focusedPane || !layout.floating.some((entry) => entry.instanceId === focusedPane.instanceId)) {
+          ctx.showToast("Focus a floating pane to dock it", { type: "info" });
+          return;
+        }
+
+        const nextLayout = dockPane(layout, focusedPane.instanceId);
+        persistLayout(nextLayout);
+        dispatchRef?.({ type: "FOCUS_PANE", paneId: focusedPane.instanceId });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "add-pane",
+      label: "New Pane",
+      description: "Create a new pane from plugin templates",
+      keywords: ["new", "add", "pane", "panel", "show"],
+      category: "config",
+      hidden: () => true,
+      execute: async () => {
+        ctx.openCommandBar("NP ");
+        ctx.showToast("Choose a pane template to create", { type: "info" });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "gridlock-all",
+      label: "Gridlock All Windows",
+      description: "Arrange all visible panes into a tiled grid",
+      keywords: ["grid", "gridlock", "tile", "arrange", "windows", "layout"],
+      category: "config",
+      execute: async () => {
+        if (!getStateRef) return;
+        const { layout, termWidth, termHeight } = getStateRef();
+        persistLayout(gridlockAllPanes(layout, { x: 0, y: 0, width: termWidth, height: termHeight }));
+        ctx.showToast("Retiled all panes", { type: "success" });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "remove-pane",
+      label: "Remove Pane",
+      description: "Remove a pane from the layout",
+      keywords: ["remove", "pane", "close", "hide", "panel"],
+      category: "config",
+      execute: async () => {
+        if (!getStateRef) return;
+        const { layout, focusedPaneId } = getStateRef();
+        const focusedPane = getFocusedPane(layout, focusedPaneId);
+        if (!focusedPane || !isPaneInLayout(layout, focusedPane.instanceId)) {
+          ctx.showToast("Focus a pane to remove it", { type: "info" });
+          return;
+        }
+        persistLayout(removePane(layout, focusedPane.instanceId));
+      },
+    });
+
+    ctx.registerCommand({
+      id: "new-layout",
+      label: "New Layout",
+      description: "Create a new layout",
+      keywords: ["new", "create", "add", "layout", "workspace"],
+      category: "config",
+      wizard: [{ key: "name", label: "Layout name", placeholder: "e.g. Trading, Research, Overview" }],
+      execute: async (values) => {
+        const name = values?.name?.trim();
+        if (!name) {
+          ctx.showToast("Layout name is required", { type: "error" });
+          return;
+        }
+        dispatchRef?.({ type: "NEW_LAYOUT", name });
+        ctx.showToast(`Layout "${name}" created`, { type: "success" });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "delete-layout",
+      label: "Delete Layout",
+      description: "Delete the current layout preset",
+      keywords: ["delete", "remove", "layout", "preset"],
+      category: "config",
+      confirm: () => {
+        const registry = getSharedRegistry();
+        if (!registry) return null;
+        const config = registry.getConfigFn();
+        const layout = config.layouts[config.activeLayoutIndex];
+        if (!layout) return null;
+        return {
+          title: "Delete Layout",
+          body: [`Delete layout "${layout.name}"? This cannot be undone.`],
+          confirmLabel: "Delete Layout",
+          cancelLabel: "Back",
+          tone: "danger",
+        };
+      },
+      execute: async () => {
+        const registry = getSharedRegistry();
+        if (!registry) return;
+        const config = registry.getConfigFn();
+        if (config.layouts.length <= 1) {
+          ctx.showToast("Can't delete the only layout", { type: "error" });
+          return;
+        }
+        const index = config.activeLayoutIndex;
+        const name = config.layouts[index]!.name;
+        dispatchRef?.({ type: "DELETE_LAYOUT", index });
+        ctx.showToast(`Layout "${name}" deleted`, { type: "success" });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "rename-layout",
+      label: "Rename Layout",
+      description: "Rename the current layout preset",
+      keywords: ["rename", "layout", "preset"],
+      category: "config",
+      wizard: [{ key: "name", label: "New name", placeholder: "Layout name" }],
+      execute: async (values) => {
+        const name = values?.name?.trim();
+        if (!name) {
+          ctx.showToast("Name is required", { type: "error" });
+          return;
+        }
+        const registry = getSharedRegistry();
+        if (!registry) return;
+        dispatchRef?.({ type: "RENAME_LAYOUT", index: registry.getConfigFn().activeLayoutIndex, name });
+        ctx.showToast(`Layout renamed to "${name}"`, { type: "success" });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "duplicate-layout",
+      label: "Duplicate Layout",
+      description: "Create a copy of the current layout",
+      keywords: ["duplicate", "copy", "clone", "layout"],
+      category: "config",
+      execute: async () => {
+        const registry = getSharedRegistry();
+        if (!registry) return;
+        dispatchRef?.({ type: "DUPLICATE_LAYOUT", index: registry.getConfigFn().activeLayoutIndex });
+        ctx.showToast("Layout duplicated", { type: "success" });
+      },
+    });
+
+    ctx.registerCommand({
+      id: "swap-panes",
+      label: "Swap Panes",
+      description: "Swap two pane positions",
+      keywords: ["swap", "switch", "pane", "panel"],
+      category: "config",
+      execute: async () => {
+        if (!getStateRef) return;
+        const { layout, focusedPaneId } = getStateRef();
+        const focusedPane = getFocusedPane(layout, focusedPaneId);
+        const dockedPaneIds = getDockedPaneIds(layout);
+        if (dockedPaneIds.length < 2) {
+          ctx.showToast("Need at least 2 docked panes to swap", { type: "info" });
+          return;
+        }
+        if (!focusedPane || !isPaneDocked(layout, focusedPane.instanceId)) {
+          ctx.showToast("Focus a docked pane to swap it", { type: "info" });
+          return;
+        }
+
+        const others = dockedPaneIds.filter((instanceId) => instanceId !== focusedPane.instanceId);
+        if (others.length === 1) {
+          persistLayout(swapPanes(layout, focusedPane.instanceId, others[0]!));
+          return;
+        }
+
+        ctx.openCommandBar("LAY ");
+        ctx.showToast("Choose a swap target from layout mode", { type: "info" });
+      },
+    });
+  },
+};

package/src/plugins/builtin/manual-entry.tsx

@@ -0,0 +1,25 @@
+import type { GloomPlugin } from "../../types/plugin";
+import type { BrokerAdapter, BrokerPosition } from "../../types/broker";
+
+const manualBroker: BrokerAdapter = {
+  id: "manual",
+  name: "Manual Entry",
+
+  async validate() {
+    return true; // Always valid
+  },
+
+  async importPositions(): Promise<BrokerPosition[]> {
+    // Manual entry doesn't import - positions are created directly
+    return [];
+  },
+
+  configSchema: [],
+};
+
+export const manualEntryPlugin: GloomPlugin = {
+  id: "manual-entry",
+  name: "Manual Entry",
+  version: "1.0.0",
+  broker: manualBroker,
+};