gloomberb 0.9.1 → 0.9.3

package/README.md

@@ -70,22 +70,43 @@ Open command mode with `Ctrl+P`, then type a command. Press `` ` `` to open tick
 
 ## CLI
 
-Running `gloomberb` with no arguments launches the terminal UI. Use `gloomberb help` to see the full command list.
+Running `gloomberb` with no arguments launches the terminal UI. Normal commands run through a headless CLI path; use `gloomberb launch-ui` when a script should explicitly open the UI.
+
+Human-readable output is the default. Automation can opt into structured output with `--json`, `--csv`, or `--ndjson`. JSON output favors the richest fetched model available and includes display-column metadata when a command has table columns; CSV and NDJSON use the command's tabular row view. Common global flags include `--limit`, `--refresh`, `--quiet`, `--no-color`, `--dry-run`, and `--yes`.
 
 | Command | Use |
 |---------|-----|
 | `gloomberb` | Launch the terminal UI |
+| `gloomberb launch-ui` | Explicitly launch the terminal UI |
 | `gloomberb help` | Show all CLI commands |
-| `gloomberb search <query>` | Search tickers and company names |
+| `gloomberb api list|get|invoke|subscribe` | Inspect and call plugin capabilities directly |
+| `gloomberb quote <symbols>` | Fetch current quotes |
+| `gloomberb search <query>` / `provider-search <query>` | Search tickers and provider symbols |
 | `gloomberb ticker <symbol>` | Show quote, ownership, and financials |
+| `gloomberb history|financials|fundamentals|options <symbol>` | Fetch research data |
+| `gloomberb news|filings|holders|insider|13f|analyst|events|valuation <symbol>` | Fetch company research feeds |
+| `gloomberb movers|indices|sectors|fx|fear-greed|earnings` | Fetch market overview data |
+| `gloomberb econ|fred|yield-curve` | Fetch macro data |
+| `gloomberb compare|correlation|relationship <symbols>` | Compare securities |
 | `gloomberb portfolio [action]` | Manage manual portfolios |
 | `gloomberb watchlist [action]` | Manage watchlists |
+| `gloomberb notes|alerts [action]` | Manage local notes and alerts |
+| `gloomberb broker|ibkr [action]` | Inspect broker integrations; trading actions require explicit account/profile and `--yes` |
+| `gloomberb ai providers|ask|screen` | Use configured AI providers and screeners |
+| `gloomberb rss fetch <url>` | Fetch an RSS feed |
+| `gloomberb buildout|congress|substack|x-feed|tweets` | Access cloud and social data sources when an existing session is available |
+| `gloomberb provider status` | Inspect enabled data providers |
+| `gloomberb config|cache|plugin|layout|pane|debug|doctor|version|changelog` | Inspect and manage local app state |
+| `gloomberb fn [...]` | Run a pane-backed report command |
+| `gloomberb shot [...]` | Capture a pane-backed screenshot |
 | `gloomberb predictions [...]` | Launch Prediction Markets |
 | `gloomberb plugins` | List installed plugins |
 | `gloomberb install <user/repo>` | Install a plugin from GitHub |
 | `gloomberb remove <name>` | Remove an installed plugin |
 | `gloomberb update [name]` | Update plugins |
 
+Commands that need a signed-in cloud session may return `auth_required`; sign-in, account management, and chat workflows are still handled in the app UI for now.
+
 ## Plugins
 
 Everything from the portfolio list to broker integrations is a plugin. Plugins can add panes, tabs, columns, command bar commands, CLI commands, status bar widgets, and data providers.

package/bin/gloomberb

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/app.tsx

@@ -14,6 +14,7 @@ import { Header } from "./components/layout/header";
 import { StatusBar } from "./components/layout/status-bar";
 import { Shell } from "./components/layout/shell";
 import { DetachedPaneShell } from "./components/layout/detached-pane-shell";
+import { TransientLayoutProvider } from "./components/layout/transient-layout";
 import { CommandBar } from "./components/command-bar/surface";
 import { OnboardingWizard } from "./components/onboarding/onboarding-wizard";
 import { useDialog } from "./ui/dialog";
@@ -293,13 +294,15 @@ function AppInner({
     <ContextMenuProvider pluginRegistry={pluginRegistry}>
       <ThemedAppRoot>
         <Header />
-        <Shell
-          pluginRegistry={pluginRegistry}
-          desktopWindowBridge={desktopWindowBridge}
-          desktopDockPreview={desktopDockPreview}
-          commandBarNativeOccluder={commandBarNativeOccluder}
-        />
-        <StatusBar />
+        <TransientLayoutProvider>
+          <Shell
+            pluginRegistry={pluginRegistry}
+            desktopWindowBridge={desktopWindowBridge}
+            desktopDockPreview={desktopDockPreview}
+            commandBarNativeOccluder={commandBarNativeOccluder}
+          />
+          <StatusBar />
+        </TransientLayoutProvider>
         {state.commandBarOpen && (
           <CommandBar
             dataProvider={dataProvider}

package/src/capabilities/registry.ts

@@ -58,6 +58,7 @@ export class CapabilityRegistry {
           id,
           kind: operation.kind,
           rendererSafe: operation.rendererSafe === true,
+          ...operation.cli,
         }));
       return {
         id: capability.id,

package/src/capabilities/types.ts

@@ -3,6 +3,7 @@ import type { AssetDataProvider } from "../types/data-provider";
 import type { NewsDataProvider } from "../types/capability-route-source";
 
 type CapabilityOperationKind = "read" | "query" | "action" | "stream";
+type CapabilitySideEffectLevel = "none" | "local-write" | "network-write" | "external-trade" | "external-side-effect";
 
 type CapabilityKind =
   | "asset-data"
@@ -20,9 +21,22 @@ interface CapabilityHandlerContext {
 
 type CapabilityStreamEmit<T = unknown> = (event: T) => void;
 
+export interface CapabilityOperationCliManifest {
+  summary?: string;
+  inputShape?: string;
+  outputShape?: string;
+  examples?: string[];
+  sideEffectLevel?: CapabilitySideEffectLevel;
+  requirements?: string[];
+  batch?: boolean;
+  formats?: Array<"text" | "json" | "csv" | "ndjson">;
+  safety?: string[];
+}
+
 export interface CapabilityOperation<I = unknown, O = unknown, E = unknown> {
   kind: CapabilityOperationKind;
   rendererSafe?: boolean;
+  cli?: CapabilityOperationCliManifest;
   input?: CapabilitySchema<I>;
   output?: CapabilitySchema<O>;
   cachePolicy?: CachePolicyMap[keyof CachePolicyMap];
@@ -55,6 +69,15 @@ export interface CapabilityOperationManifest {
   id: string;
   kind: CapabilityOperationKind;
   rendererSafe: boolean;
+  summary?: string;
+  inputShape?: string;
+  outputShape?: string;
+  examples?: string[];
+  sideEffectLevel?: CapabilitySideEffectLevel;
+  requirements?: string[];
+  batch?: boolean;
+  formats?: Array<"text" | "json" | "csv" | "ndjson">;
+  safety?: string[];
 }
 
 export interface CapabilityManifest {

package/src/cli/commands/api.ts

@@ -0,0 +1,119 @@
+import type { CliCommandDef } from "../../types/plugin";
+import { parseJsonPayload, requireArg, takeOption } from "./command-utils";
+
+function splitOperationTarget(target: string): { capabilityId: string; operationId: string } {
+  const separator = target.lastIndexOf(".");
+  if (separator <= 0 || separator === target.length - 1) {
+    throw new Error("Use <capability-id>.<operation-id>.");
+  }
+  return {
+    capabilityId: target.slice(0, separator),
+    operationId: target.slice(separator + 1),
+  };
+}
+
+function parseOperationTarget(target: string, ctx: Parameters<CliCommandDef["execute"]>[1]) {
+  try {
+    return splitOperationTarget(target);
+  } catch (error) {
+    ctx.fail("Invalid capability operation target.", error instanceof Error ? error.message : String(error));
+  }
+}
+
+export const apiCliCommand: CliCommandDef = {
+  name: "api",
+  description: "List, inspect, invoke, or subscribe to plugin capabilities",
+  help: {
+    usage: [
+      "api list [--kind kind]",
+      "api get <capability-id>",
+      "api invoke <capability.operation> [json-payload]",
+      "api subscribe <capability.operation> [json-payload] [--limit n]",
+    ],
+  },
+  execute: async (rawArgs, ctx) => {
+    const action = rawArgs[0] ?? "list";
+    const args = rawArgs.slice(1);
+    const services = await ctx.initServices();
+
+    try {
+      if (action === "list") {
+        const kind = takeOption(args, "--kind");
+        const manifests = services.services.pluginRegistry.capabilities
+          .manifests()
+          .filter((manifest) => !kind || manifest.kind === kind);
+        ctx.printResult({ data: manifests }, {
+          rows: (data) => data.map((manifest) => ({
+            id: manifest.id,
+            kind: manifest.kind,
+            name: manifest.name,
+            operations: manifest.operations.map((operation) => operation.id).join(", "),
+          })),
+          columns: [
+            { key: "id", header: "Capability" },
+            { key: "kind", header: "Kind" },
+            { key: "name", header: "Name" },
+            { key: "operations", header: "Operations" },
+          ],
+        });
+        return;
+      }
+
+      if (action === "get") {
+        const capabilityId = requireArg(args[0], "Usage: gloomberb api get <capability-id>", ctx);
+        const manifest = services.services.pluginRegistry.capabilities
+          .manifests()
+          .find((entry) => entry.id === capabilityId);
+        if (!manifest) ctx.fail(`Capability "${capabilityId}" is not available.`);
+        ctx.printResult({ data: manifest });
+        return;
+      }
+
+      if (action === "invoke") {
+        const target = requireArg(args[0], "Usage: gloomberb api invoke <capability.operation> [json-payload]", ctx);
+        const operationTarget = parseOperationTarget(target, ctx);
+        const payload = parseJsonPayload(args[1], ctx);
+        const data = await services.services.pluginRegistry.capabilities.invoke(
+          operationTarget.capabilityId,
+          operationTarget.operationId,
+          payload,
+        );
+        ctx.printResult({ data });
+        return;
+      }
+
+      if (action === "subscribe") {
+        const target = requireArg(args[0], "Usage: gloomberb api subscribe <capability.operation> [json-payload] [--limit n]", ctx);
+        const operationTarget = parseOperationTarget(target, ctx);
+        const limit = ctx.cliOptions.limit ?? 10;
+        const payload = parseJsonPayload(args[1], ctx);
+        let count = 0;
+        let subscriptionId: string | null = null;
+        await new Promise<void>(async (resolve, reject) => {
+          try {
+            subscriptionId = await services.services.pluginRegistry.capabilities.subscribe(
+              operationTarget.capabilityId,
+              operationTarget.operationId,
+              payload,
+              (event) => {
+                count += 1;
+                ctx.printResult({ data: event });
+                if (count >= limit && subscriptionId) {
+                  services.services.pluginRegistry.capabilities.unsubscribe(subscriptionId);
+                  resolve();
+                }
+              },
+            );
+          } catch (error) {
+            reject(error);
+          }
+        });
+        return;
+      }
+
+      ctx.fail("Usage: gloomberb api list|get|invoke|subscribe");
+    } finally {
+      services.destroy();
+    }
+  },
+};

package/src/cli/commands/automation.ts

@@ -0,0 +1,173 @@
+import { detectProviders, getAiProvider } from "../../plugins/builtin/ai/providers";
+import { runAiPrompt } from "../../plugins/builtin/ai/runner";
+import { createRssNewsCapability } from "../../plugins/builtin/news/wire/rss/source";
+import type { CliCommandDef } from "../../types/plugin";
+import { requireArg, takeOption } from "./command-utils";
+
+function deferredResult(command: string, code: "auth_required" | "not_implemented", message: string) {
+  return {
+    command,
+    status: code,
+    code,
+    message,
+  };
+}
+
+export const brokerCliCommand: CliCommandDef = {
+  name: "broker",
+  aliases: ["brokers"],
+  description: "Inspect broker profiles and guarded broker operations",
+  help: { usage: ["broker list", "broker status", "broker add|edit|remove|connect|sync"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "list";
+    const services = await ctx.initServices();
+    try {
+      if (action === "list" || action === "status") {
+        const rows = services.config.brokerInstances.map((instance) => ({
+          id: instance.id,
+          type: instance.brokerType,
+          label: instance.label,
+          enabled: instance.enabled !== false,
+          connectionMode: instance.connectionMode ?? "",
+          lastSyncedAt: instance.lastSyncedAt ? new Date(instance.lastSyncedAt).toISOString() : "",
+        }));
+        ctx.printResult({ data: rows });
+        return;
+      }
+
+      ctx.printResult({
+        data: deferredResult("broker", "not_implemented", "Broker mutation and connection commands need shared non-UI broker service extraction before they can safely run headless."),
+      });
+    } finally {
+      services.destroy();
+    }
+  },
+};
+
+export const ibkrCliCommand: CliCommandDef = {
+  name: "ibkr",
+  description: "Guarded IBKR account, order preview, and order action commands",
+  help: { usage: ["ibkr accounts|positions|orders|preview|place|cancel"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "status";
+    const profile = takeOption(args, "--profile");
+    const account = takeOption(args, "--account");
+    if ((action === "place" || action === "cancel") && (!profile || !account || !ctx.cliOptions.yes)) {
+      ctx.fail(`ibkr ${action} requires --profile, --account, and --yes.`);
+    }
+    const services = await ctx.initServices();
+    try {
+      const ibkrProfiles = services.config.brokerInstances.filter((instance) => instance.brokerType === "ibkr");
+      if (action === "accounts" || action === "status") {
+        ctx.printResult({ data: ibkrProfiles.map((instance) => ({
+          id: instance.id,
+          label: instance.label,
+          enabled: instance.enabled !== false,
+          connectionMode: instance.connectionMode ?? "",
+          lastSyncedAt: instance.lastSyncedAt ? new Date(instance.lastSyncedAt).toISOString() : "",
+        })) });
+        return;
+      }
+      ctx.printResult({
+        data: {
+          ...deferredResult("ibkr", "not_implemented", "IBKR trading commands are registered with safety gates, but headless order/account service extraction is still required."),
+          action,
+          profile: profile ?? null,
+          account: account ?? null,
+          dryRun: ctx.cliOptions.dryRun,
+          confirmed: ctx.cliOptions.yes,
+        },
+      });
+    } finally {
+      services.destroy();
+    }
+  },
+};
+
+export const aiCliCommand: CliCommandDef = {
+  name: "ai",
+  description: "Inspect AI providers and run guarded headless AI prompts",
+  help: { usage: ["ai providers", "ai ask [--provider id] <prompt>", "ai screen list|show|delete|refresh|export"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "providers";
+    if (action === "providers") {
+      ctx.printResult({ data: detectProviders().map((provider) => ({
+        id: provider.id,
+        name: provider.name,
+        command: provider.command,
+        available: provider.available,
+      })) });
+      return;
+    }
+    if (action === "ask") {
+      const rawArgs = args.slice(1);
+      const providerId = takeOption(rawArgs, "--provider") ?? detectProviders().find((provider) => provider.available)?.id;
+      const provider = getAiProvider(providerId);
+      if (!provider) ctx.fail("Unknown AI provider.");
+      const selectedProvider = provider;
+      if (!selectedProvider.available) ctx.fail(`${selectedProvider.name} is not installed or not available in PATH.`);
+      const prompt = rawArgs.join(" ").trim();
+      if (!prompt) ctx.fail("Usage: gloomberb ai ask [--provider id] <prompt>");
+      const controller = runAiPrompt({ provider: selectedProvider, prompt, cwd: process.cwd() });
+      const text = await controller.done;
+      ctx.printResult({ data: { provider: selectedProvider.id, text } });
+      return;
+    }
+    if (action === "screen") {
+      ctx.printResult({
+        data: deferredResult("ai screen", "not_implemented", "AI screener tabs are still pane-state backed; expose them through a shared non-UI screener store before headless mutation."),
+      });
+      return;
+    }
+    ctx.fail("Usage: gloomberb ai providers|ask|screen");
+  },
+};
+
+export const rssCliCommand: CliCommandDef = {
+  name: "rss",
+  description: "Fetch an RSS feed as news rows",
+  help: { usage: ["rss fetch <url> [--name label]"] },
+  execute: async (args, ctx) => {
+    const action = args[0] ?? "fetch";
+    if (action !== "fetch") ctx.fail("Usage: gloomberb rss fetch <url> [--name label]");
+    const rawArgs = args.slice(1);
+    const name = takeOption(rawArgs, "--name") ?? "RSS";
+    const url = requireArg(rawArgs[0], "Usage: gloomberb rss fetch <url> [--name label]", ctx);
+    const capability = createRssNewsCapability([{
+      id: "cli-feed",
+      url,
+      name,
+      category: "cli",
+      authority: 50,
+      enabled: true,
+    }]);
+    const articles = await capability.provider.fetchNews({ feed: "latest", limit: ctx.cliOptions.limit ?? 20 });
+    ctx.printResult({ data: articles.map((article) => ({
+      title: article.title,
+      source: article.source,
+      publishedAt: article.publishedAt.toISOString(),
+      url: article.url,
+      summary: article.summary ?? "",
+    })) });
+  },
+};
+
+function cloudCommand(name: string, description: string): CliCommandDef {
+  return {
+    name,
+    description,
+    execute: (_args, ctx) => {
+      ctx.printResult({
+        data: deferredResult(name, "auth_required", "This command needs an existing cloud/session token. New auth/account/chat CLI workflows are deferred in this pass."),
+      });
+    },
+  };
+}
+
+export const cloudCliCommands: CliCommandDef[] = [
+  cloudCommand("buildout", "Fetch Buildout company data through an existing cloud session"),
+  cloudCommand("congress", "Fetch congressional trade data through an existing cloud session"),
+  cloudCommand("substack", "Fetch Substack reader data through an existing session"),
+  cloudCommand("x-feed", "Fetch X/Twitter feed data through an existing cloud session"),
+  cloudCommand("tweets", "Alias for x-feed"),
+];

package/src/cli/commands/command-utils.ts

@@ -0,0 +1,53 @@
+import type { CliCommandContext } from "../../types/plugin";
+
+export function takeOption(args: string[], name: string): string | undefined {
+  const equalsPrefix = `${name}=`;
+  const equalsIndex = args.findIndex((arg) => arg.startsWith(equalsPrefix));
+  if (equalsIndex >= 0) {
+    const [value] = args.splice(equalsIndex, 1);
+    return value!.slice(equalsPrefix.length);
+  }
+
+  const index = args.indexOf(name);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  args.splice(index, value == null ? 1 : 2);
+  return value;
+}
+
+export function takeFlag(args: string[], name: string): boolean {
+  const index = args.indexOf(name);
+  if (index < 0) return false;
+  args.splice(index, 1);
+  return true;
+}
+
+export function parseJsonPayload(value: string | undefined, ctx: CliCommandContext): unknown {
+  if (!value) return {};
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    ctx.fail("Payload must be valid JSON.", error instanceof Error ? error.message : String(error));
+  }
+}
+
+export function parsePositiveInt(value: string | undefined, fallback: number, label: string, ctx: CliCommandContext): number {
+  if (value == null || value === "") return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    ctx.fail(`${label} must be a positive integer.`);
+  }
+  return parsed;
+}
+
+export function requireArg(value: string | undefined, usage: string, ctx: CliCommandContext): string {
+  if (!value) ctx.fail(usage);
+  return value;
+}
+
+export function isoDate(value: unknown): string {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "number") return new Date(value).toISOString();
+  if (typeof value === "string") return value;
+  return "";
+}